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

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

  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);
}