DigitalConvexity.h

 
#pragma once
 
#if defined(DigitalConvexity_RECURSES)
#error Recursive header files inclusion detected in DigitalConvexity.h
#else // defined(DigitalConvexity_RECURSES)
 
#define DigitalConvexity_RECURSES
 
#if !defined DigitalConvexity_h
 
#define DigitalConvexity_h
 
// Inclusions
#include <iostream>
#include <list>
#include <vector>
#include <string>
#include <unordered_set>
#include "DGtal/base/Common.h"
#include "DGtal/base/Clone.h"
#include "DGtal/topology/CCellularGridSpaceND.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/geometry/volumes/BoundedLatticePolytope.h"
#include "DGtal/geometry/volumes/BoundedRationalPolytope.h"
#include "DGtal/geometry/volumes/CellGeometry.h"
 
namespace DGtal
{
 
  // template class DigitalConvexity
  template < typename TKSpace >
  class DigitalConvexity
  {
    BOOST_CONCEPT_ASSERT(( concepts::CCellularGridSpaceND< TKSpace > ));
 
  public:
    typedef DigitalConvexity<TKSpace>       Self;
    typedef TKSpace                         KSpace;
    typedef typename KSpace::Integer        Integer;
    typedef typename KSpace::Point          Point;
    typedef typename KSpace::Vector         Vector;
    typedef typename KSpace::Cell           Cell;
    typedef typename KSpace::Space          Space;
    typedef DGtal::BoundedLatticePolytope < Space > Polytope;
    typedef DGtal::BoundedLatticePolytope < Space > LatticePolytope;
    typedef DGtal::BoundedRationalPolytope< Space > RationalPolytope;
    typedef DGtal::CellGeometry< KSpace >   CellGeometry;
    typedef std::vector<Point>              PointRange;
    typedef std::unordered_set<Point>       PointSet;
 
    static const Dimension dimension = KSpace::dimension;
 
 
 
    ~DigitalConvexity() = default;
 
    DigitalConvexity() = default;
 
    DigitalConvexity ( const Self & other ) = default;
 
    DigitalConvexity( Clone<KSpace> K );
 
    DigitalConvexity( Point lo, Point hi );
 
    Self & operator= ( const Self & other ) = default;
 
    const KSpace& space() const;
 
 
    // ----------------------- Simplex services --------------------------------------
  public:
 
    template <typename PointIterator>
    static
    LatticePolytope makeSimplex( PointIterator itB, PointIterator itE );
 
    static
    LatticePolytope makeSimplex( std::initializer_list<Point> l );
 
    template <typename PointIterator>
    static
    RationalPolytope makeRationalSimplex( Integer d,
                                          PointIterator itB, PointIterator itE );
 
    static
    RationalPolytope makeRationalSimplex( std::initializer_list<Point> l );
 
    template <typename PointIterator>
    static
    bool isSimplexFullDimensional( PointIterator itB, PointIterator itE );
 
    static
    bool isSimplexFullDimensional( std::initializer_list<Point> l );
 
    enum class SimplexType{
      INVALID,     
      DEGENERATED, 
      UNITARY,     
      COMMON       
    };
 
    template <typename PointIterator>
    static
    SimplexType simplexType( PointIterator itB, PointIterator itE );
 
    static
    SimplexType simplexType( std::initializer_list<Point> l );
 
    template <typename PointIterator>
    static
    void displaySimplex( std::ostream& out, PointIterator itB, PointIterator itE );
 
    static
    void displaySimplex( std::ostream& out, std::initializer_list<Point> l );
 
 
    // ----------------------- Polytope services --------------------------------------
  public:
 
    static
    PointRange insidePoints( const LatticePolytope& polytope );
 
    static
    PointRange interiorPoints( const LatticePolytope& polytope );
 
    static
    PointRange insidePoints( const RationalPolytope& polytope );
 
    static
    PointRange interiorPoints( const RationalPolytope& polytope );
 
 
 
    // ----------------------- Cell geometry services -----------------------------------
  public:
 
    template <typename PointIterator>
    CellGeometry makeCellCover( PointIterator itB, PointIterator itE,
                                Dimension i = 0,
                                Dimension k = KSpace::dimension ) const;
 
    CellGeometry makeCellCover( const LatticePolytope& P,
                                Dimension i = 0,
                                Dimension k = KSpace::dimension ) const;
 
    CellGeometry makeCellCover( const RationalPolytope& P,
                                Dimension i = 0,
                                Dimension k = KSpace::dimension ) const;
 
    // ----------------------- Morphological services -----------------------------------
  public:
 
    LatticePolytope makePolytope( const PointRange& X, bool safe = false ) const;
    
    PointRange U( Dimension i, const PointRange& X ) const;
 
    bool is0Convex( const PointRange& X, bool safe = false ) const;
    
    bool isFullyConvex( const PointRange& X, bool convex0 = false,
                        bool safe = false ) const;
    
    
    // ----------------------- Convexity services for lattice polytopes -----------------
  public:
 
 
    bool isKConvex( const LatticePolytope& P, const Dimension k ) const;
 
 
    bool isFullyConvex( const LatticePolytope& P ) const;
 
 
    bool isKSubconvex( const LatticePolytope& P, const CellGeometry& C, const Dimension k ) const;
 
 
    bool isFullySubconvex( const LatticePolytope& P, const CellGeometry& C ) const;
 
    bool isKSubconvex( const Point& a, const Point& b,
                       const CellGeometry& C, const Dimension k ) const;
 
    bool isFullySubconvex( const Point& a, const Point& b,
                           const CellGeometry& C ) const;
    
 
    // ----------------------- Convexity services for rational polytopes ----------------
  public:
 
 
    bool isKConvex( const RationalPolytope& P, const Dimension k ) const;
 
 
    bool isFullyConvex( const RationalPolytope& P ) const;
 
 
    bool isKSubconvex( const RationalPolytope& P, const CellGeometry& C, const Dimension k ) const;
 
 
    bool isFullySubconvex( const RationalPolytope& P, const CellGeometry& C ) const;
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
 
    // ------------------------- Protected Datas ------------------------------
  protected:
    KSpace myK;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class DigitalConvexity
 
 
  template <typename TKSpace>
  std::ostream&
  operator<< ( std::ostream & out,
               const DigitalConvexity<TKSpace> & object );
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DigitalConvexity.ih"
 
//                                                                           //
 
#endif // !defined DigitalConvexity_h
 
#undef DigitalConvexity_RECURSES
#endif // else defined(DigitalConvexity_RECURSES)