face.cpp

/***************************************************************************
 *   Copyright (C) 2007 by Pablo Diaz-Gutierrez   *
 *   pablo@ics.uci.edu   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifdef _WIN32
#pragma warning(disable:4786)
#endif

#include <cassert>
#include "face.h"
#include "vertex.h"
#include "halfedge.h"

using namespace std;
using namespace Geometry;
using namespace HE;


Vector3Df Face::normal() const
{
        //static Vector3Df prev(1,0,0); // $$$ Hack to prevent problems with degenerate normals...
        Vector3Df N(0,0,0);
#if 0 // We can still compute the normal of a hole... Let the application decide its use.
        if (hole())
                return N;
#endif

        const_edge_circulator e = begin();
        const_edge_circulator sentinel = e;
        do
        {
                Vector3Df v(- (*e)->tangent());
                ++e;
                Vector3Df v2((*e)->tangent());
                float a = v.angle(v2);
                Vector3Df n = v2 ^ v;
                N += a*n;
        } while (e != sentinel) ;

        N.normalize();
#if 1
        return N;
#else
        if (!isnan(N[0]) && !isnan(N[1]) && !isnan(N[2]))
        {
                prevN = N;
                return N;
        }
        else
        {
                return prevN;
        }
#endif
}

Vector3Df Face::centroid() const
{
        Vector3Df C(0,0,0);

        const_edge_circulator e = begin();
        const_edge_circulator sentinel = e;
        int n = 0;
        do
        {
                n++;
                C += (*e)->dst()->position();
                ++e;
        } while (e != sentinel) ;

        return C / n;
}


ostream& HE::operator<< (ostream& out, const Face& f)
{
        out << '[' << (int)f.edge() << (f.hole() ? ", hole" : ", solid") << ", " << f.size() << " verts: ";

        Face::const_edge_circulator e = f.begin();
        const Face::const_edge_circulator sentinel = e;
        do
        {
                const Vertex* v = (*e)->dst();
                if (v)
                        out << ' ' << v->index();
                else
                        out << " NULL";
                ++e;
        } while (sentinel != e) ;

   return out << ']';
}

int Face::size() const
{
        Face::const_edge_circulator e = begin();
        Face::const_edge_circulator sentinel = e;
        int n(0);
        do
        {
                n++;
                ++e;
        } while (sentinel != e) ;

        return n;
}

bool Face::contains(const HalfEdge* he) const
{
        Face::const_edge_circulator e = begin();
        Face::const_edge_circulator sentinel = e;
        do
        {
                if (*e == he)
                        return true;
                ++e;
        } while (sentinel != e) ;

        return false;
}

bool Face::contains(const Vertex* v) const
{
        Face::const_edge_circulator e = begin();
        Face::const_edge_circulator sentinel = e;
        do
        {
                if ((*e)->dst() == v)
                        return true;
                ++e;
        } while (sentinel != e) ;

        return false;
}

const HalfEdge* Face::fromVertex(int v) const
{
        Face::const_edge_circulator e = begin();
        Face::const_edge_circulator sentinel = e;
        do
        {
                if ((*e)->dst()->index() == v)
                        return (*e)->next();
                ++e;
        } while (sentinel != e) ;

        return 0;
}

const HalfEdge* Face::toVertex(int v) const
{
        Face::const_edge_circulator e = begin();
        Face::const_edge_circulator sentinel = e;
        do
        {
                if ((*e)->dst()->index() == v)
                        return *e;
                ++e;
        } while (sentinel != e) ;

        return 0;
}

const HalfEdge* Face::fromVertex(Vertex* v) const
{
        return fromVertex(v->index());
}

const HalfEdge* Face::toVertex(Vertex* v) const
{
        return toVertex(v->index());
}

void HE::Face::edge_circulator::operator++()
{
        _here = _here->next();
}

void HE::Face::const_edge_circulator::operator++()
{
        _here = _here->next();
}

---