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

Go to the documentation of this file.

// $Id: nodearray.h,v 1.86 2006/05/24 16:51:18 sean Exp $
// $Copyright: (c)2001 National Biocomputation Center, Stanford University $

#ifndef NodeArray_H
#define NodeArray_H

#include "util.h"
#include "point3d.h"
#include "node.h"
//#include "edgearray.h"
#include "reallocablearray.h"
#include "geometryreplicator.h"
#include "matrix.h"
#include <string.h>
#include <stdio.h>

class Node;
class EdgeArray;
class FaceArray;
class Object;
typedef ReallocableArray<int>   sbb_t;

typedef enum {grab, pierce, collide} Constraint_type;
typedef enum {FULL, REL, ABS, NONE} Damping_type;


typedef struct {
    int index; // index of the thread node which is constrained
    Constraint_type type;
    Node *n;   // node to which it is constrained    (if pierce type)
    int whichpierce; // index for pierce array       (if pierce type)
    Edge *e;   // or edge to which it is constrained (if collide type)
    double w0, w1; // weights of nodes for Edge e    (if collide type)
    int whichcollide; // index for collide array     (if collide type)
} Thread_constraint;

/* if this is #def'ed to 0, there will be no torsion */
//#define TORSION_FORCE 0.0001
#define TORSION_FORCE 0
typedef enum{ RIGHT, LEFT, FRONT, BACK, UP, DOWN } wall_pos;
#define RIGIDNEEDLE 10  // for use only with needle/thread
Point3D ApplyMatrix(Point3D e1, Point3D e2, Point3D e3, Point3D v);

class NodeArray
{
private:
    int numnodes, maxnodes;
    Node* *nodes;
    Node* *orderedNodes;          // for defining special order to evaluate
    int highlevel;              // level of useful ordering
    int highnode;                 // also for ordering nodes
    char nodefilename[MAXLINE];
    Point3D min, max;           // bounding box
    Point3D init_min, init_max; // bounding box of initial data
    Point3D center;             // center of nodes (average)
    Point3D cg;                 // center of gravity (uses mass of each)

        Point3D center_bounding_box;   // center of bounding box (inbetween min and max)
    double radius;              // actually length of principle axis

        Point3D dimension;      // The dimension of the eobjct (width, length, height of bounding box)
    sbb_t        sbb[4][4][4];  // sub bounding boxes (volumetric decomposition)
    double convergence_factor;
        double U[3][3]; //SVD matrix eigenvectors in columns
        double sig[3];  //SVD eigenvalues
    
    // links to parallel arrays
    EdgeArray* edgearray_p;
    Object* object_p;
    
    Damping_type damping_type;
    
    // internal functions
    static void updateNodes_thread(void* in);           // for parallelism
    static void findPositionThreads(int,int,void*);
    static void findVelocityThreads(int,int,void*);
    static void findForceThreads(int,int,void*);

        static void findMidpointRKThreads(int thread_index, int max_threads, 
                                                                          void* data);
        static void findFinalRK2Threads(int thread_index, int max_threads, 
                                                                          void* data);
        static void findfindMidpoint2RK4Threads(int thread_index, int max_threads, 
                                                                          void* data);
        static void findGuessRK4Threads(int thread_index, int max_threads, 
                                                                          void* data);
        static void findFinalRK4Threads(int thread_index, int max_threads, 
                                                                          void* data);
        static void forceDisplacementThreads(int thread_index, int max_threads, 
                                 void* data);
        static void FSAThreads(int thread_index, int max_threads, void* data);

public:
    NodeArray(Object* object_p_in);
    ~NodeArray();
    
    static const char* rcsid;
    
    void Init(EdgeArray* edgearray_p_in);
    void reset(void);
    int getNumNodes(void);
    Object* getObject();
    EdgeArray* getEdgeArray();
    
    // public variables
    static int debug;
    int orderedNodesFlag;         // has this order been defined? public, lazy
    
    // statistics/useful values
    void computeStats();
    void getBoundingBox(Point3D* min_p, Point3D* max_p);
    void getInitialBoundingBox(Point3D* imin_p, Point3D* imax_p);
    double getRadius();

        Point3D getDimension();
    Point3D getCenter();
    Point3D getCenterOfGravity();

        Point3D getCenterOfBoundingBox();
    void spread2(double kx, double ky, double kz) ;
    
    void rotate90(int axis = 0) { rotate(axis);}
    void rotate(int axis = 0, double t = PI/2);
    void spread(double kx, double ky, double kz);
    void translate(double kx, double ky, double kz);
    Point3D getHorizontalVector();
    Point3D getVerticalVector();
    void refresh();
    void pivote(wall_pos dir);
    void stretch(wall_pos dir);
    void twist(wall_pos dir);
        void PrincipalAxes();
        void getUmatrix(double newU[3][3]);
    
    // File I/O routines
    void setNodeFilename(char *s);
    int getMeshNodeData(FILE *meshfile);     // used with mesh files
    int getSMFNodeData(FILE *meshfile);     // used with SMF files
    int getOBJNodeData(FILE *meshfile);     // used with OBJ files (Wavefront)
    int getNodeData(void);                   // used with node/edge files
    int getAmiraNodeData(FILE *meshfile, int numnodes_given);     // used with Amira files
    
