QEM_Edge.cpp

// QEM_Edge.cpp : Implementation for the Edge class
//
// Author: Matt Loper
// $Revision: 1.4 $
// $Date: 2002/05/15 08:28:12 $

#include "../common/standard.h"
#include "QEM_Edge.h"   
#include "QEM_Face.h"

using namespace QEM;

Edge::Edge (int FaceIndex1, int whichEdge, int VertexIndex1, int VertexIndex2)
{
        assert (FaceIndex1 >= 0);
        assert (whichEdge >=0 && whichEdge <= 3);
        cachedCost = -1.;
        face1 = FaceIndex1*3 + whichEdge;
        face2 = -1;
        v1 = VertexIndex1;
        v2 = VertexIndex2;
}



VertexArray *Edge::varray;

bool Edge::operator<(const Edge &e) const
{
    if (getCachedCost() != e.getCachedCost())
                return (getCachedCost() < e.getCachedCost());

    // if we get here, then our quadric-based costs are the same.
    // compare by edge length (a shorter edge == a better collapse)
    VertexArray &vertices = *varray;

        ColVector3 us   = vertices[v1] - vertices[v2];
        ColVector3 them = vertices[e.v1] - vertices[e.v2];

        return (us.getLengthSquared() < them.getLengthSquared());
}


bool Edge::swapVertexIndex(int from1, int from2, int to)
{
    if (v1 == v2) // we've been given a degenerate edge
    {
        assert(!"Edge::swapVertexIndex(): called on a degenerate edge.");
        throw ("Edge::swapVertexIndex(): called on a degenerate edge.");
    }

    if (v1 != from1 && v2 != from1 && 
        v1 != from2 && v2 != from2)
            return false; // didn't have to swap anything

    if (v1 == from1 || v1 == from2) v1 = to;
        if (v2 == from1 || v2 == from2) v2 = to;

    if (v1 == v2) // we've become a degenerate edge
    {
        assert(!"Edge::swapVertexIndex(): we've created a degenerate edge.");
        throw ("Edge::swapVertexIndex(): we've created a degenerate edge.");
    }

    // our vertex has been swapped, so we have to update our cached cost.
    // if it crashes here, it means that you have probably forgotten 
    // to call "recalculateCosts()" before doing your first collapse
    VertexQuadric &vertex1 = varray->operator[](v1);
    VertexQuadric &vertex2 = varray->operator[](v2);

    // ...sum up the quadrics of our neighboring vertices...
    Quadric sum = vertex1.quadric + vertex2.quadric;

    // and try to get an optimum point. If the quadric doesn't specify an
    // optimum, then take an average of the two points
    Vertex v;
    if (!sum.getOptimumPoint (v))
    {
        v = (vertex1 + vertex2) / 2;
    }

    setCachedCost(sum.getCost(v));

    return true;
}



int Edge::faceIndexFirst() const
{ 
        return edgeIndexFirst()/3;
}



int Edge::faceIndexSecond() const
{ 
        return edgeIndexSecond()/3;
}



int Edge::edgeIndexFirst() const
{ 
        if (face1 == -1)
                throw "Edge::edgeIndexFirst(): This edge has no first face.";
        
        return face1; 
}



int Edge::edgeIndexSecond() const
{ 
        if (face2 == -1)
                throw "Edge::edgeIndexSecond(): This edge has no second face.";
        
        return face2; 
}

 

void Edge::setFace2(int faceIndex, int whichEdge) 
{ 
        assert (faceIndex >= 0 && whichEdge >= 0);
        face2 = faceIndex*3 + whichEdge; 
        assert (face1 != face2 && "Edge::setFace1: you're setting this edge to have two identical faces!");
        assert (face1/3 != face2/3 && "Edge::setFace1: you're setting this edge to have two identical faces!");
}



void Edge::setFace1(int faceIndex, int whichEdge) 
{ 
        assert (faceIndex >= 0 && whichEdge >= 0);
        face1 = faceIndex*3 + whichEdge; 
        assert (face1 != face2 && "Edge::setFace1: you're setting this edge to have two identical faces!");
        assert ((face1/3) != (face2/3) && "Edge::setFace1: you're setting this edge to have two identical faces!");
}



void Edge::removeFace1()
{
        face1 = -1;
}



void Edge::removeFace2()
{
        face2 = -1;
}



void Edge::assertValid()
{
        assert (face1 != face2 && "Edge::assertValid(): this edge has two identical faces)");
        assert (v1 >= 0 && v2 >= 0 && "Edge::assertValid(): this edge has vertex indices < 0)");
        assert (v1 != v2 && "Edge::assertValid(): this edge is degenerate (two identical vertices)");
}
 


void Edge::printDebugString()
{
        MTRACE("EDGE PRINTING -------------\n");
        MTRACE("face1 = %d.%d, ", face1/3, face1%3);
        MTRACE("face2 = %d.%d\n", face2/3, face2%3);
        MTRACE("v1    = %d, v2    = %d\n", v1, v2);
}



bool Edge::operator==(const Edge &e) const
{
        if (e.v1 == v1 && e.v2 == v2)
                return true;
        if (e.v2 == v1 && e.v1 == v2)
                return true;
        return false;
}



bool Edge::operator!=(const Edge &e) const
{
        return (!(operator==(e)));
}

---