polyhedron_gl.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_
#include <windows.h>
#endif

#include <GL/gl.h>
#include <iostream>
#include "polyhedron_gl.h"
#include "util.h"

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

Polyhedron_GL::Polyhedron_GL(const Polyhedron* p)
        : _poly(p), _normalLen(0.5)
{
#if 0
  cerr << "Ready to draw a Polyhedron with " << p->numFaces() << " faces (" << p->numHoles() << " holes), and "
      << p->numVertices() << " vertices:\n";
        
  for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
  {
    const Face* f = *it;
    cerr << "Face: " << *f << endl;
  }
#endif

  _poly->GL(this);
        recomputeNormals();
        recomputeCentroids();
   recomputeColors();
   recomputeBoundingBox();
}

void Polyhedron_GL::drawVertices() const
{
   //cerr << "Drawing " << _poly->numVertices() << " vertices\n";
   glBegin(GL_POINTS);
        for (Polyhedron::const_vertex_iterator it=_poly->vBegin() ; it!=_poly->vEnd() ; ++it)
   {
      //cerr << (*it)->position() << endl;
                glVertex3fv( (*it)->position().getData() );
   }
        glEnd();
}

void Polyhedron_GL::drawCentroids() const
{
        glBegin(GL_POINTS);
        for (map<const Face*,Vector3Df>::const_iterator it=_centroids.begin() ; it!=_centroids.end() ; ++it)
                glVertex3fv( it->second.getData() );
        glEnd();
}

void Polyhedron_GL::drawFaces(const std::map<const Face*,Geometry::Vector3Df>& fnormals, bool faceColors) const
{
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                if (f->hole())
                        continue;
                Face::const_edge_circulator e = f->begin();
                Face::const_edge_circulator sentinel = e;

                glBegin(GL_POLYGON);
                glNormal3fv( fnormals.find(f)->second.getData() );
                if (faceColors)
                        glColor3fv( _randomColors.find(f)->second.getData() );
                do
                {
                        const Vertex* v = (*e)->dst();
                        glVertex3fv( v->position().getData() );
                        ++e;
                } while (e != sentinel) ;
                glEnd();
        }
}


void Polyhedron_GL::drawFacesWithColors(const std::map<const Vertex*,Geometry::Vector3Df>& vcolors, bool flat) const
{
   for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
   {
      const Face* f = *it;
      if (f->hole())
         continue;
      Face::const_edge_circulator e = f->begin();
      Face::const_edge_circulator sentinel = e;

      glBegin(GL_POLYGON);
      if (flat)
         glNormal3fv( _fNormals.find(f)->second.getData() );
      do
      {
         const Vertex* v = (*e)->dst();
         glColor3fv( vcolors.find(v)->second.getData() );
         if (!flat)
            glNormal3fv( _vNormals.find(v)->second.getData() );
         glVertex3fv( v->position().getData() );
         ++e;
      } while (e != sentinel) ;
      glEnd();
   }
}


void Polyhedron_GL::drawFacesWithTexture(const std::map<const Vertex*,Geometry::Vector3Df>& tCoords, bool flat) const
{
   for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
   {
      const Face* f = *it;
      if (f->hole())
         continue;
      Face::const_edge_circulator e = f->begin();
      Face::const_edge_circulator sentinel = e;

      glBegin(GL_POLYGON);
      if (flat)
         glNormal3fv( _fNormals.find(f)->second.getData() );
      do
      {
         const Vertex* v = (*e)->dst();
         glTexCoord2fv( tCoords.find(v)->second.getData() );
         if (!flat)
            glNormal3fv( _vNormals.find(v)->second.getData() );
         glVertex3fv( v->position().getData() );
         ++e;
      } while (e != sentinel) ;
      glEnd();
   }
}


void Polyhedron_GL::drawFaces(bool flat, bool faceColors) const
{
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                if (f->hole())
                        continue;
                Face::const_edge_circulator e = f->begin();
                Face::const_edge_circulator sentinel = e;

                glBegin(GL_POLYGON);
                if (flat)
                        glNormal3fv( _fNormals.find(f)->second.getData() );
                if (faceColors)
                        glColor3fv( _randomColors.find(f)->second.getData() );
                do
                {
                        const Vertex* v = (*e)->dst();
                        if (!flat)
                                glNormal3fv( _vNormals.find(v)->second.getData() );
                        glVertex3fv( v->position().getData() );
                        ++e;
                } while (e != sentinel) ;
                glEnd();
        }
}

void Polyhedron_GL::drawHoles() const
{
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                if (!f->hole())
                        continue;
                Face::const_edge_circulator e = f->begin();
                Face::const_edge_circulator sentinel = e;

                glBegin(GL_LINE_LOOP);
                do
                {
                        const Vertex* v = (*e)->dst();
                        glVertex3fv( v->position().getData() );
                        ++e;
                } while (e != sentinel) ;
                glEnd();
        }
}

void Polyhedron_GL::drawEdges() const
{
   glBegin(GL_LINES);
   for(Polyhedron::const_edge_iterator it=_poly->eBegin() ; it!=_poly->eEnd() ; ++it)
   {
      const HalfEdge* e = *it;
      glVertex3fv( e->dst()->position().getData() );
      glVertex3fv( e->src()->position().getData() );
   }
   glEnd();
}

