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

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

  Adjacency model representation.
  $Id: AdjModel.cxx,v 1.1 1997/06/25 15:24:52 garland Exp $

  Adapted from:
     mlab: (Id: polymodel.cc,v 1.21 1997/02/06 16:34:14 garland Exp)
  via
     simplif: (Id: polymodel.cc,v 1.5 1997/02/25 20:36:36 garland Exp)

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

#include "AdjModel.h"

using namespace simplif;

int Model::in_Vertex(const Vec3& p)
{
    Vertex *v = newVertex(p[X], p[Y], p[Z]);
    bounds.addPoint(p);
    return vertCount() - 1;
}

int Model::in_Normal(const Vec3& n)
{
        normals.add(n);
        return normCount()-1;
}

int Model::in_TexCoord(const Vec2& t)
{
        texcoords.add(t);
        return texcoordCount()-1;
}

int Model::in_Face(int a, int b, int c, int n1, int n2, int n3, int t1, int t2, int t3)
{
    Vertex *v1 = vertices(a-1);
    Vertex *v2 = vertices(b-1);
    Vertex *v3 = vertices(c-1);
        
    Face *t = newFace(v1, v2, v3);

        t->normals[0] = n1;
        t->normals[1] = n2;
        t->normals[2] = n3;

        t->texcoords[0] = t1;
        t->texcoords[1] = t2;   
        t->texcoords[2] = t3;

        return faceCount() - 1;
}

int Model::miin_Face(int a, int b, int c)
{
    Vertex *v1 = vertices(a-1);
    Vertex *v2 = vertices(b-1);
    Vertex *v3 = vertices(c-1);
        
    Face *t = newFace(v1, v2, v3);

        t->normals[0] = a;
        t->normals[1] = b;
        t->normals[2] = c;

        t->texcoords[0] = a;
        t->texcoords[1] = b;    
        t->texcoords[2] = c;

        return faceCount() - 1;
}

#ifdef SUPPORT_FCOLOR
int Model::in_FColor(const Vec3& c)
{
    Face *f = faces(faces.length()-1);

    if( !f->props )
        f->props = new FProp;

    f->props->color = c;
    return 0;
}
#endif

#ifdef SUPPORT_VCOLOR
int Model::in_VColor(const Vec3& c)
{
    Vertex *v = vertices(vertices.length()-1);

    if( !v->props )
        v->props = new VProp;

    v->props->color = c;
    return 0;
}
#endif

Vec3 Model::synthesizeNormal(Vertex *v)
{
    Vec3 n(0,0,0);
    int n_count = 0;

    edge_buffer& edges = v->edgeUses();
    for(int i=0; i<edges.length(); i++)
    {
        face_buffer& faces = edges(i)->faceUses();

        for(int j=0; j<faces.length(); j++)
        {
            n += faces(j)->plane().normal();
            n_count++;
        }
    }

    if( n_count )
        n /= (real)n_count;
    else
    {
                std::cerr << "Vertex with no normals!!: " << v->uniqID;
                std::cerr << " / " << v->tempID << std::endl;
    }
    return n;
}


////////////////////////////////////////////////////////////////////////
//
// Model Transmogrification:
//
// These routines are the basic model munging procedures.
// All model simplification is implemented in terms of these
// transmogrification primitives.
////////////////////////////////////////////////////////////////////////


Vertex *Model::newVertex(real x, real y, real z)
{
    Vertex *v = new Vertex(x, y, z);

    v->vID = v->uniqID = vertices.add(v);

/*    if( logfile && selected_output&OUTPUT_MODEL_DEFN )
                *logfile << "v " << x << " " << y << " " << z << std::endl;
*/
    validVertCount++;

    return v;
}

Edge *Model::newEdge(Vertex *a, Vertex *b)
{
    Edge *e = new Edge(a, b);

    e->uniqID = edges.add(e);
    e->sym()->uniqID = e->uniqID;

    validEdgeCount++;

    return e;
}

static Edge *get_edge(Model *m, Vertex *org, Vertex *v)
{
    edge_buffer& edge_uses = org->edgeUses();

    for(int i=0; i<edge_uses.length(); i++)
        if( edge_uses(i)->dest() == v )
            return edge_uses(i);

    Edge *e = m->newEdge(org, v);

    return e;
}


