polyhedron.h

Go to the documentation of this file.

/***************************************************************************
 *   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.             *
 ***************************************************************************/

#ifndef __POLYHEDRON_H__
#define __POLYHEDRON_H__

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

#include <cassert>
#include <vector>
#include <map>
#include <set>
#include <fstream>

#include "halfedge.h"
#include "face.h"
#include "vertex.h"


namespace HE
{
        enum filetype_e
        {
    FT_PLY_ASCII, 
                FT_PLY_BIN, 
                FT_OFF, 
    FT_OBJ, 
    FT_TRI, 
    FT_NONE 
        };

        class Polyhedron_GL;

        class Polyhedron
        {
                public:
                        friend class Polyhedron_GL;

         Polyhedron();

         explicit Polyhedron(const char* filename);

                        explicit Polyhedron(const std::vector<Vertex*>& verts, const std::vector<std::vector<int> >& faces);

         Polyhedron* refine() const;

                        ~Polyhedron();

                        bool load(const char* filename);

                        bool readPly(const char* filename);

      bool readOff(const char* filename);

      bool readTri(const char* filename);

                        bool save(const char* filename) const;

                        bool saveAsPly(const char* filename) const;

      bool saveAsOff(const char* filename) const;

      bool saveAsTri(const char* filename) const;

      void clearData();

                        Vertex* addVertex(float x, float y, float z) { return addVertex(Geometry::Vector3Df(x, y, z)); }

         Vertex* addVertex(const Geometry::Vector3Df& v);


         Face* addFace(const std::vector<int>& corners);

         Face* addFace(int a, int b, int c);

         void loadVertices(const std::vector<float>& verts);

         void loadFaces(const std::vector<std::vector<int> >& faces);

                        int numVertices() const { return (int)_vertices.size(); }
                        
                        int numFaces() const { return (int)_faces.size(); }

                        int numHalfEdges() const { return (int)_halfEdges.size(); }

                        int numHoles() const;

         bool adjacent(const Vertex* v1, const Vertex* v2) const;
                        
         bool adjacent(const Face* f1, const Face* f2) const;
                        
                        filetype_e type() const { return _type; }
                        
                        void type(filetype_e ft) { _type = ft; }

      HalfEdge* edge(int from, int to) const;
      HalfEdge* edge(const Vertex* vFrom, const Vertex* vTo) const { return edge(vFrom->index(), vTo->index()); }

                        Vertex* vertex(int v) { return _vertices[v]; } 
                        const Vertex* vertex(int v) const { return _vertices[v]; } 
                        Face* face(int f) { return _faces[f]; } 
                        const Face* face(int f) const { return _faces[f]; } 
                        HalfEdge* halfedge(int h) { return _halfEdges[h]; } 
                        const HalfEdge* halfedge(int h) const { return _halfEdges[h]; } 

                        const std::vector<Vertex*>& vertices() const { return _vertices; } 

                        void invertNormals();
                        
                        void packVertices();
                        
                        void scaleAndCenter(float side=10);
                        
                        void boundingBox(Geometry::Vector3Df& m, Geometry::Vector3Df& M) const;

         void finalize();

                        // Iterators/circulators
#include "polyhedron_iterators.h"

          void writeVertices(std::ostream& out) const;

         void writeFaces(std::ostream& out, bool includeHoles=false) const;

         void writeHalfEdges(std::ostream& out) const;

         bool check(bool holesFilled=true) const;

     protected:
         void closeSurface(std::map<std::pair<int,int>, HalfEdge*>& connections);
         void GL(Polyhedron_GL* gl) const { _gl = gl; }
         bool readPlyHeader(std::ifstream& in, int& nv, int& nf, short order[11]);
         bool readPlyData(std::ifstream& in, int& nv, int& nf, const short order[11], std::vector<float>& verts, std::vector<std::vector<int> >& faces);

                        std::vector<Face*> _faces;
                        std::set<Face*> _holes;
                        std::vector<HalfEdge*> _halfEdges;
                        std::vector<Vertex*> _vertices;
                        mutable Polyhedron_GL* _gl;
                        filetype_e _type;
        };

   std::ostream& operator<<(std::ostream& out, const Polyhedron& p);

        filetype_e fileFormat(const char* filename);
};

#endif // __POLYHEDRON_H__

---