void Polyhedron_GL::drawBoundingBox() const
{
   glBegin(GL_LINE_LOOP);
   glVertex3f(_bbox[0][0], _bbox[0][1], _bbox[0][2]);
   glVertex3f(_bbox[1][0], _bbox[0][1], _bbox[0][2]);
   glVertex3f(_bbox[1][0], _bbox[1][1], _bbox[0][2]);
   glVertex3f(_bbox[0][0], _bbox[1][1], _bbox[0][2]);
   glEnd();

   glBegin(GL_LINE_LOOP);
   glVertex3f(_bbox[0][0], _bbox[0][1], _bbox[1][2]);
   glVertex3f(_bbox[1][0], _bbox[0][1], _bbox[1][2]);
   glVertex3f(_bbox[1][0], _bbox[1][1], _bbox[1][2]);
   glVertex3f(_bbox[0][0], _bbox[1][1], _bbox[1][2]);
   glEnd();

   glBegin(GL_LINES);
   glVertex3f(_bbox[0][0], _bbox[0][1], _bbox[0][2]);
   glVertex3f(_bbox[0][0], _bbox[0][1], _bbox[1][2]);

   glVertex3f(_bbox[1][0], _bbox[0][1], _bbox[0][2]);
   glVertex3f(_bbox[1][0], _bbox[0][1], _bbox[1][2]);

   glVertex3f(_bbox[1][0], _bbox[1][1], _bbox[0][2]);
   glVertex3f(_bbox[1][0], _bbox[1][1], _bbox[1][2]);

   glVertex3f(_bbox[0][0], _bbox[1][1], _bbox[0][2]);
   glVertex3f(_bbox[0][0], _bbox[1][1], _bbox[1][2]);
   glEnd();
}

void Polyhedron_GL::drawNormals() const
{
        glBegin(GL_LINES);
        for(Polyhedron::const_vertex_iterator it=_poly->vBegin() ; it!=_poly->vEnd() ; ++it)
        {
                const Vertex* v = *it;
                Vector3Df pos(v->position());
                Vector3Df away(pos + (_vNormals.find(v)->second)*_normalLen);
                glVertex3fv( pos.getData() );
                glVertex3fv( away.getData() );
        }
        glEnd();
}

void Polyhedron_GL::drawFaceNormals() const
{
        glBegin(GL_LINES);
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                Vector3Df pos(_centroids.find(f)->second);
                Vector3Df away(pos + (_fNormals.find(f)->second)*_normalLen);
                glVertex3fv( pos.getData() );
                glVertex3fv( away.getData() );
        }
        glEnd();
}

void Polyhedron_GL::drawFaceNormals(const map<const Face*,Vector3Df>& fn) const
{
   glBegin(GL_LINES);
   //for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
   for (map<const Face*,Vector3Df>::const_iterator it=fn.begin() ; it!=fn.end() ; ++it)
   {
      const Face* f = it->first;
      Vector3Df pos(_centroids.find(f)->second);
      Vector3Df away(pos + (it->second)*_normalLen);
      glVertex3fv( pos.getData() );
      glVertex3fv( away.getData() );
   }
   glEnd();
}



void Polyhedron_GL::drawTriangles(bool flat, bool faceColors) const
{
        glBegin(GL_TRIANGLES);
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                if (f->hole())
                        continue;
                Face::const_edge_circulator e = f->begin();

                if (flat)
                        glNormal3fv( _fNormals.find(f)->second.getData() );
                if (faceColors)
                        glColor3fv( _randomColors.find(f)->second.getData() );
                for (int i=0 ; i<3 ; i++, ++e)
                {
                        const Vertex* v = (*e)->dst();
                        if (flat)
                                glNormal3fv( _vNormals.find(v)->second.getData() );
                        glVertex3fv( v->position().getData() );
                }
        }
        glEnd();
}

void Polyhedron_GL::recomputeNormals()
{
        _vNormals.clear();
        for (Polyhedron::const_vertex_iterator it=_poly->vBegin() ; it!=_poly->vEnd() ; ++it)
        {
                const Vertex* v = *it;
                const Vector3Df n = v->normal();
                _vNormals[v] = n;
        }

        _fNormals.clear();
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                const Vector3Df n = f->normal();
                _fNormals[f] = n;
        }
}


void Polyhedron_GL::recomputeCentroids()
{
        _centroids.clear();
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                const Face* f = *it;
                const Vector3Df c = f->centroid();
                _centroids[f] = c;
        }
}



void Polyhedron_GL::recomputeColors()
{
        _randomColors.clear();
        for(Polyhedron::const_face_iterator it=_poly->fBegin() ; it!=_poly->fEnd() ; ++it)
        {
                Vector3Df c(HE::rangerand(0, 1), HE::rangerand(0, 1), HE::rangerand(0, 1));
                c.normalize();

                const Face* f = *it;
                _randomColors[f] = c;
        }
}


void Polyhedron_GL::recomputeBoundingBox()
{
   _bbox[0] = _bbox[1] = (*_poly->vBegin())->position();
   for (Polyhedron::const_vertex_iterator it=_poly->vBegin() ; it!=_poly->vEnd() ; ++it)
   {
      const Vector3Df& v = (*it)->position();
      for (int i=0 ; i<3 ; i++)
      {
         if (v[i] < _bbox[0][i])
            _bbox[0][i] = v[i];
         if (v[i] > _bbox[1][i])
            _bbox[1][i] = v[i];
      }
   }
}

---