source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.cxx @ 1526

/************************************************************************

  Primitive entities for adjacency models (AdjModel).
  $Id: AdjPrims.cxx,v 1.1 1997/06/25 15:24:55 garland Exp $

  Adapted from:
     mlab: (Id: primitives.cc,v 1.7 1997/02/06 16:32:45 garland Exp)
  via
     simplif: (Id: primitives.cc,v 1.2 1997/02/18 21:11:27 garland Exp)

 ************************************************************************/

#include "AdjPrims.h"

using namespace simplif;

void Vertex::kill()
{
#ifdef SAFETY
        assert( edge_uses.length() == 0 );
#endif
        markInvalid();
        edge_uses.reset();
}

void Vertex::linkEdge(Edge *e)
{
        edge_uses.add(e);
}

void Vertex::unlinkEdge(Edge *e)
{
        int index = edge_uses.find(e);

#ifdef SAFETY
        assert( index >= 0 );
#endif
        edge_uses.remove(index);
        if( edge_uses.length() <= 0 )
                kill();
}

#include <assert.h>

void Vertex::remapTo(Vertex *v)
{
        if ( v != this )
        {
                for (int i=0; i<edge_uses.length(); i++)
                {
                        assert( edge_uses(i)->org() == this );
                        edge_uses(i)->remapEndpoint(this, v);
                }

                kill();
        }
}

Edge::Edge(Vertex *a, Vertex *b)
{
        v1 = a;
        v1->linkEdge(this);

        face_uses = new buffer<Face *>(2);

        twin = new Edge(this, b);
}

Edge::Edge(Edge *sibling, Vertex *org)
{
        v1 = org;
        v1->linkEdge(this);

        face_uses = sibling->face_uses;
        twin = sibling;
}

Edge::~Edge()
{
        if ( twin )
        {
                face_uses->f_r_e_e();
                delete face_uses;

                twin->twin = NULL;
                delete twin;
        }
}

void Edge::kill()
{
#ifdef SAFETY
        assert( face_uses->length() == 0 );
#endif
        if ( isValid() )
        {
                org()->unlinkEdge(this);
                dest()->unlinkEdge(sym());
                markInvalid();
                twin->markInvalid();
                face_uses->reset();
        }
}

void Edge::linkFace(Face *face)
{
        face_uses->add(face);
}

void Edge::unlinkFace(Face *face)
{
        int index = face_uses->find(face);

#ifdef SAFETY
        assert( index>=0 );
#endif
        face_uses->remove(index);
        if( face_uses->length() == 0 )
                kill();
}

void Edge::remapTo(Edge *e)
{
        if ( e != this )
        {
                for (int i=0; i<face_uses->length(); i++)
                {
                        (*face_uses)(i)->remapEdge(this, e);
                }

                // Disconnect from all faces and vertices
                kill();
        }
}

void Edge::remapEndpoint(Vertex *from, Vertex *to)
{
        if ( org() == from )
        {
                v1 = to;
                to->linkEdge(this);
        }
        else if ( dest() == from )
        {
                twin->v1 = to;
                to->linkEdge(twin);
        }
        else
        {
                std::cerr << "WARNING remapEndpoint: Illegal endpoint." << std::endl;
        }

        //
        // The cached Plane equations for the faces attached to us may
        // no longer be valid (in general, chances are pretty slim that they're OK)
        for (int i      =       0; i < face_uses->length(); i++)
        {
                face_uses->ref(i)->invalidatePlane();
        }
}

Face::Face(Edge *e0, Edge *e1, Edge *e2)
    : Face3(*e0->org(), *e1->org(), *e2->org())
{
        edges[0] = e0;
        edges[1] = e1;
        edges[2] = e2;

        edges[0]->linkFace(this);
        edges[1]->linkFace(this);
        edges[2]->linkFace(this);

#ifdef SUPPORT_FCOLOR
        props = NULL;
#endif
}

void Face::kill()
{
        if( isValid() )
        {
                if( edge(0)->isValid() )
                        edge(0)->unlinkFace(this);

                if( edge(1)->isValid() )
                        edge(1)->unlinkFace(this);

                if( edge(2)->isValid() )
                        edge(2)->unlinkFace(this);

                markInvalid();
        }
}

void Face::remapEdge(Edge *from, Edge *to)
{
        for (int i=0; i<3; i++)
        {
                if ( edges[i] == from )
                {
                        edges[i] = to;
                        to->linkFace(this);
                }
                else if ( edges[i] == from->sym() )
                {
                        edges[i] = to->sym();
                        to->sym()->linkFace(this);
                }
        }

        invalidatePlane();
}

void simplif::untagFaceLoop(Vertex *v)
{
        edge_buffer& edges = v->edgeUses();

        for (int j      =       0; j < edges.length(); j++)
        {           
                face_buffer& faces = edges(j)->faceUses();

                for (int k      =       0; k < faces.length(); k++)
                {
                        faces(k)->untag();
                }
        }
}

void simplif::collectFaceLoop(Vertex *v, face_buffer& loop)
{
        edge_buffer& edges = v->edgeUses();

        for(int j=0; j<edges.length(); j++)
        {           
                face_buffer& faces = edges(j)->faceUses();
                for(int k=0; k<faces.length(); k++)
                        if( !faces(k)->isTagged() )
                        {
                                loop.add(faces(k));
                                faces(k)->tag();
                        }
        }
}

int simplif::classifyEdge(Edge *e)
{
        int cls = e->faceUses().length();

        if( cls>3 ) cls=3;

        return cls;
}

int simplif::classifyVertex(Vertex *v)
{
        int border_count = 0;
        const edge_buffer& edges = v->edgeUses();

        for(int i=0; i<edges.length(); i++)
                if( classifyEdge(edges(i)) == 1 )
                        border_count++;

        if( border_count == edges.length() )
                return VERTEX_BORDER_ONLY;
        else 
                return (border_count > 0);
}