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
  {

    //Integer must be a model of the concept CInteger.
    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:
    // Underlying pre-cell
    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
  {
    //Integer must be a model of the concept CInteger.
    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:
    // Underlying signed pre-cell
    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 > >;

    //Integer must be signed to characterize a ring.
    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;


    // ----------------------- 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)