    void SaveMeshNodeData(ostream& os);
    void SaveSMFNodeData(ostream& os);
    void SaveVRMLNodeData(ostream& os);
    void SaveAmiraNodeData(ostream& os);
    void SaveVRMLNormalData(ostream& os);
    
    // handy helpers
    Node *getNode(int i);
    int getIndex(Node* n);
    void CacheIndices();
    friend ostream& operator<<(ostream & out, const NodeArray &na);
    
    // dynamic creation routines
    void allocateNodes(int max_num_nodes);
    int addNode(Point3D p);
    
    // methods which iterate over all numnodes of the Nodes in nodes[]
    void DrawNodes();
    void drawlabels(float offset);
    void drawnormals();
    void drawinitial();
    void drawtienodes();
    int updateNodes(void);      // returns whether nodes moved
    int updateNodesRigid(void); // returns whether nodes moved
    // these are specifically for an articulate edge object (ie thread)
    void updateArticulateEdge(void);
    double findThreadSlack(int start_node, int end_node);
    double findMaxStretch(int start_node, int end_node);
    int whichConstraint(int i, Thread_constraint *constraints,
        int numconstraints);
    void updateArticulateSections(Thread_constraint *constraints,
        int numconstraints);
    void updateArticulateUpOrDown(int start_node, int end_node, int average=0);
    void updateThread(void);
    void FollowTheLeader(int start_node, int end_node, int average=0);
    
    void moveNodesOfPart(int part, Point3D motion_vector, int absolute=0);
    void xformNodesOfParts(ReallocableArray<Matrix> parts_matrices, 
        ReallocableArray<Point3D> prerot_trans,
        ReallocableArray<Point3D> postrot_trans);
    void xformNodesOfPart(int part, Matrix matrix, Point3D offset, 
        Point3D new_origin);  // part=-1= everything
    void resetInitialPosition();
    void setToInitialPosition();
    void setFext(Point3D force);
    void setVelocityDampConstants(double value);
    void setMasses(double value);
    void processCollisions(NodeArray* na);
    void resetCollisions();
    void printInfo(void);
    void computeInitialEdgeSums(void);
    void interpolateNormals(void);
    void interpolateTetraNormals(void);
    double getEnergy(void);
    double findError(void);
    void DeleteNode(Node* n);
    void DeleteNode(int index);
    void EraseNode(Node* n, Node *adjacents[]);
    void DeleteAllNodes();
    void computeTextureCoords(Node::texture_coord_type textype);
    void moveTexture(Point3D translation, Point3D scaling);
    void SanityCheck(Object* o_p);
    double CumulativeDistanceToSurface(FaceArray* fa_p);
    void multiplyNodes(double value);
    void ScaleByNormal(double value);
    int findClosestNode(Point3D pt);
    int findCollisionNode(Point3D pt);
    double findClosestNodesBetweenNodeArrays(NodeArray* other_na, 
        Node** our_node_p, Node** other_node_p);
    void TieNodesToClosestInNodeArray(NodeArray* other_na);
    void MakeEdgeToClosestInNodeArray(NodeArray* other_na);
                void redistributeMass();
        void RedistributeSubset(); //on the fly distribution
        void RedistributeTetraSubset();
        void RedistributeSurfaceSubset();
    

    // "color" (segmentation) routines (0 implies not colored=unused)
    int getNumDifferentColors();
    int getNumNodesOfColor(int color);
    int VertexColor();
    void OrderNodes(Node *n, int keepCurrentGrabs = 1);
    void ResetColors(int color);
    void ResetLevels(int level);
    void SplitColor(Face* splitting_face);
    void DeleteNodesOfColor(int color);
    void FixNodesOfColor(int color);
    void getColorBoundingBox(int color, Point3D* min_p, Point3D* max_p);
    void ColorNodesWithinBoundingBox(Point3D min, Point3D max, int color);
    int SpreadOutColor();
    int CompressDuplicateNodes(double dist);
    
    void setDampingType(int dtype);
    int getDampingType();
    
    void GeometryReplicate(GeometryReplicator* gr);
};

inline int NodeArray::getNumNodes(void) 
{return numnodes;}

inline void NodeArray::getBoundingBox(Point3D* min_p, Point3D* max_p) 
{ *min_p = min, *max_p = max; }

inline void NodeArray::getInitialBoundingBox(Point3D* imin_p, Point3D* imax_p) 
{ *imin_p = init_min, *imax_p = init_max; }

inline double NodeArray::getRadius()
{ return(radius); }


inline Point3D NodeArray::getDimension()

{ return dimension; }


inline Point3D NodeArray::getCenter()
{ return(center); }

inline Point3D NodeArray::getCenterOfGravity()
{ return(cg); }


inline Point3D NodeArray::getCenterOfBoundingBox()

{ return center_bounding_box; }


inline void NodeArray::setNodeFilename(char *s) 
{ strcpy(nodefilename, s); }

inline Node* NodeArray::getNode(int i) 
{ return (nodes[i]); }

inline Object* NodeArray::getObject()
{ return (object_p); }

inline EdgeArray* NodeArray::getEdgeArray()
{ return (edgearray_p); }

inline void NodeArray::setDampingType(int dtype)
{ damping_type = Damping_type(dtype); }

inline int NodeArray::getDampingType()
{ return (damping_type); }

inline void NodeArray::getUmatrix(double newU[3][3])
{ for(int i=0;i<3;i++)for(int j=0;j<3;j++)newU[i][j]=U[i][j];}

#endif

---