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

Go to the documentation of this file.

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

#ifndef Edge_H
#define Edge_H

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

class Node;
class Face;
class Tetra;
class NodeArray;
class EdgeArray;
class BoundingSphereLeaf;

class Edge
{
private:
    // every edge connects 2 nodes
    Node *node[2];
    
    ReallocableArray<Face*>  face;      // reallocable array of face pointers
    ReallocableArray<Tetra*> tetra;     // reallocable array of tetra pointers
    
    // physical properties
    double init_angle;         // initial angle between its 2 faces
    
    double restLength;
    double springConstant;
    double dampConstant;
    double marker;                // -1: no collision, [0,1]: collision param
    int cutting_marker;
    
    BoundingSphereLeaf* boundingsphere;
    // access to the dispenser class
    EdgeArray* edgearray_p;
    
    Node* splitNode[2];
    
public:
        Point3D force;  // The force from the 1st to 2nd node.  Public for quick access.

public:
    Edge();
    ~Edge();
    static const char* rcsid;
    static int debug;
    
    // initialization
    int init(NodeArray* nodearray_p, EdgeArray* edgearray_p_in,
        char *initString);
    int init(NodeArray* nodearray_p, EdgeArray* edgearray_p_in,
        int i1, int i2, double restLength=-1.0, 
        double springConstant=1.0, double dampConstant=0.5);
    int init(NodeArray* nodearray_p, EdgeArray* edgearray_p_in,
        Node* n1, Node* n2, double restLength=-1.0, 
        double springConstant=1.0, double dampConstant=0.5);
    
    // handy functions
    int getIndex(void);
    
    EdgeArray* getEdgeArray();
    
    int SanityCheck(EdgeArray* real_ea_p);
    
    friend ostream& operator<<(ostream& os, const Edge& e);
    
    BoundingSphereLeaf* getBoundingSphere();
    void setBoundingSphere(BoundingSphereLeaf* sphere);
    Point3D getCenter();
    
    double getRadius();
    
    // links to other arrays
    Node* getOtherNode(Node *n);
    Node* getNodeLink(int which);       // 0,1
    void replaceNodeLink(Node* old_node, Node* new_node);
    int hasNodeLink(Node* n);
    
    Face* getFaceLink(int which);       // 0,1
    Face* getOtherFace(Face* f);
    int numFaceLinks();
    void addFaceLink(Face* f);
    void deleteFaceLink(Face* f);
    int hasFaceLink(Face* n);
    
    Tetra* getTetraLink(int index);
    int numTetraLinks();
    void addTetraLink(Tetra *t);
    void deleteTetraLink(Tetra* t);
    int hasTetraLink(Tetra* t);
    
    int intersectsPlaneSweptByCuttingEdge(Edge* e_in, Point3D* intersection_p);
    int intersectsPlaneSweptFromEntryPt(Point3D entPt, Edge* cuttingEdge,Point3D
        *intPt);
    int stepOffVerts(Point3D intPt);
    
    Node* getSplitNode(int which);
    void setSplitNodes(Node* node0, Node* node1);
    
    void interpolateTextureCoords(Node* n0, Node* n1);  
    
    int isAdjacent(Edge* e);
    
    // simulation functions
    double getAngle(void);    // gets current angle between faces
    void addTorsion(void);
    double getLength(void);
    double getEnergy(void);
    double getRestLength(void);
    void setRestLength(double distance);
    void scaleRestLength(double scalefactor);
    void computeNewRestLength();
    void scaleRestingLengthFrom(Edge* oldEdge);
    
    
    double getSpringConstant(void);
    void setSpringConstant(double value, int restLengthScale = 0);
    double getDampConstant(void);
    void setDampConstant(double value);
    Point3D UnitDirectionVector(void);
    double EdgeDistanceToPoint(Point3D pt, double *near1 = NULL);
    double EdgeDistanceToEdge(Edge* e2, double *near1 = NULL, 
                              double *near2 = NULL);
    double EdgeDistanceToFaceNoIntersect(Face* f, double *near1, 
                                         Point3D *nearpt);
    void setMarker(double value);
    void setCuttingMarker(int value);

        void ComputeSpringForce(int dampingType);
        void ComputeSpringForceFullDamp(void);
        void ComputeSpringForceRelDamp(void);
    
        void ComputeSpringForceNonlinear(int dampingType);

    // graphics functions
    void draw();
    void drawover(double scale);
    void drawInitial();
    void drawlabel(float offset);
    int crossesPlane(double a, double b, double c, double d, 
        Point3D *intersection_p);
    int crossesPlane(Point3D p1, Point3D p2, Point3D p3, Point3D *intPt);

    // collision functions
    void ResolveMyself(Edge* other_edge);
        
};

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

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

inline Point3D Edge::getCenter()
{ return ((node[0]->p + node[1]->p)/2.0); }

inline Node* Edge::getNodeLink(int which) 
{ if ((which < 0) || (which >= 2)) return(NULL);
else return(node[which]);
}

// This function returns the current length of this Edge 
inline double Edge::getLength(void)
{
    Point3D diff = getNodeLink(1)->p - getNodeLink(0)->p;
    return (diff.Length());
}

inline double Edge::getRadius()
{ return (getLength()/2.0); }

inline double Edge::getRestLength()
{ return(restLength); }

inline void Edge::setRestLength(double distance)
{ restLength = distance; }

inline void Edge::scaleRestLength(double scalefactor)
{ restLength *= scalefactor; }

inline double Edge::getSpringConstant()
{ return(springConstant); }

// restLengthScale is to scale the constant inversely with the restLength
// in order to get homogeneous behavior regardless of restLength
// eg. if F = -k(x/x0 - 1) then k is Young's modulus, a tissue constant, but
// we express F = -k(x - x0) so our k must be divided by x0 to get Young's mod.
inline void Edge::setSpringConstant(double value, int restLengthScale)
{ if (restLengthScale)
    springConstant = value/restLength;
  else 
    springConstant = value;
}

inline double Edge::getDampConstant()
{ return(dampConstant); }

inline void Edge::setDampConstant(double value)
{ dampConstant = value; }

inline void Edge::setMarker(double value)
{ marker = value; }
inline void Edge::setCuttingMarker(int value)
{ cutting_marker = value; }

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


inline int Edge::hasNodeLink(Node* n)
{
    if ((node[0] == n) || (node[1] == n)) return(1);
    return(0);
}

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

inline int Edge::numFaceLinks() 
{ return(face.NumElements()); }

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

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

// this is called with a Node, and will return the other Node that this Edge
// is connected to, or NULL if this Edge is not connected to Node argument 
inline Node *Edge::getOtherNode(Node *n)
{
    if (n == node[0]) return node[1];
    else if (n == node[1]) return node[0];
    else return (NULL);
}

// this returns 1 if this is adjacent to e via a node, 0 else
inline int Edge::isAdjacent(Edge *e)
{
    if (node[0]->hasEdgeLink(e) || node[1]->hasEdgeLink(e))
        return(1);
    return(0);
}

// make a label containing the face num
inline void Edge::computeNewRestLength()
{
    setRestLength(getLength());
}
inline void Edge::setSplitNodes(Node* node0, Node* node1)
{splitNode[0] = node0; splitNode[1] = node1;}

inline Node* Edge::getSplitNode(int which)
{return splitNode[which];}
inline void Edge::scaleRestingLengthFrom(Edge* oldEdge)
{
    double factor = getLength()/oldEdge->getLength();
    setRestLength(factor*oldEdge->getRestLength());
}
#endif

---