KhalimskySpaceND.h

 
#pragma once
 
#if defined(KhalimskySpaceND_RECURSES)
#error Recursive header files inclusion detected in KhalimskySpaceND.h
#else // defined(KhalimskySpaceND_RECURSES)
#define KhalimskySpaceND_RECURSES
 
#if !defined KhalimskySpaceND_h
#define KhalimskySpaceND_h
 
// Inclusions
#include <iostream>
#include <set>
#include <map>
#include <array>
#include <DGtal/base/Common.h>
#include <DGtal/kernel/CInteger.h>
#include <DGtal/kernel/PointVector.h>
#include <DGtal/kernel/SpaceND.h>
#include <DGtal/topology/KhalimskyPreSpaceND.h>
 
namespace DGtal
{
  // Pre-declaration
  template <
      Dimension dim,
      typename TInteger = DGtal::int32_t
  >
  class KhalimskySpaceND;
 
 
  template < class TKhalimskySpace >
  class KhalimskySpaceNDHelper;
 
 
  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  struct KhalimskyCell
  {
 
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
 
 
    // Aliases
  public:
    using Integer = TInteger;
    using UnsignedInteger = typename NumberTraits<Integer>::UnsignedVersion;
    using Point   = PointVector< dim, Integer >;
    using PreCell = KhalimskyPreCell< dim, Integer >;
    using CellularGridSpace = KhalimskySpaceND< dim, TInteger >;
    using PreCellularGridSpace = KhalimskyPreSpaceND< dim, TInteger >;
    using Self    = KhalimskyCell< dim, Integer >;
 
    // Friendship
    friend class KhalimskySpaceND< dim, TInteger >;
    friend class KhalimskySpaceNDHelper< CellularGridSpace >;
 
  private:
    PreCell myPreCell;
 
  private:
 
    explicit KhalimskyCell( const Point & aPoint );
 
    explicit KhalimskyCell( const PreCell & aCell );
 
  public:
    operator PreCell const& () const;
 
    PreCell const& preCell() const;
 
  private:
    explicit operator PreCell & ();
 
  public:
    explicit KhalimskyCell( Integer dummy = 0 );
 
    KhalimskyCell( const KhalimskyCell & other ) = default;
 
    KhalimskyCell & operator=( const KhalimskyCell & other ) = default;
 
    KhalimskyCell( KhalimskyCell && other ) = default;
 
    KhalimskyCell & operator=( KhalimskyCell && other ) = default;
 
    bool operator==( const KhalimskyCell & other ) const;
 
    bool operator!=( const KhalimskyCell & other ) const;
 
    bool operator<( const KhalimskyCell & other ) const;
 
    // --------------- CDrawableWithBoard2D realization -------------------
  public:
 
    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
 
    std::string className() const;
 
  };
 
  template < Dimension dim,
             typename TInteger >
  std::ostream &
  operator<<( std::ostream & out,
              const KhalimskyCell< dim, TInteger > & object );
 
 
 
  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  struct SignedKhalimskyCell
  {
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
 
    // Aliases
  public:
    using Integer = TInteger;
    using UnsignedInteger = typename NumberTraits<Integer>::UnsignedVersion;
    using Point   = PointVector< dim, Integer >;
    using SPreCell = SignedKhalimskyPreCell< dim, Integer >;
    using CellularGridSpace = KhalimskySpaceND< dim, TInteger >;
    using PreCellularGridSpace = KhalimskyPreSpaceND< dim, TInteger >;
    using Self    = SignedKhalimskyCell< dim, Integer >;
 
    // Friendship
    friend class KhalimskySpaceND< dim, TInteger >;
    friend class KhalimskySpaceNDHelper< CellularGridSpace >;
 
  private:
    SPreCell mySPreCell;
 
  private:
    explicit SignedKhalimskyCell( const Point & aPoint, bool positive );
 
    explicit SignedKhalimskyCell( const SPreCell & aCell );
 
  public:
    operator SPreCell const& () const;
 
    SPreCell const& preCell() const;
 
  private:
    explicit operator SPreCell & ();
 
  public:
    explicit SignedKhalimskyCell( Integer dummy = 0 );
 
    SignedKhalimskyCell( const SignedKhalimskyCell & other ) = default;
 
    SignedKhalimskyCell & operator=( const SignedKhalimskyCell & other ) = default;
 
    SignedKhalimskyCell( SignedKhalimskyCell && other ) = default;
 
    SignedKhalimskyCell & operator=( SignedKhalimskyCell && other ) = default;
 
    bool operator==( const SignedKhalimskyCell & other ) const;
 
    bool operator!=( const SignedKhalimskyCell & other ) const;
 
    bool operator<( const SignedKhalimskyCell & other ) const;
 
    // --------------- CDrawableWithBoard2D realization -------------------
  public:
 
    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
 
    std::string className() const;
 
  };
 
