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

Go to the documentation of this file.

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

#ifndef Face_H
#define Face_H


#include "point3d.h"

#include "node.h"

#include "nodearray.h"
#include "edgearray.h"
#include "facearray.h"
#include "tetraarray.h"

class Node;
class Edge;
class Tetra;
class NodeArray;
class EdgeArray;
class FaceArray;
class TetraArray;
class BoundingSphereLeaf;

class Face {
private:
    Node *node[3];
    Edge *edge[3];
    
    FaceArray* facearray_p;

        ReallocableArray<Tetra*> tetra;

    Point3D normal;

    Point3D isobary; // Iso Center of gravity
    int marker; // 0 off, 1 on
                
        Node*                           splitNode[2];
        Edge*                           splitEdge[2];
        int                      num_split_edges;
        Node*                           fakeSplitNode[2];

    
    BoundingSphereLeaf* boundingsphere;
    
public:
    Face();
    ~Face();
    static const char* rcsid;
    static int debug;
    
    void init(NodeArray* nodearray_p, EdgeArray* edgearray_p, 
        FaceArray* facearray_p, int i1, int i2, int i3);
    void init(NodeArray* nodearray_p, EdgeArray* edgearray_p, 
        FaceArray* facearray_p, Node* n1, Node* n2, Node* n3);
    void init(NodeArray* nodearray_p, EdgeArray* edgearray_p, 
        FaceArray* facearray_p, Node* n1, Node* n2, Node* n3,
        Edge* e1, Edge* e2, Edge* e3);

    int getIndex(void);
    FaceArray* getFaceArray();
    
    BoundingSphereLeaf* getBoundingSphere();
    void        setBoundingSphere(BoundingSphereLeaf* sphere);
    
    // links to other arrays
    int hasNodeLink(Node* node);
    Node* getNodeLink(int which); // 0,1,2
    Node* getOppositeNode(Edge *e);
                Node* getOtherNode(Node* n0, Node* n1);
                int getNodeIndex(Node* n);


    void replaceNodeLink(Node* old_node, Node* new_node);
    void replaceNodeLink(int which, Node* new_node);

    void replaceEdgeLink(Edge* old_edge, Edge* new_edge);
    int hasEdgeLink(Edge* edge);
    Edge* getEdgeLink(int which);       // 0,1,2
        int   getEdgeLinkIndex(Edge* edge);
        Edge* getEdge(int n0, int n1);

                Tetra* getTetraLink(int which); // 0,1
        // maybe getothertetra
        int     numTetraLinks();
        void    addTetraLink(Tetra* t);
        void    deleteTetraLink(Tetra* t);
        int     hasTetraLink(Tetra* t);
        
        int stepOffVerts(Point3D intPt);
        int stepOffEdges(Point3D intPt);
        void interpolateTextureCoords(Node* n);
        
        Node* getSplitNode(int which);
        void    setSplitNodes(Node* node0, Node* node1);
        
        Node* getFakeSplitNode(int which);
        void    setFakeSplitNodes(Node* node0, Node* node1);
        
        Edge* getSplitEdge(int which);
        void    setSplitEdge(Edge* e);
        int getNumSplitEdges();

        int                     getCase(int (&v)[9]);

    void unlink();  // unlinks face from its nodes and edges

    void getAdjacentFaces(Face** f1_p, Face** f2_p, Face** f3_p);
    int isAdjacent(Face *f);
    Edge* isEdgeAdjacent(Face *f); //looks to see if faces share edge
                Point3D getSatelite(Face *f, Node *p); //gets remaining shared point


    // reading/saving
    void SaveAsMesh(ostream& os);
    
    void setNormal(Point3D normal_in);
    void computenormal();
    Point3D getNormal();

    void draw(int do_texture);
    void drawnormal();
    void drawlabel(float offset);
    void drawmarker();
    void setMarker(int value);

    int getMarker(void);

    Point3D getCenter();
    double getRadius();
         void computeisobary();
    Point3D getIsobary();

  int intersectsPlaneSweptByCuttingEdge(Edge* e_in, Point3D* intersection_p);
        int vectorCrossesMe(Point3D P1, Point3D P2, Point3D* intPt);

    double ZVolume();
    double TetraVol(Point3D a, Point3D b, Point3D c, Point3D d);
     Point3D Projection(Point3D pt);
   int getMinZNode();

