/Users/craigcornelius/Projects/SPRING Mac Release 0.2/node.h

Go to the documentation of this file.

// $Id: node.h,v 1.69 2006/05/24 16:52:41 sean Exp $
// $Copyright: (c)2001 National Biocomputation Center, Stanford University $

#ifndef Node_H
#define Node_H

#include "util.h"
#include "point3d.h"
#include "reallocablearray.h"
//#include "boundingsphere.h"

// Note: no more MAXDEGREE- now edges and faces arrays are ReallocableArrays

class Edge;
class Face;
class Tetra;
class NodeArray;
class BoundingSphereLeaf;

class Node
{
public:                        
    // publicly used vars
    Point3D p;           // position
    Point3D init_pos;    // initial position
    Point3D v;           // velocity
    Point3D p_old;       // these are used in RK2 and RK4, for now
    Point3D v_old;
    Point3D p_mid;
    Point3D v_mid;
    Point3D p_mid2;
    Point3D v_mid2;
    Point3D delta;                     // for hacky use in findFaceCollisions
    
    // indicates whether a node has fixed position or velocity or neither
    enum Fixtype {NOT, POS, VEL};
    
    // indicates what type of texture coord model we have
    enum texture_coord_type {linear, cylindrical, spherical};    
    
    BoundingSphereLeaf* boundingsphere;
    
private:
    Point3D n;                         // normals
    Point3D f;                         // total force applied to this node
    Point3D f_ext;                     // external force applied to this node
    Point3D t;                         // texture coordinates

    Point3D edge_sum;                  // sum of the edge vectors surrounding this node
        Point3D init_edge_sum;             // initial sum of the ed...
  
        Node* tie_node;                                  // other node we are tied to
   
        int skipnum;                       // steps of force recalculation to skip
    double mass;
    double velocityDampConstant;       // for viscous (ABSolute) damping
   
        Fixtype fixed;
    
        ReallocableArray<Edge*> edges;    // reallocable array of edge pointers
    ReallocableArray<Face*> faces;    // reallocable array of face pointers
        ReallocableArray<Tetra*> tetras;        // reallocable array of tetra pointers

        int part_id;                                            // for vertex coloring/subobjects
    int level;
    long cached_index;    // for fast index lookup:see NodeArray::CacheIndices
    
    NodeArray* nodearray_p;
    
    Node* collision;    // FOR TESTING- who we're colliding with
    
public:
    Node();
    ~Node();
    static const char* rcsid;
    static int debug;
    static double deltatime;   // make timestep a static class member
    
    // initialization
    int init(NodeArray* nodearray_p, char* initString);
    int init(NodeArray* nodearray_p, double x_in, double y_in, double z_in, 
        double nx_in=0.0, double ny_in=0.0, double nz_in=1.0,    // normal
        double vx_in=0.0, double vy_in=0.0, double vz_in=0.0, // velocity
        double u_in=0.0, double v_in=0.0,            // texture coords
        Fixtype fixed_in=NOT, double mass_in=1.0);    // misc
    
    BoundingSphereLeaf* getBoundingSphere();
    void setBoundingSphere(BoundingSphereLeaf* sphere);
    Point3D getCenter();
    double getRadius();
    
    // topology/link routines
    int getIndex(void);
    void setCachedIndex(long index);
    long getCachedIndex();

        int isConnectedTo(Node* n);

    int IsOnTheBorder(void);
    int is_on_the_border();

    void addEdgeLink(Edge *e);
    void deleteEdgeLink(Edge *e);
    Edge* getEdgeLink(int index);
    Edge* findEdgeLink(Node* adjacentNode);
    int hasEdgeLink(Edge* e);
    int numEdgeLinks();
    Edge *is_adjacent_to(Node* n);

    void addFaceLink(Face *f);
    void deleteFaceLink(Face* f);
    Face* getFaceLink(int index);
    int numFaceLinks();
    int hasFaceLink(Face* f);
        Face* isAFaceWith(Node* n0, Node* n1);