  template < Dimension dim,
             typename TInteger >
  std::ostream &
  operator<<( std::ostream & out,
              const SignedKhalimskyCell< dim, TInteger > & object );
 
  // template class KhalimskySpaceND
  template <
      Dimension dim,
      typename TInteger
  >
  class KhalimskySpaceND
    : private KhalimskySpaceNDHelper< KhalimskySpaceND< dim, TInteger > >
  {
 
    typedef KhalimskySpaceNDHelper< KhalimskySpaceND< dim, TInteger > > Helper; 
    friend class KhalimskySpaceNDHelper< KhalimskySpaceND< dim, TInteger > >;
 
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
 
  public:
    typedef TInteger Integer;
 
    typedef typename NumberTraits<Integer>::UnsignedVersion Size;
 
    // Spaces
    typedef SpaceND<dim, Integer> Space;
    typedef KhalimskySpaceND<dim, Integer>    CellularGridSpace;
    typedef KhalimskyPreSpaceND<dim, Integer> PreCellularGridSpace;
 
    // Cells
    typedef KhalimskyCell< dim, Integer > Cell;
    typedef KhalimskyPreCell< dim, Integer > PreCell;
    typedef SignedKhalimskyCell< dim, Integer > SCell;
    typedef SignedKhalimskyPreCell< dim, Integer > SPreCell;
 
    typedef SCell Surfel;
    typedef bool Sign;
    using DirIterator = typename PreCellularGridSpace::DirIterator;
 
    // Points and Vectors
    typedef PointVector< dim, Integer > Point;
    typedef PointVector< dim, Integer > Vector;
 
 
    // static constants
    static const constexpr Dimension dimension = dim;
    static const constexpr Dimension DIM = dim;
    static const constexpr Sign POS = true;
    static const constexpr Sign NEG = false;
 
    template < typename CellType >
    using AnyCellCollection = typename PreCellularGridSpace::template AnyCellCollection< CellType >;
 
    // Neighborhoods, Incident cells, Faces and Cofaces
    typedef AnyCellCollection<Cell> Cells;
    typedef AnyCellCollection<SCell> SCells;
 
    // Sets, Maps
    typedef std::set<Cell> CellSet;
 
    typedef std::set<SCell> SCellSet;
 
    typedef std::set<SCell> SurfelSet;
 
    template <typename Value> struct CellMap {
        typedef std::map<Cell,Value> Type;
    };
 
    template <typename Value> struct SCellMap {
        typedef std::map<SCell,Value> Type;
    };
 
    template <typename Value> struct SurfelMap {
        typedef std::map<SCell,Value> Type;
    };
 
    enum Closure
      {
        CLOSED,   
        OPEN,     
        PERIODIC  
      };
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~KhalimskySpaceND();
 
    KhalimskySpaceND();
 
    KhalimskySpaceND ( const KhalimskySpaceND & other ) = default;
 
    KhalimskySpaceND & operator= ( const KhalimskySpaceND & other ) = default;
 
    KhalimskySpaceND ( KhalimskySpaceND && other ) = default;
 
    KhalimskySpaceND & operator= ( KhalimskySpaceND && other ) = default;
 
    bool init( const Point & lower,
               const Point & upper,
               bool isClosed );
 
    bool init( const Point & lower,
               const Point & upper,
               Closure closure );
 
    bool init( const Point & lower,
               const Point & upper,
               const std::array<Closure, dim> & closure );
 
 
    // ------------------------- Basic services ------------------------------
  public:
 
    Size size( Dimension k ) const;
 
    Integer min( Dimension k ) const;
 
    Integer max( Dimension k ) const;
 
    const Point & lowerBound() const;
 
    const Point & upperBound() const;
 
    const Cell & lowerCell() const;
 
    const Cell & upperCell() const;
 
    bool uIsValid( const PreCell & c, Dimension k ) const;
 
    bool uIsValid( const PreCell & c ) const;
 
    bool sIsValid( const SPreCell & c, Dimension k ) const;
 
    bool sIsValid( const SPreCell & c ) const;
 
    bool cIsValid( const Point & p, Dimension k ) const;
 
    bool cIsValid( const Point & p ) const;
 
 
    // ----------------------- Closure type query --------------------------
  public:
 
    bool isSpaceClosed() const;
 
    bool isSpaceClosed( Dimension k ) const;
 
    bool isSpacePeriodic() const;
 
    bool isSpacePeriodic( Dimension k ) const;
 
    bool isAnyDimensionPeriodic() const;
 
    Closure getClosure( Dimension k ) const;
 
 
    // ----------------------- Cell creation services --------------------------
  public:
 
    Cell uCell( const PreCell & c ) const;
 
    Cell uCell( const Point & kp ) const;
 
    Cell uCell( Point p, const PreCell & c ) const;
 
    SCell sCell( const SPreCell & c ) const;
 
    SCell sCell( const Point & kp, Sign sign = POS ) const;
 
    SCell sCell( Point p, const SPreCell & c ) const;
 
    Cell uSpel( Point p ) const;
 
    SCell sSpel( Point p, Sign sign = POS ) const;
 
    Cell uPointel( Point p ) const;
 
    SCell sPointel( Point p, Sign sign = POS ) const;
 
 
    // ----------------------- Read accessors to cells ------------------------
  public:
    Integer uKCoord( const Cell & c, Dimension k ) const;
 
    Integer uCoord( const Cell & c, Dimension k ) const;
 
    const Point & uKCoords( const Cell & c ) const;
 
    Point uCoords( const Cell & c ) const;
 
    Integer sKCoord( const SCell & c, Dimension k ) const;
 
    Integer sCoord( const SCell & c, Dimension k ) const;
 
    const Point & sKCoords( const SCell & c ) const;
 
    Point sCoords( const SCell & c  ) const;
 
    Sign sSign( const SCell & c ) const;
 
 
    // ----------------------- Write accessors to cells ------------------------
  public:
 
    void uSetKCoord( Cell & c, Dimension k, Integer i ) const;
 
    void sSetKCoord( SCell & c, Dimension k, Integer i ) const;
 
    void uSetCoord( Cell & c, Dimension k, Integer i ) const;
 
    void sSetCoord( SCell & c, Dimension k, Integer i ) const;
 
    void uSetKCoords( Cell & c, const Point & kp ) const;
 
    void sSetKCoords( SCell & c, const Point & kp ) const;
 
    void uSetCoords( Cell & c, const Point & kp ) const;
 
    void sSetCoords( SCell & c, const Point & kp ) const;
 
    void sSetSign( SCell & c, Sign s ) const;
 
 
    // -------------------- Conversion signed/unsigned ------------------------
  public:
    SCell signs( const Cell & p, Sign s ) const;
 
    Cell unsigns( const SCell & p ) const;
 
    SCell sOpp( const SCell & p ) const;
 
 
    // ------------------------- Cell topology services -----------------------
  public:
    Integer uTopology( const Cell & p ) const;
 
    Integer sTopology( const SCell & p ) const;
 
    Dimension uDim( const Cell & p ) const;
 
    Dimension sDim( const SCell & p ) const;
 
    bool uIsSurfel( const Cell & b ) const;
 
    bool sIsSurfel( const SCell & b ) const;
 
    bool uIsOpen( const Cell & p, Dimension k ) const;
 
    bool sIsOpen( const SCell & p, Dimension k ) const;
 
 
    // -------------------- Iterator services for cells ------------------------
  public:
 
    DirIterator uDirs( const Cell & p ) const;
 
    DirIterator sDirs( const SCell & p ) const;
 
    DirIterator uOrthDirs( const Cell & p ) const;
 
    DirIterator sOrthDirs( const SCell & p ) const;
 
    Dimension uOrthDir( const Cell & s ) const;
 
    Dimension sOrthDir( const SCell & s ) const;
 
 
    // -------------------- Unsigned cell geometry services --------------------
  public:
 
    Integer uFirst( const PreCell & p, Dimension k ) const;
 
    Cell uFirst( const PreCell & p ) const;
 
    Integer uLast( const PreCell & p, Dimension k ) const;
 
    Cell uLast( const PreCell & p ) const;
 
    Cell uGetIncr( const Cell & p, Dimension k ) const;
 
    bool uIsMax( const Cell & p, Dimension k ) const;
 
 
    bool uIsInside( const PreCell & p, Dimension k ) const;
 
 
    bool uIsInside( const PreCell & p ) const;
 
    bool cIsInside( const Point & p, Dimension k ) const;
 
 
    bool cIsInside( const Point & p ) const;
 
    Cell uGetMax( Cell p, Dimension k ) const;
 
    Cell uGetDecr( const Cell & p, Dimension k ) const;
 
    bool uIsMin( const Cell & p, Dimension k ) const;
 
    Cell uGetMin( Cell p, Dimension k ) const;
 
 
    Cell uGetAdd( const Cell & p, Dimension k, Integer x ) const;
 
    Cell uGetSub( const Cell & p, Dimension k, Integer x ) const;
 
    Integer uDistanceToMax( const Cell & p, Dimension k ) const;
 
    Integer uDistanceToMin( const Cell & p, Dimension k ) const;
 
    Cell uTranslation( const Cell & p, const Vector & vec ) const;
 
    Cell uProjection( const Cell & p, const Cell & bound, Dimension k ) const;
 
    void uProject( Cell & p, const Cell & bound, Dimension k ) const;
 
    bool uNext( Cell & p, const Cell & lower, const Cell & upper ) const;
 
 
    // -------------------- Signed cell geometry services --------------------
  public:
 
    Integer sFirst( const SPreCell & p, Dimension k ) const;
 
    SCell sFirst( const SPreCell & p ) const;
 
    Integer sLast( const SPreCell & p, Dimension k ) const;
 
    SCell sLast( const SPreCell & p ) const;
 
    SCell sGetIncr( const SCell & p, Dimension k ) const;
 
    bool sIsMax( const SCell & p, Dimension k ) const;
 
    bool sIsInside( const SPreCell & p, Dimension k ) const;
 
    bool sIsInside( const SPreCell & p ) const;
 
    SCell sGetMax( SCell p, Dimension k ) const;
 
    SCell sGetDecr( const SCell & p, Dimension k ) const;
 
    bool sIsMin( const SCell & p, Dimension k ) const;
 
    SCell sGetMin( SCell p, Dimension k ) const;
 
    SCell sGetAdd( const SCell & p, Dimension k, Integer x ) const;
 
    SCell sGetSub( const SCell & p, Dimension k, Integer x ) const;
 
    Integer sDistanceToMax( const SCell & p, Dimension k ) const;
 
    Integer sDistanceToMin( const SCell & p, Dimension k ) const;
 
    SCell sTranslation( const SCell & p, const Vector & vec ) const;
 
    SCell sProjection( const SCell & p, const SCell & bound, Dimension k ) const;
 
    void sProject( SCell & p, const SCell & bound, Dimension k ) const;
 
    bool sNext( SCell & p, const SCell & lower, const SCell & upper ) const;
 
 
    // ----------------------- Neighborhood services --------------------------
  public:
 
    Cells uNeighborhood( const Cell & cell ) const;
 
    SCells sNeighborhood( const SCell & cell ) const;
 
    Cells uProperNeighborhood( const Cell & cell ) const;
 
    SCells sProperNeighborhood( const SCell & cell ) const;
 
    Cell uAdjacent( const Cell & p, Dimension k, bool up ) const;
 
    SCell sAdjacent( const SCell & p, Dimension k, bool up ) const;
 
 
    // ----------------------- Incidence services --------------------------
  public:
 
    Cell uIncident( const Cell & c, Dimension k, bool up ) const;
 
    SCell sIncident( const SCell & c, Dimension k, bool up ) const;
 
    Cells uLowerIncident( const Cell & c ) const;
 
    Cells uUpperIncident( const Cell & c ) const;
 
    SCells sLowerIncident( const SCell & c ) const;
 
    SCells sUpperIncident( const SCell & c ) const;
 
    Cells uFaces( const Cell & c ) const;
 
    Cells uCoFaces( const Cell & c ) const;
 
    bool sDirect( const SCell & p, Dimension k ) const;
 
    SCell sDirectIncident( const SCell & p, Dimension k ) const;
 
    SCell sIndirectIncident( const SCell & p, Dimension k ) const;
 
    
    
    Point interiorVoxel( const SCell & c ) const;
    
    Point exteriorVoxel( const SCell & c ) const;
    
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
    Point myLower;
    Point myUpper;
    Cell myCellLower;
    Cell myCellUpper;
    std::array<Closure, dimension> myClosure;
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
 
  private:
 
 
 
    // ------------------------- Internals ------------------------------------
  private:
    void uAddFaces( Cells& faces, const Cell& c, Dimension axis ) const;
 
    void uAddCoFaces( Cells& cofaces, const Cell& c, Dimension axis ) const;
 
 
  }; // end of class KhalimskySpaceND
 
 
  template < Dimension dim,
             typename TInteger >
  std::ostream&
  operator<< ( std::ostream & out,
               const KhalimskySpaceND<dim, TInteger > & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/topology/KhalimskySpaceND.ih"
 
//                                                                           //
 
#endif // !defined KhalimskySpaceND_h
 
#undef KhalimskySpaceND_RECURSES
#endif // else defined(KhalimskySpaceND_RECURSES)