MeshHelpers.h

 
#pragma once
 
#if defined(MeshHelpers_RECURSES)
#error Recursive header files inclusion detected in MeshHelpers.h
#else // defined(MeshHelpers_RECURSES)
#define MeshHelpers_RECURSES
 
#if !defined MeshHelpers_h
#define MeshHelpers_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/topology/CCellEmbedder.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
#include "DGtal/topology/DigitalSurface.h"
#include "DGtal/shapes/TriangulatedSurface.h"
#include "DGtal/shapes/PolygonalSurface.h"
#include "DGtal/shapes/Mesh.h"
#include "DGtal/shapes/SurfaceMesh.h"
 
namespace DGtal
{
 
  // template class MeshHelpers
  class MeshHelpers
  {
    // ----------------------- Static services ------------------------------
  public:
    
    
    template <typename Point>
    static
    bool mesh2TriangulatedSurface
    ( const Mesh<Point>& mesh,
      TriangulatedSurface<Point>& trisurf );
 
    template <typename Point>
    static
    bool mesh2PolygonalSurface
    ( const Mesh<Point>& mesh,
      PolygonalSurface<Point>& polysurf );
 
    template <typename Point>
    static
    void polygonalSurface2TriangulatedSurface
    ( const PolygonalSurface<Point>& polysurf,
      TriangulatedSurface<Point>&    trisurf,
      bool  centroid = true );
 
    template < typename DigitalSurfaceContainer,
               typename CellEmbedder,
               typename VertexMap >
    static
    void digitalSurface2DualTriangulatedSurface
    ( const DigitalSurface<DigitalSurfaceContainer>& dsurf,
      const CellEmbedder& cembedder,
      TriangulatedSurface<typename CellEmbedder::Value>& trisurf,
      VertexMap& vertexmap );
 
    template < typename DigitalSurfaceContainer,
               typename CellEmbedder,
               typename VertexMap >
    static
    void digitalSurface2DualPolygonalSurface
    ( const DigitalSurface<DigitalSurfaceContainer>& dsurf,
      const CellEmbedder& cembedder,
      PolygonalSurface<typename CellEmbedder::Value>& polysurf,
      VertexMap& vertexmap );
 
    template < typename DigitalSurfaceContainer,
               typename CellEmbedder,
               typename CellMap >
    static
    bool digitalSurface2PrimalPolygonalSurface
    ( const DigitalSurface<DigitalSurfaceContainer>& dsurf,
      const CellEmbedder& cembedder,
      PolygonalSurface<typename CellEmbedder::Value>& polysurf,
      CellMap& cellmap );
    
    template < typename DigitalSurfaceContainer,
    typename CellEmbedder,
    typename CellMap >
    static
    bool digitalSurface2PrimalSurfaceMesh
    ( const DigitalSurface<DigitalSurfaceContainer>& dsurf,
     const CellEmbedder& cembedder,
     SurfaceMesh<typename CellEmbedder::Value,typename CellEmbedder::Value>& polysurf,
     CellMap& cellmap );
    
    
    template <typename Point>
    static
    void triangulatedSurface2Mesh
    ( const TriangulatedSurface<Point>& trisurf,
      Mesh<Point>& mesh );
 
    template <typename Point>
    static
    void polygonalSurface2Mesh
    ( const PolygonalSurface<Point>& polysurf,
      Mesh<Point>& mesh );
 
    template < typename RealPoint, typename RealVector >
    static
    void surfaceMesh2Mesh
    ( const SurfaceMesh< RealPoint, RealVector >& smesh,
     Mesh< RealPoint >& mesh, const std::vector<Color> &cols = {} );
    
    template <typename Point>
    static
    bool exportOBJ
    ( std::ostream& output,
      const TriangulatedSurface<Point>& trisurf );
 
    template <typename Point>
    static
    bool exportOBJ
    ( std::ostream& output,
      const PolygonalSurface<Point>& polysurf );
 
 
    template <typename TTriangulatedOrPolygonalSurface>
    static
    bool exportOBJwithFaceNormalAndColor
    ( std::ostream& output_obj,
      const std::string&             mtl_filename,
      const TTriangulatedOrPolygonalSurface& polysurf,
      const std::vector< typename TTriangulatedOrPolygonalSurface::Point >&    normals,
      const std::vector< Color >&    diffuse_colors,
      const Color&                   ambient_color  = Color( 32, 32, 32 ),
      const Color&                   diffuse_color  = Color( 200, 200, 255 ),
      const Color&                   specular_color = Color::White );
 
    
    static
    bool exportMTLNewMaterial
    ( std::ostream& output_mtl,
      unsigned long idxMaterial,
      const Color& ambient_color,
      const Color& diffuse_color,
      const Color& specular_color );
 
  }; // end of class MeshHelpers
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/shapes/MeshHelpers.ih"
 
//                                                                           //
 
#endif // !defined MeshHelpers_h
 
#undef MeshHelpers_RECURSES
#endif // else defined(MeshHelpers_RECURSES)