        void addTetraLink(Tetra *t);
        void deleteTetraLink(Tetra* t);
        Tetra* getTetraLink(int index);
        int numTetraLinks();
        int hasTetraLink(Tetra* t);


    NodeArray* getNodeArray(void) {return nodearray_p;}

    Point3D getNormal();
    Point3D getCurvature();

    void setNewStableInitPos(Point3D newpos);

    Node* FindClosestAdjacentNode(Point3D p);
    Node* FindClosestAdjacentNodeToFace(Face* f_p);

    int SanityCheck(NodeArray* na_p);    // returns 1 if ok
    
    // simulation stuff
    void setF(Point3D force) {f = force;}
    Point3D getF(void) {return f;}
    void setFext(Point3D force) {f_ext = force;}
    Point3D getFext(void) {return f_ext;}
    void addForce(Point3D force) {f = f + force;}

    double getEnergy(void);
    double getMass();
    void setMass(double mass);

    double getVelocityDampConstant();
    void setVelocityDampConstant(double value);

    void setFixedType(Fixtype fixed);
    Fixtype getFixedType(void) {return fixed;}

    void findPosition(void);
    void findFSAEverything(double elapsed_time);
    void findVelocity(void);
    void findMidpointRK(void);
    void findMidpoint2RK4(void);
    void findGuessRK4(void);
    void findFinalRK2(void);
    void findFinalRK4(void);
    //  void findFSAForce(void);

        
        void findForceFromEdges(int damped);
        void findForceDampFull();
        void findForceDampRel(void);
        void findForceDampAbs(void);
    
        // This is an older, less efficient method, but it works.
    void findForce(int damped);

        // For quasistatic computations.  No damping used.
    Point3D findSpringForce(void);
        void findQuasiForceFromEdges(void);


    void forceDisplace(double scale);

    void moveTestLine(Node *n1, Node *n2);

    // decimation handling
    void Adjacents(Node *adjacents[]);
    void AdjacentsSort(Node *set[], int setSize, Point3D normal, int *initTest, 
        int headIndex);

    void SetOutput(Node *set[], Node *output[], int testConcavity, int setSize);
 
        void ClipEar(int i, int n, Node* poly[], int labels[]);
    void PointAssign(Node* n);
    bool Diagonal(int i, int j, int n, Node* poly[], Point3D normal);
    bool InCone(int i, int j, int n, Node* poly[], Point3D normal);
    bool Diagonalie(int i, int j, int n, Node* poly[], Point3D normal);
    bool Intersect(Node* b, Node* c, Node* d, Point3D normal);
    bool Between(Node* b, Node* c, Point3D normal);
    bool IntersectProp(Node* b, Node* c, Node* d, Point3D normal);
    bool Left(Node* a, Node* b, Point3D normal);
    bool LeftOn(Node* a, Node* b, Point3D normal);
    bool Colinear(Node* a, Node* b);
    double SignedArea(Node* a, Node* b, Point3D normal);
    
    // collision handling
    int processCollisions(NodeArray* na_p);
    void resetCollisions();
    void setCollisionNode(Node* n);
    Node* getCollisionNode();
    double DistanceToAnyOfMyFaces(Point3D pt);
    
    // graphics
    void computeInitialEdgeSum();
    void interpolateNormal(void);
        void interpolateTetraNormal();
    void draw(int do_color, int do_objectwide_color, int do_texture);
    void drawlabel(float offset);
    void drawover(double scale);
    void drawnormal();
    void drawinitial();
    void drawtienode();
    void computeTextureCoords(texture_coord_type textype);
    Point3D getTextureCoords();
    void setTextureCoords(double u, double v);
                void setTextureCoords(Point3D tc);
    
