ConvexityHelper.h

 
#pragma once
 
#if defined(ConvexityHelper_RECURSES)
#error Recursive header files inclusion detected in ConvexityHelper.h
#else // defined(ConvexityHelper_RECURSES)
#define ConvexityHelper_RECURSES
 
#if !defined ConvexityHelper_h
#define ConvexityHelper_h
 
// Inclusions
#include <iostream>
#include <string>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/geometry/tools/QuickHull.h"
#include "DGtal/geometry/volumes/BoundedLatticePolytope.h"
#include "DGtal/geometry/volumes/BoundedRationalPolytope.h"
#include "DGtal/geometry/volumes/ConvexCellComplex.h"
#include "DGtal/shapes/PolygonalSurface.h"
 
namespace DGtal
{
 
    namespace detail {
 
    template < typename TIntegerCoordinate, bool safe >
    struct ConvexityHelperInternalInteger {
      typedef TIntegerCoordinate Type;
    };
 
    template < >
    struct ConvexityHelperInternalInteger< DGtal::int32_t, true > {
      typedef DGtal::BigInteger Type;
    };
 
    template < >
    struct ConvexityHelperInternalInteger< DGtal::int32_t, false > {
      typedef DGtal::int64_t Type;
    };
 
    template < >
    struct ConvexityHelperInternalInteger< DGtal::int64_t, true > {
      typedef DGtal::BigInteger Type;
    };
 
    template < >
    struct ConvexityHelperInternalInteger< DGtal::int64_t, false > {
      typedef DGtal::int64_t Type;
    };
 
    template < bool safe >
    struct ConvexityHelperInternalInteger< DGtal::BigInteger, safe > {
      typedef DGtal::BigInteger Type;
    };
 
    }  // namespace detail
  
  // template class ConvexityHelper
  template < int dim,
             typename TInteger = DGtal::int32_t,
             typename TInternalInteger = DGtal::int64_t >
  struct ConvexityHelper {
    BOOST_STATIC_ASSERT( dim > 1 );
    // Integer must be a model of the concept CInteger.
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ));
    // Integer must be a model of the concept CInteger.
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInternalInteger> ));
    
    static const Dimension dimension = dim;
 
    typedef TInteger                         Integer;
    typedef TInternalInteger                 InternalInteger;
    typedef SpaceND< dim, Integer >          Space;
    typedef typename Space::Point            Point;
    typedef typename Space::Vector           Vector;
    typedef typename Space::RealPoint        RealPoint;
    typedef typename Space::RealVector       RealVector;
    typedef std::size_t                      Size;
    typedef std::size_t                      Index;
    typedef std::vector< Index >             IndexRange;
    typedef std::vector< Point >             PointRange;
    typedef ConvexHullIntegralKernel< dim, Integer, InternalInteger >
    LatticeConvexHullKernel;
    typedef ConvexHullRationalKernel< dim, Integer, InternalInteger >
    RealConvexHullKernel;
    typedef DelaunayIntegralKernel< dim, Integer, InternalInteger >
    LatticeDelaunayKernel;
    typedef DelaunayRationalKernel< dim, Integer, InternalInteger >
    RealDelaunayKernel;
    typedef BoundedLatticePolytope< Space >  LatticePolytope;
    typedef BoundedRationalPolytope< Space > RationalPolytope;
 
    // ----------------- lattice convex hull services -------------------------
  public:
    
    static
    LatticePolytope
    computeLatticePolytope( const PointRange& input_points,
                            bool remove_duplicates = true,
                            bool make_minkowski_summable = false );
 
    static
    PointRange
    computeConvexHullVertices( const PointRange& input_points,
                               bool remove_duplicates = true );    
 
    
    template < typename TSurfaceMesh >
    static
    bool
    computeConvexHullBoundary( TSurfaceMesh&               mesh,
                               const PointRange& input_points,
                               bool remove_duplicates = true );
 
    static
    bool
    computeConvexHullBoundary( PolygonalSurface< Point >&  polysurf,
                               const PointRange& input_points,
                               bool remove_duplicates = true );
 
    static
    bool
    computeConvexHullCellComplex( ConvexCellComplex< Point >& cell_complex,
                                  const PointRange& input_points,
                                  bool remove_duplicates = true );
 
    static
    LatticePolytope
    computeSimplex( const PointRange& input_points,
                    bool remove_duplicates = true );
 
    static
    LatticePolytope
    computeDegeneratedLatticePolytope( PointRange& input_points );
 
    static
    PointRange
    computeDegeneratedConvexHullVertices( PointRange& input_points );
 
    static
    LatticePolytope
    compute3DTriangle( const Point& a, const Point& b, const Point& c,
                       bool make_minkowski_summable = false );
 
    static
    LatticePolytope
    compute3DOpenTriangle( const Point& a, const Point& b, const Point& c,
                           bool make_minkowski_summable = false );
    
    static
    LatticePolytope
    computeDegeneratedTriangle( const Point& a, const Point& b, const Point& c );
 
    
    static
    LatticePolytope
    computeSegment( const Point& a, const Point& b );
 
    static
    LatticePolytope
    computeOpenSegment( const Point& a, const Point& b );
    
    
    // ----------------- lattice Delaunay services -------------------------
  public:
 
    static
    bool
    computeDelaunayCellComplex( ConvexCellComplex< Point >& cell_complex,
                                const PointRange& input_points,
                                bool remove_duplicates = true );
    
 
    // ----------------- rational convex hull services -------------------------
  public:
    
    static
    RationalPolytope
    computeRationalPolytope( const std::vector< RealPoint >& input_points,
                             Integer denominator, 
                             bool remove_duplicates = true,
                             bool make_minkowski_summable = false );
 
    template < typename TSurfaceMesh >
    static
    bool
    computeConvexHullBoundary( TSurfaceMesh&               mesh,
                               const std::vector< RealPoint >& input_points,
                               double precision = 1024.0,
                               bool remove_duplicates = true );
 
    static
    bool
    computeConvexHullBoundary( PolygonalSurface< RealPoint > & polysurf,
                               const std::vector< RealPoint >& input_points,
                               double precision = 1024.0,
                               bool remove_duplicates = true );
 
    static
    bool
    computeConvexHullCellComplex( ConvexCellComplex< RealPoint >& cell_complex,
                                  const std::vector< RealPoint >& input_points,
                                  double precision = 1024.0,
                                  bool remove_duplicates = true );
    
 
 
    // ----------------- real Delaunay services -------------------------
  public:
 
    static
    bool
    computeDelaunayCellComplex( ConvexCellComplex< RealPoint >& cell_complex,
                                const std::vector< RealPoint >& input_points,
                                double precision = 1024.0,
                                bool remove_duplicates = true );
    
    
    // ----------------- utility services -------------------------
  public:
 
    template < typename QHull >
    static
    void
    computeFacetAndRidgeVertices( const QHull& hull,
                                  std::vector< IndexRange >& cell_vertices,
                                  std::map< typename QHull::Ridge, Index >& r2f,
                                  std::vector< IndexRange >& face_vertices );
 
    
  }; // class ConvexityHelper
 
  
} // namespace DGtal
 
// Includes inline functions.
#include "ConvexityHelper.ih"
 
//                                                                           //
 
#endif // !defined ConvexityHelper_h
 
#undef ConvexityHelper_RECURSES
#endif // else defined(ConvexityHelper_RECURSES)