Face *Model::newFace(Vertex *v1, Vertex *v2, Vertex *v3)
{
    Edge *e0 = get_edge(this, v1, v2);   // v1->edgeTo(m, v2);
    Edge *e1 = get_edge(this, v2, v3);   // v2->edgeTo(m, v3);
    Edge *e2 = get_edge(this, v3, v1);   // v3->edgeTo(m, v1);
  
    Face *t = new Face(e0, e1, e2);

    t->uniqID = faces.add(t);

/*    if( logfile && selected_output&OUTPUT_MODEL_DEFN )
        *logfile << "f " << v1->uniqID+1 << " "
        << v2->uniqID+1 << " " << v3->uniqID+1 << std::endl;
*/
    validFaceCount++;

    return t;
}


void Model::killVertex(Vertex *v)
{
    if( v->isValid() )
    {
/*      if( logfile && selected_output&OUTPUT_CONTRACTIONS )
                *logfile << "v- " << v->uniqID+1 << std::endl;
*/
        v->kill();
        validVertCount--;
    }
}

void Model::killEdge(Edge *e)
{
    if( e->isValid() )
    {
        e->kill();
        validEdgeCount--;
    }
}

void Model::killFace(Face *f)
{
    if( f->isValid() )
    {
/*      if( logfile && selected_output&OUTPUT_CONTRACTIONS )
                *logfile << "f- " << f->uniqID+1 << std::endl;
*/
        f->kill();
        validFaceCount--;
    }
}

void Model::reshapeVertex(Vertex *v, real x, real y, real z)
{
    v->set(x, y, z);

#ifdef LOG_LOWLEVEL_OPS
    if( logfile )
        *logfile << "v! " << v->uniqID+1 << " "
                 << x << " " << y << " " << z << endl;
#endif
}

void Model::remapVertex(Vertex *from, Vertex *to)
{
    from->remapTo(to);

#ifdef LOG_LOWLEVEL_OPS
    if( logfile )
        *logfile << "v> " << from->uniqID+1 << " " << to->uniqID+1 << endl;
#endif
}



void Model::contract(Vertex *v1,
                     const vert_buffer& rest,
                     const Vec3& to,
                     face_buffer& changed)
{
    int i;

/*    if( logfile && selected_output&OUTPUT_CONTRACTIONS )
    {
        *logfile << "v% (" << v1->uniqID+1;
        for(i=0; i<rest.length(); i++)
            *logfile << " " << rest(i)->uniqID+1;
        
        *logfile << ") " << to[X] << " " << to[Y] << " " << to[Z] << std::endl;
    }
*/

    //
    // Collect all the faces that are going to be changed
    //
    contractionRegion(v1, rest, changed);

    reshapeVertex(v1, to[X], to[Y], to[Z]);

    for(i=0; i<rest.length(); i++)
                rest(i)->remapTo(v1);

    removeDegeneracy(changed);
}

void Model::maybeFixFace(Face *F)
{
    //
    // Invalid faces do not need to be fixed.
#ifdef SAFETY
    assert( F->isValid() );
#endif

    Vertex *v0=F->vertex(0); Vertex *v1=F->vertex(1); Vertex *v2=F->vertex(2);
    Edge *e0 = F->edge(0); Edge *e1 = F->edge(1); Edge *e2 = F->edge(2);

    bool a=(v0 == v1),  b=(v0 == v2),  c=(v1 == v2);

    if( a && c )
    {
        // This triangle has been reduced to a point
        killEdge(e0);
        killEdge(e1);
        killEdge(e2);

        killFace(F);
    }
    //
    // In the following 3 cases, the triangle has become an edge
    else if( a )
    {
        killEdge(e0);
        e1->remapTo(e2->sym());
        killFace(F);
    }
    else if( b )
    {
        killEdge(e2);
        e0->remapTo(e1->sym());
        killFace(F);
    }
    else if( c )
    {
        killEdge(e1);
        e0->remapTo(e2->sym());
        killFace(F);
    }
    else
    {
        // This triangle remains non-degenerate
/*              // SUS: recalcular la normal en los triangulos cambiados no degenerados

                simplif::Vertex * auxv0 = F->vertex(0);
                simplif::Vertex * auxv1 = F->vertex(1);
                simplif::Vertex * auxv2 = F->vertex(2);
                simplif::Vec3 vd1(auxv1->operator[](simplif::X) - auxv0->operator[](simplif::X), 
                                                auxv1->operator[](simplif::Y) - auxv0->operator[](simplif::Y),
                                                auxv1->operator[](simplif::Z) - auxv0->operator[](simplif::Z));
                simplif::Vec3 vd2(auxv2->operator[](simplif::X) - auxv0->operator[](simplif::X), 
                                                auxv2->operator[](simplif::Y) - auxv0->operator[](simplif::Y),
                                                auxv2->operator[](simplif::Z) - auxv0->operator[](simplif::Z));

                simplif::unitize(vd1);
                simplif::unitize(vd2);

                simplif::Vec3 vn = vd1 ^ vd2;
                simplif::unitize(vn);
                
                //auxf->vertex_normals[0] = vn;
                //auxf->vertex_normals[1] = vn;
                //auxf->vertex_normals[2] = vn;
                F->vertex_normals[0][simplif::X] = vn[simplif::X];
                F->vertex_normals[0][simplif::Y] = vn[simplif::Y];
                F->vertex_normals[0][simplif::Z] = vn[simplif::Z];
                F->vertex_normals[1][simplif::X] = vn[simplif::X];
                F->vertex_normals[1][simplif::Y] = vn[simplif::Y];
                F->vertex_normals[1][simplif::Z] = vn[simplif::Z];
                F->vertex_normals[2][simplif::X] = vn[simplif::X];
                F->vertex_normals[2][simplif::Y] = vn[simplif::Y];
                F->vertex_normals[2][simplif::Z] = vn[simplif::Z];*/

    }
}

