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<unsigned int> MeshFace;
    
    
    typedef  std::vector<TPoint> VertexStorage; 
    
    typedef  std::vector<MeshFace> FaceStorage; 

    typedef  std::vector<DGtal::Color> ColorStorage; 
     

    typedef typename VertexStorage::const_iterator ConstIterator;

    typedef typename VertexStorage::iterator Iterator;

    


    // ----------------------- 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(unsigned int indexVertex1, unsigned int indexVertex2, unsigned int indexVertex3, 
                           const DGtal::Color &aColor=DGtal::Color::White);


    void addQuadFace(unsigned int indexVertex1, unsigned int indexVertex2, 
                     unsigned int indexVertex3, unsigned int 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<unsigned int>  &facesIndex);
   
 
    const TPoint & getVertex(unsigned int i) const;

    TPoint & getVertex(unsigned int i);
    
    
    
    const MeshFace & getFace(unsigned int i) const;


    RealPoint getFaceBarycenter(unsigned int i) const;    


    
    MeshFace & getFace(unsigned int i);
    


    const Color & getFaceColor(unsigned int i) const;



    std::pair<TPoint, TPoint>  getBoundingBox() const;


    void setFaceColor(unsigned int 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();
    }

    
    
    FaceStorage::const_iterator 
    faceBegin() const {
      return myFaceList.begin();
    }
    


    FaceStorage::const_iterator 
    faceEnd() const {
      return myFaceList.end();
    }    
    

    FaceStorage::iterator 
    faceBegin()  {
      return myFaceList.begin();
    }
    


    FaceStorage::iterator 
    faceEnd()  {
      return myFaceList.end();
    }    
    
    

    unsigned int nbFaces() const;

    unsigned int  nbVertex() const;
    
    
    
    void invertVertexFaceOrder();
    
    void clearFaces();
    
    void changeScale(const double aScale);
    
    double subDivideTriangularFaces(const double minArea);
    
    unsigned int quadToTriangularFaces();
        
    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  private:



    


    // ------------------------- 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)