    // for vertex coloring/subobjects
    int getPartId();
    void setPartId(int part_id_in);  
    void SpreadColor(int new_color);
    Node* FindColoredAdjacentNode(int color);
    Node* FindDifferentColoredAdjacentNode(int color);
    void ColorMeshForSplitAtNode(Node* other_node);
    Node* SplitColoredMeshAtNode(Node* other_node);
    
    // for helping ordered numerical methods?
    int getLevel();
    void setLevel(int level_in);
    
    // misc
    void setTieNode(Node* other_node);
    Node* getTieNode();
                //mass distribution
                double VoronoiArea(); 
                double TriPointArea(Point3D one, Point3D two, Point3D three); 
                void OrderFaces(Face **orderme, int cur_index);
                Point3D ClosestIntersect(Point3D p1, Point3D p2, Point3D p3, Point3D p4);
    
    // output
    void Print();
    void SaveAsMesh(ostream& os);
    friend ostream& operator<<(ostream& os, const Node& n);
};

inline BoundingSphereLeaf* Node::getBoundingSphere()
{ return(boundingsphere); }

inline void Node::setBoundingSphere(BoundingSphereLeaf* sphere)
{ boundingsphere = sphere; }

inline Point3D Node::getCenter()
{ return (p); }

inline double Node::getRadius()
{ return (0.0); }

inline Edge* Node::getEdgeLink(int index)
{
    if ((index < 0) || (index >= edges.NumElements()))
        return(NULL);
    else return(edges[index]);
}

inline int Node::hasEdgeLink(Edge* e)
{
    for (int i=0; i<edges.NumElements(); i++)
        if (edges[i] == e) return(1);
        return(0);
}

inline int Node::numEdgeLinks()
{ return (edges.NumElements()); }

inline Face* Node::getFaceLink(int index)
{
    if ((index < 0) || (index >= faces.NumElements()))
        return(NULL);
    else return(faces[index]);
}

inline int Node::numFaceLinks()
{ return(faces.NumElements()); }

inline int Node::hasFaceLink(Face* f)
{
    for (int i=0; i<faces.NumElements(); i++)
        if (faces[i] == f) return(1);
        return(0);
}

inline int Node::hasTetraLink(Tetra* t)
{
  for (int i=0; i<tetras.NumElements(); i++)
        if (tetras[i] == t) return(1);
  return(0);
}

inline Tetra* Node::getTetraLink(int index)
{
  if ((index < 0) || (index >= tetras.NumElements()))
    return(NULL);
  else return(tetras[index]);
}

inline double Node::getMass()
{ return(mass); }

inline void Node::setMass(double mass_in)
{ mass = mass_in; }

inline double Node::getVelocityDampConstant()
{ return(velocityDampConstant); }

inline void Node::setVelocityDampConstant(double value)
{ velocityDampConstant = value; }

inline Point3D Node::getNormal()
{ return(n); }

inline void Node::resetCollisions()
{ collision = NULL; }

inline Node* Node::getCollisionNode()
{ return(collision); }

inline void Node::setCollisionNode(Node* n)
{ collision = n; }

inline void Node::setFixedType(Fixtype fixed_in)
{ fixed = fixed_in; }

inline int Node::getPartId()
{ return(part_id); }

inline void Node::setPartId(int part_id_in)
{ part_id = part_id_in; }

inline int Node::getLevel()
{ return(level); }

inline void Node::setLevel(int level_in)
{ level = level_in; }

inline void Node::setCachedIndex(long index)
{ cached_index = index; }

inline long Node::getCachedIndex()
{ return(cached_index); }

inline Point3D Node::getTextureCoords()
{ return(t); }

inline void Node::setTextureCoords(Point3D tc)
{ t = tc; }

inline void Node::setTextureCoords(double u, double v)
{ t.x = u; t.y = v; t.z = 1.0; }

inline void Node::setTieNode(Node* other_node)
{ tie_node = other_node; }

inline Node* Node::getTieNode()
{ return(tie_node); }

#endif

---