    double getArea();   // area of the triangle
    double getShadowArea();     // projection of triangle onto X-Z plane
    double getZShadowArea();    // projection of triangle onto X-Y plane

    Node *getThirdNode(Node *n1, Node *n2);
 
    double PlaneDistanceToPoint(Point3D pt);// returns signed distance to point
    double FaceDistanceToPoint(Point3D pt, int early_exit = 0, 
                               Point3D *nearpt = NULL);

    int IsColliding(Point3D pt);        
        // is having a collision
    Node* getClosestNodeInFace(Point3D pt);
                Node* getClosestNodeInFace(Point3D pt, Node *notme); //closest except notme

    void determinePlaneEq(double *a_p, double *b_p, double *c_p, double *d_p);

    int intersectsEdge(Edge *e_in, Point3D *intersection_p);
    int intersectsFace(Face *f_in, Point3D *intersection_p);

        bool intersectsEdge(Edge *edge);
    bool intersectsFace(Face *otherFace);
        bool intersectsBox(Point3D *min, Point3D *max);

    int ResolveMyself(Face *f_in);
    
    int SanityCheck(FaceArray* real_fa_p);      // returns 1 if ok
    friend ostream& operator<<(ostream& os, const Face& f);
};

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

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

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

inline double Face::getRadius()
{ double radius = 0;
Point3D cent = getCenter();
for (int i=0; i<3; i++) {
    double currad = node[i]->p.Dist(cent);
    if (currad > radius)
        radius = currad;
}
return radius;
}

inline Point3D Face::getNormal()
{ return(normal); }

inline Point3D Face::getIsobary()
{ return(isobary); }

inline Node* Face::getNodeLink(int which)
{ if ((which < 0) || (which > 3)) return(NULL);
return(node[which]);
}

inline Edge* Face::getEdgeLink(int which)
{ if ((which < 0) || (which > 3)) return(NULL);
return(edge[which]);
}
inline Tetra* Face::getTetraLink(int which)
{ if ((which < 0) || (which >= tetra.NumElements()))
    return(NULL);
  else return(tetra[which]);
}

inline int Face::numTetraLinks()
{ return(tetra.NumElements());
}

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

// is this face adjacent to f (if so, they must share a node)
inline int Face::isAdjacent(Face *f)
{ 
    if (node[0]->hasFaceLink(f) || node[1]->hasFaceLink(f) ||
        node[2]->hasFaceLink(f))
        return(1);
    return(0);
}

inline FaceArray* Face::getFaceArray()
{ return(facearray_p); }

inline void Face::setMarker(int value)
{ marker = value; }

inline int Face::getMarker()
{ return(marker); }

inline void Face::computenormal()
{
    Point3D a = node[0]->p;
    Point3D b = node[1]->p;
    Point3D c = node[2]->p;
    
    Point3D u = b - a, v = c - a;
    
    Point3D n(u.y*v.z - u.z*v.y, u.z*v.x - u.x*v.z, u.x*v.y - u.y*v.x);
    double nw = sqrt(n.Squared());
    normal = n/nw;
};

// redundant with center!
inline void Face::computeisobary()
{
    Point3D a = node[0]->p;
    Point3D b = node[1]->p;
    Point3D c = node[2]->p;
    
    Point3D g((1.0/3.0)*(a.x+b.x+c.x), (1.0/3.0)*(a.y+b.y+c.y),
        (1.0/3.0)*(a.z+b.z+c.z));
    isobary = g;
};

inline int Face::getNodeIndex(Node* n)
{for (int i=0; i<3; i++) if (node[i] == n) return i; return -1;}
inline Node* Face::getSplitNode(int which)
{return splitNode[which];}

inline void Face::setSplitNodes(Node* node0, Node* node1)
{splitNode[0] = node0; splitNode[1] = node1;}

inline Node* Face::getFakeSplitNode(int which)
{return fakeSplitNode[which];}

inline void Face::setFakeSplitNodes(Node* node0, Node* node1)
{fakeSplitNode[0] = node0; fakeSplitNode[1] = node1;node0->setMass(0.01); node1->setMass(0.01);}

inline Edge* Face::getSplitEdge(int which)
{return splitEdge[which];}

inline void Face::setSplitEdge(Edge* e)
{splitEdge[num_split_edges] = e;num_split_edges++;}

inline int Face::getNumSplitEdges()
{ return num_split_edges;}

#endif

---