MeanCurvatureSkeleton3D.h

Go to the documentation of this file.

#ifndef MEAN_CURVATURE_3D_H_
#define MEAN_CURVATURE_3D_H_
 
#ifndef CGAL_EIGEN3_ENABLED
#define CGAL_EIGEN3_ENABLED
#endif
 
#include <memory>
#include <map>
#include <limits>
#include <algorithm>
#include <unordered_map>
#include <tuple>
#include <sstream>
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/Polyhedron_items_with_id_3.h>
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/extract_mean_curvature_flow_skeleton.h>
#include <containers/sequential/graph/graph.h>
#include <containers/sequential/graph/algorithms/graph_algo_util.h>
#include <boost/functional/hash.hpp>
#include "Utilities/IOUtils.h"
#include "Geometry/Boundaries/Boundary.h"
#include "Workspace/WorkspaceSkeleton.h"
#include "Workspace/WorkspaceDecomposition.h"
#include "Workspace/PropertyMap.h"
#include "Vector.h"
 
using namespace std;
using namespace mathtool;
 
class Environment;
class XMLNode;
class WorkspaceDecomposition;
 
 
class MeanCurvatureSkeleton3D {
 
  public:
 
    struct Parameters {
      double m_wM{0.2};
      double m_wH{0.1};
      double m_refine{1};
      size_t m_iterations{1000};
      std::string ioType;
      std::string filebase;
      bool useConvex{false};
      double scaleConvex{1.2};
      size_t space;
    };
 
    static Parameters m_defaultParams; 
 
    typedef CGAL::Simple_cartesian<double> CGALKernel;
    typedef typename CGALKernel::Point_3 Point3;
    typedef CGAL::Surface_mesh<Point3> SurfaceMesh;
    typedef CGAL::Polyhedron_3<CGALKernel, CGAL::Polyhedron_items_with_id_3> Polyhedron;
    typedef CGAL::Mean_curvature_flow_skeletonization<SurfaceMesh> Skeletonization;
    typedef Skeletonization::Skeleton   MCSkeleton;
    typedef MCSkeleton::vertex_descriptor    MCVD;
    typedef MCSkeleton::edge_descriptor      MCED;
    typedef Skeletonization::Meso_skeleton  MESO;
    typedef vector<Point3d> WitnessType;
    typedef PropertyMap<vector<WitnessType>, WitnessType> AnnotationType;
 
 
    MeanCurvatureSkeleton3D();
 
    static void SetDefaultParameters(XMLNode& _node);
 
    void SetEnvironment(const Environment* _env);
 
    template<typename PolyhedronType>
      MeanCurvatureSkeleton3D(PolyhedronType& _poly, bool _d = false) : m_debug(_d) {
        AddPolyhedron(_poly);
      }
 
    ~MeanCurvatureSkeleton3D();
 
 
    void Write(string _filename);
 
    void Read(string _filename);
 
 
    template<typename PolyhedronType>
    void AddPolyhedron(PolyhedronType& _poly, double _refine = 1.32);
 
    void BuildSkeleton(bool _curve = true);
 
    void BuildSkeleton(const WorkspaceDecomposition* _decomposition, bool _curve = true);
 
 
    pair<WorkspaceSkeleton, AnnotationType> GetSkeleton();
 
    pair<WorkspaceSkeleton, AnnotationType> GetMesoSkeleton();
 
    void SetParameters(Parameters& _p) { m_params = _p; }
 
 
  private:
 
 
    void InitializeFreeSpace(const Environment* _env);
 
    void InitializeObstacleSpace(const Environment* _env);
 
    void GetWitnesses(MCVD& _v, vector<Point3d>& _witness);
 
    void GetWitnesses(MESO::Vertex& _v, vector<Point3d>& _witness);
 
    void GetWitnesses(Skeletonization::vertex_descriptor& _v, vector<Point3d>& _witness);
 
    void Reset();
 
    void Refine(SurfaceMesh& _m, double _f=1.00);
 
    void ToPolyLines(vector<vector<MCVD>>& _plines, bool _isSimplify = true);
 
    Point3 Point(MCVD& _vd) { return m_mcs[_vd].point; }
 
 
    SurfaceMesh m_input; 
    MCSkeleton m_mcs; 
    MESO m_meso; 
    WorkspaceSkeleton m_skeleton; 
    AnnotationType m_annotation;  
    bool m_debug{false};   
    Parameters m_params; 
    
};
 
/*------------------------Templated Modifiers---------------------------------*/
template<typename PolyhedronType>
void
MeanCurvatureSkeleton3D::
AddPolyhedron(PolyhedronType& _poly, double _refine) {
  stringstream ss;
  ss << _poly;
  ss >> m_input;
  Refine(m_input, _refine); //1.32
}
 
#endif