Mesh.h

 
#pragma once
 
#if defined(Mesh_RECURSES)
#error Recursive header files inclusion detected in Mesh.h
#else // defined(Mesh_RECURSES)
#define Mesh_RECURSES
 
#if !defined Mesh_h
#define Mesh_h
 
// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/io/Color.h"
 
namespace DGtal
{
 
 
  // template class Mesh
  template <typename TPoint >
  class Mesh
  {
 
 
    // ----------------------- associated types ------------------------------
  public:
 
 
    typedef TPoint Point;
 
 
 
    typedef  typename DGtal::PointVector<TPoint::dimension, double> RealPoint;
 
 
    typedef  std::vector<TPoint> VertexStorage;
 
    typedef typename VertexStorage::size_type Index;
    
    typedef std::vector<Index> MeshFace;
 
    
    typedef  std::vector<MeshFace> FaceStorage;
 
    typedef  std::vector<DGtal::Color> ColorStorage;
 
 
    typedef typename VertexStorage::const_iterator ConstIterator;
 
    typedef typename VertexStorage::iterator Iterator;
 
    typedef typename std::size_t Size;
 
 
 
    // ----------------------- Standard services ------------------------------
  public:
    Mesh(bool saveFaceColor=false);
 
    Mesh(const DGtal::Color &aColor);
 
    Mesh(const std::vector<TPoint> &vertexSet);
 
    ~Mesh();
 
    Mesh ( const Mesh & other );
 
    Mesh & operator= ( const Mesh & other );
 
 
 
    // --------------- CDrawableWithDisplay3D  realization -------------------
  public:
 
    std::string className() const;
 
 
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
 
    void addVertex(const TPoint &vertex);
 
 
 
    void addTriangularFace(Index indexVertex1, Index indexVertex2, Index indexVertex3,
                           const DGtal::Color &aColor=DGtal::Color::White);
 
 
    void addQuadFace(Index indexVertex1, Index indexVertex2,
                     Index indexVertex3, Index indexVertex4,
                     const DGtal::Color & aColor=DGtal::Color::White);
 
 
    void addFace(const MeshFace &aFace, const DGtal::Color &aColor=DGtal::Color::White);
 
 
    void removeFaces(const std::vector<Index>  &facesIndex);
 
 
    const TPoint & getVertex(Index i) const;
 
    TPoint & getVertex(Index i);
 
 
 
    const MeshFace & getFace(Index i) const;
 
 
    RealPoint getFaceBarycenter(Index i) const;
 
 
 
    MeshFace & getFace(Index i);
 
 
 
    const Color & getFaceColor(Index i) const;
 
 
 
    std::pair<TPoint, TPoint>  getBoundingBox() const;
 
 
    void setFaceColor(Index i, const DGtal::Color &aColor) ;
 
 
    bool isStoringFaceColors() const;
 
 
    ConstIterator
    vertexBegin() const {
      return myVertexList.begin();
    }
 
 
    ConstIterator
    vertexEnd() const {
      return myVertexList.end();
    }
 
 
    Iterator
    vertexBegin()  {
      return myVertexList.begin();
    }
 
 
 
    Iterator
    vertexEnd()  {
      return myVertexList.end();
    }
 
 
 
    typename FaceStorage::const_iterator
    faceBegin() const {
      return myFaceList.begin();
    }
 
 
 
    typename FaceStorage::const_iterator
    faceEnd() const {
      return myFaceList.end();
    }
 
 
    typename FaceStorage::iterator
    faceBegin()  {
      return myFaceList.begin();
    }
 
 
 
    typename FaceStorage::iterator
    faceEnd()  {
      return myFaceList.end();
    }
 
 
 
    Size nbFaces() const;
 
    Size  nbVertex() const;
 
 
 
    void invertVertexFaceOrder();
 
    void clearFaces();
 
    
    void clearVertices();
      
     void removeIsolatedVertices();
 
    void rescale(const typename TPoint::Component aScale);
 
    double subDivideTriangularFaces(const double minArea);
 
    unsigned int quadToTriangularFaces();
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Private Datas --------------------------------
  private:
    FaceStorage  myFaceList;
    VertexStorage myVertexList;
    ColorStorage myFaceColorList;
    bool mySaveFaceColor;
    DGtal::Color myDefaultColor;
 
 
    // ------------------------- Mesh generation ------------------------------
 
  public:
 
    static
    void
    createTubularMesh(Mesh<TPoint> &aMesh,  const std::vector<TPoint> &aSkeleton, const double aRadius,
                      const double angleStep = 0.2, const DGtal::Color &aMeshColor = DGtal::Color::White );
 
 
 
    static
    void
    createTubularMesh(Mesh<TPoint> &aMesh,  const std::vector<TPoint> &aSkeleton, const std::vector<double> &aVectOfRadius,
                      const double angleStep = 0.2, const DGtal::Color &aMeshColor = DGtal::Color::White );
 
    template <typename TValue>
    static
    void
    createMeshFromHeightSequence(Mesh<TPoint> &aMesh,  const std::vector<TValue> & anValueSequence,
                                 const unsigned int lengthSequence,
                                 double stepX, double stepY, double stepZ,
                                 const DGtal::Color &aMeshColor = DGtal::Color::White );
 
 
 
 
 
 
 
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
    struct CompPoints
    {
      CompPoints(typename TPoint::Dimension d): myDim(d){};
      bool operator() (const TPoint &p1, const TPoint &p2){return p1[myDim]<p2[myDim];};
      typename TPoint::Dimension myDim;
    };
 
 
 
 
 
 
 
 
  }; // end of class Mesh
 
 
  template <typename TPoint>
  std::ostream&
  operator<< ( std::ostream & out, const Mesh<TPoint> & object );
 
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/shapes/Mesh.ih"
 
//                                                                           //
 
#endif // !defined Mesh_h
 
#undef Mesh_RECURSES
#endif // else defined(Mesh_RECURSES)