void Model::removeDegeneracy(face_buffer& changed)
{
    for(int i=0; i<changed.length(); i++)
                maybeFixFace(changed(i));
}

void Model::contractionRegion(Vertex *v1,
                              const vert_buffer& vertices,
                              face_buffer& changed)
{
    changed.reset();

    //
    // First, reset the marks on all reachable vertices
    int i;

    untagFaceLoop(v1);
    for(i=0; i<vertices.length(); i++)
                untagFaceLoop(vertices(i));

    //
    // Now, pick out all the unique reachable faces
    collectFaceLoop(v1, changed);
    for(i=0; i<vertices.length(); i++)
                collectFaceLoop(vertices(i), changed);
}


void Model::contractionRegion(Vertex *v1, Vertex *v2, face_buffer& changed)
{
    changed.reset();

    //
    // Clear marks on all reachable faces
    untagFaceLoop(v1);
    untagFaceLoop(v2);

    //
    // Collect all the unique reachable faces
    collectFaceLoop(v1, changed);
    collectFaceLoop(v2, changed);
}

void Model::contract(Vertex *v1, Vertex *v2, const Vec3& to,
                     face_buffer& changed)
{
#ifdef SAFETY
    assert( v1 != v2);
#endif

/*    if( logfile && selected_output&OUTPUT_CONTRACTIONS )
        *logfile << "v% (" << v1->uniqID+1 << " " << v2->uniqID+1 << ") "
                 << to[X] << " "
                 << to[Y] << " "
                 << to[Z] << std::endl;
*/
    //
    // Collect all the faces that are going to be changed
    //
    contractionRegion(v1, v2, changed);

    reshapeVertex(v1, to[X], to[Y], to[Z]);

    //
    // Map v2 ---> v1.  This accomplishes the topological change that we want.
    v2->remapTo(v1);

    removeDegeneracy(changed);
}


/*
ostream& operator<<(ostream& out, Model& M)
{
    int i;
    int uniqVerts = 0;

    out << "#$SMF 1.0" << endl;

    out_annotate(out, M);

    for(i=0; i<M.vertCount(); i++)
    {
        if( M.vertex(i)->isValid() )
        {
            M.vertex(i)->tempID = ++uniqVerts;

            out_annotate(out, M.vertex(i));
            const Vertex& v = *M.vertex(i);
            out << "v " << v[X] << " " << v[Y] << " " << v[Z] << endl;

#ifdef SUPPORT_VCOLOR
            if( v.props )
                out << ":vc "
                    << v.props->color[X] << " "
                    << v.props->color[Y] << " "
                    << v.props->color[Z] << endl;
#endif
        }
        else
            M.vertex(i)->tempID = -1;

    }

    for(i=0; i<M.faceCount(); i++)
    {
        if( M.face(i)->isValid() )
        {
            Face *f = M.face(i);
            out_annotate(out, f);
            out << "f ";
            Vertex *v0 = (Vertex *)f->vertex(0);
            Vertex *v1 = (Vertex *)f->vertex(1);
            Vertex *v2 = (Vertex *)f->vertex(2);
#ifdef SAFETY
            assert( v0->tempID >= 0 );
            assert( v1->tempID >= 0 );
            assert( v2->tempID >= 0 );
#endif
            out<<v0->tempID << " " <<v1->tempID<< " " <<v2->tempID<< endl;
#ifdef SUPPORT_FCOLOR
            if( f->props )
                out << ":fc "
                    << f->props->color[X] << " "
                    << f->props->color[Y] << " "
                    << f->props->color[Z] << endl;
#endif
        }
    }

    return out;
}
*/