Mesh.h

Go to the documentation of this file.

#ifndef MESH_CM
#define MESH_CM
#include <vector>
#include <set>
#include <iostream>

#include "Edge.h"
#include "Face.h"
#include "Vertex.h"

class Mesh
{
private:
   struct edge_comp {
      edge_comp() {}
      bool operator()( const Edge *e1, const Edge *e2 ) const {
          int b1 = e1->vertex->ID, t1 = e1->pair->vertex->ID;
          int b2 = e2->vertex->ID, t2 = e2->pair->vertex->ID; 

          int min1, min2, max1, max2;
          min1 = std::min(b1, t1); min2 = std::min(b2, t2);
          max1 = std::max(b1, t1); max2 = std::max(b2, t2);
          if (min1 == min2 && max1 == max2){
             if (b1 < b2) return true;
             return (b1 == b2 && t1 < t2);
          }
          if (min1 < min2)     return true;
          return (min1 == min2 && max1 < max2);       
      }
   };


   std::vector<Vertex *> vertices;
   std::vector<Face *> faces;
   std::multiset<Edge*, Mesh::edge_comp> edges;

public:

   int numBoundaryVertices;

   int numBoundaryLoops;
   int numConnectedComponents;

   int numGenus;

   typedef std::multiset<Edge*, Mesh::edge_comp>  EdgeSet;
   typedef std::vector<Face *> FaceSet;
   typedef std::vector<Vertex *> VertexSet;

   Mesh(void);
   ~Mesh(void);
   void clear();

   Vertex * addVertex(const Vector3 & p);
   Face * addFace(std::vector<int> faceVerts);
   Edge * addEdge(int i, int j);
   Edge * addEdge(Edge * e) {
      edges.insert(e);
      return e;
   }

   bool cutAlongEdge(Edge * forward);

   inline Vertex * vertexAt (int i) {return vertices[i];}
   inline Face * faceAt (int i) {return faces[i];}

   inline int numFaces()     { return (int)faces.size();    }
   inline int numVertices()  { return (int)vertices.size(); }
   inline int numEdges()     { return (int)edges.size()/2;  }
   inline int numBoundary()  { return numBoundaryVertices;  }

   void linkBoundary();
   bool checkManifold();
   bool checkVertexConection();
   void checkGaussianCurvature();

   void computeMeshInfo();

   void computeLengths();
   void computeInitAngles();

   void readOBJ(const char * obj_file);
   void readCON(const char * conn_file);
   void readCONE_VERT(const char * vert_file);
   void readCUT_EDGES(const char * edge_file);
   void writeOBJ(const char * obj_file);
   void writeVT(const char * vt_file);
   void writeCON(const char * conn_file);

   void finishMesh() {
      linkBoundary();
      checkManifold();
      checkVertexConection();
      std::cout << "*--------------------*" << std::endl;               
      std::cout << "* Faces:    " << numFaces() << std::endl;           
      std::cout << "* Edges:    " << numEdges() << std::endl;           
      std::cout << "* Vertices: " << numVertices() << std::endl;                 
      std::cout << "*--------------------*\n" << std::endl;             
   }

   class FaceIterator {
   private:
      FaceSet::iterator fIter;
      FaceSet * facesPtr;
   public:
      FaceIterator() {
          facesPtr = NULL;
      }

      FaceIterator(FaceSet * _faces) {
          facesPtr = _faces;
          fIter = _faces->begin();
      }
      FaceIterator& operator++( void ){
          fIter++;
          return *this;
      }
      FaceIterator operator++( int ){
          FaceIterator r = *this; ++*this; return r;
      }
      FaceIterator& operator--( void ){
          fIter--;
          return *this;
      }
      FaceIterator operator--( int ){
          FaceIterator r = *this; --*this; return r;
      }

      Face * face( void ) const { return *fIter; }
      //Face * & face( void )     { return *fIter; }

      void reset() {fIter = facesPtr->begin(); }
      bool end(void) { return fIter == facesPtr->end();
      ;}
   };

   class VertexIterator {
   private:
      VertexSet::iterator vIter;
      VertexSet * verticesPtr;
   public:
      VertexIterator() {
          verticesPtr = NULL;
      }

      VertexIterator(VertexSet * _vertices) {
          vIter = _vertices->begin();
          verticesPtr = _vertices;
      }
      VertexIterator& operator++( void ){
          vIter++;
          return *this;
      }
      VertexIterator operator++( int ){
          VertexIterator r = *this; ++*this; return r;
      }
      VertexIterator& operator--( void ){
          vIter--;
          return *this;
      }
      VertexIterator operator--( int ){
          VertexIterator r = *this; --*this; return r;
      }

      Vertex * vertex( void ) const { return *vIter; }
      //Vertex * & vertex( void )     { return *vIter; }

      void reset() {vIter = verticesPtr->begin();}
      bool end(void) { return vIter == verticesPtr->end();}
   };

   class HalfEdgeIterator {
   private:
      EdgeSet::iterator eIter;
      EdgeSet * edgesPtr;
   public:
      HalfEdgeIterator() {
          edgesPtr = NULL;
      }
      HalfEdgeIterator(EdgeSet * _edges) {
          eIter = _edges->begin();
          edgesPtr = _edges;
      }
      HalfEdgeIterator& operator++( void ){
          eIter++;
          return *this;
      }
      HalfEdgeIterator operator++( int ){
          HalfEdgeIterator r = *this; ++*this; return r;
      }
      HalfEdgeIterator& operator--( void ){
          eIter--;
          return *this;
      }
      HalfEdgeIterator operator--( int ){
          HalfEdgeIterator r = *this; --*this; return r;
      }

      Edge * half_edge( void ) const { return *eIter; }
      //          Edge * & operator*( void )     { return *eIter; }

      void find (Edge * eTmp) {
          eIter = edgesPtr->find(eTmp);
      }

      void reset() {eIter = edgesPtr->begin(); }
      bool end (void) { return eIter == edgesPtr->end();}
   };

   class EdgeIterator {
   private:
      EdgeSet::iterator eIter;
      EdgeSet * edgesPtr;

   public:
      EdgeIterator() {
          edgesPtr = NULL;
      }

      EdgeIterator(EdgeSet * _edges) {
          eIter = _edges->begin();
          edgesPtr = _edges;
      }
      EdgeIterator& operator++( void ){
          eIter++; eIter++;
          return *this;
      }
      EdgeIterator operator++( int ){
          EdgeIterator r = *this; ++*this; return r;
      }
      EdgeIterator& operator--( void ){
          eIter--; eIter--;
          return *this;
      }
      EdgeIterator operator--( int ){
          EdgeIterator r = *this; --*this; return r;
      }

      Edge * edge( void ) const { return *eIter; }
      //          Edge * & operator*( void )     { return *eIter; }

      void reset() {eIter = edgesPtr->begin(); }
      bool end(void) { return eIter == edgesPtr->end();}
   };



   FaceIterator faceIterator() {return FaceIterator(&faces);}
   VertexIterator vertexIterator() {return VertexIterator(&vertices);}
   HalfEdgeIterator halfEdgeIterator() {return HalfEdgeIterator(&edges);}
   EdgeIterator edgeIterator() {return EdgeIterator(&edges);}
};
#endif

---