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 "DGtal/base/Common.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/CCommutativeRing.h"
#include "DGtal/kernel/CSignedInteger.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/kernel/SpaceND.h"
//#include "DGtal/io/boards/Board2D.h"


//#include "DGtal/io/Display3D.h"

#ifdef _MSC_VER
#if defined( max )
#undef max 
#define _HAS_MSVC_MAX_ true
#endif
#if defined( min )
#undef min 
#define _HAS_MSVC_MIN_ true
#endif
#endif



namespace DGtal
{

  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  struct KhalimskyCell
  {

    //Integer must be a model of the concept CInteger.
    BOOST_CONCEPT_ASSERT(( CInteger<TInteger> ) );
    //Integer must be signed to characterize a ring.
    BOOST_CONCEPT_ASSERT(( CSignedInteger<TInteger> ) );
    
  public:
    typedef TInteger Integer;
    
    typedef typename NumberTraits<Integer>::UnsignedVersion UnsignedInteger;
    typedef PointVector< dim, Integer > Point;

    Point myCoordinates;

    KhalimskyCell();
    
    KhalimskyCell( const KhalimskyCell & other );

    KhalimskyCell( const Point & point );

    KhalimskyCell & operator=( const KhalimskyCell & other );

    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(( CInteger<TInteger> ) );
    //Integer must be signed to characterize a ring.
    BOOST_CONCEPT_ASSERT(( CSignedInteger<TInteger> ) );
 
  public:
    typedef TInteger Integer;
    typedef typename NumberTraits<Integer>::UnsignedVersion UnsignedInteger;
    typedef PointVector< dim, Integer > Point;

    Point myCoordinates;
    bool myPositive;

    SignedKhalimskyCell();
    
    SignedKhalimskyCell( const SignedKhalimskyCell & other );

    SignedKhalimskyCell( const Point & point, bool positive );

    SignedKhalimskyCell & operator=( const SignedKhalimskyCell & other );

    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 < Dimension dim,
             typename TInteger = DGtal::int32_t >
  class CellDirectionIterator 
  {
  public:
    typedef TInteger Integer;
    // Cells
    typedef KhalimskyCell< dim, Integer > Cell;
    typedef SignedKhalimskyCell< dim, Integer > SCell;

  public:
    CellDirectionIterator( Cell cell, bool open = true );

    CellDirectionIterator( SCell scell, bool open = true );

    Dimension operator*() const;

    CellDirectionIterator & operator++();
    
    bool operator!=( const Integer ) const;

    bool end() const;

    bool operator!=( const CellDirectionIterator & other ) const;

    bool operator==( const CellDirectionIterator & other ) const;
    
  private:
    Dimension myDir;
    Cell myCell;
    bool myOpen;

  private:
    void find();
  };


  // template class KhalimskySpaceND
  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  class KhalimskySpaceND
  {
    //Integer must be signed to characterize a ring.
    BOOST_CONCEPT_ASSERT(( CCommutativeRing<TInteger> ) );

  public:
    typedef TInteger Integer;
    
    typedef typename NumberTraits<Integer>::UnsignedVersion Size;
      
    // Cells
    typedef KhalimskyCell< dim, Integer > Cell;
    typedef SignedKhalimskyCell< dim, Integer > SCell;
    typedef SCell Surfel;
    typedef bool Sign;
    typedef CellDirectionIterator< dim, Integer > DirIterator;
    
    //Points and Vectors
    typedef PointVector< dim, Integer > Point;
    typedef PointVector< dim, Integer > Vector;
    
    typedef SpaceND<dim, Integer> Space;
    typedef KhalimskySpaceND<dim, Integer> KhalimskySpace;

#if defined ( WIN32 )
    // static constants
    static const Dimension dimension = dim;
    static const Dimension DIM = dim;
    static const Sign POS = true;
    static const Sign NEG = false;
#else
    // static constants
    static const Dimension dimension = dim;
    static const Dimension DIM;
    static const Sign POS;
    static const Sign NEG;
#endif //WIN32

    template <typename CellType>
    struct AnyCellCollection : public std::deque<CellType> {
      typedef CellType Value;
      typedef typename std::deque<CellType> Container;
      typedef typename std::deque<CellType>::iterator Iterator;
      typedef typename std::deque<CellType>::const_iterator ConstIterator;
    };

    // 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<SCell,Value> Type;
    };
    template <typename Value> struct SCellMap {
      typedef std::map<SCell,Value> Type;
    };
    template <typename Value> struct SurfelMap {
      typedef std::map<SCell,Value> Type;
    };
    // ----------------------- Standard services ------------------------------
  public:

    ~KhalimskySpaceND();

    KhalimskySpaceND();

    KhalimskySpaceND ( const KhalimskySpaceND & other );

    KhalimskySpaceND & operator= ( const KhalimskySpaceND & other );
    
    bool init( const Point & lower,
               const Point & upper,
               bool closed );

    // ------------------------- 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 isSpaceClosed() const; 

    // ----------------------- Cell creation services --------------------------
  public:

    Cell uCell( const Point & kp ) const;

    Cell uCell( const Point & p, const Cell & c ) const;

    SCell sCell( const Point & kp, Sign sign = POS ) const;

    SCell sCell( const Point & p, const SCell & c ) const;

    Cell uSpel( const Point & p ) const;

    SCell sSpel( const Point & p, Sign sign = POS ) const;

    Cell uPointel( const Point & p ) const;

    SCell sPointel( const 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;

    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;

    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, const Integer & i ) const;

    void sSetKCoord( SCell & c, Dimension k, const 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:

    Cell uFirst( const Cell & p ) const;
    
    Cell uLast( const Cell & p ) const;

    Cell uGetIncr( const Cell & p, Dimension k ) const;
 
    bool uIsMax( const Cell & p, Dimension k ) const;


    bool uIsInside( const Cell & p, Dimension k ) const;
 

    Cell uGetMax( const Cell & p, Dimension k ) const;
    
    Cell uGetDecr( const Cell & p, Dimension k ) const;

    bool uIsMin( const Cell & p, Dimension k ) const;

    Cell uGetMin( const Cell & p, Dimension k ) const;

    
    Cell uGetAdd( const Cell & p, Dimension k, const Integer & x ) const;

    Cell uGetSub( const Cell & p, Dimension k, const 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:

    SCell sFirst( const SCell & p ) const;
    
    SCell sLast( const SCell & p ) const;

    SCell sGetIncr( const SCell & p, Dimension k ) const;
 
    bool sIsMax( const SCell & p, Dimension k ) const;

    bool sIsInside( const SCell & p, Dimension k ) const;

    SCell sGetMax( const SCell & p, Dimension k ) const;

    SCell sGetDecr( const SCell & p, Dimension k ) const;

    bool sIsMin( const SCell & p, Dimension k ) const;

    SCell sGetMin( const SCell & p, Dimension k ) const;

    SCell sGetAdd( const SCell & p, Dimension k, const Integer & x ) const;

    SCell sGetSub( const SCell & p, Dimension k, const 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;
    bool myIsClosed;
    // ------------------------- Hidden services ------------------------------
  protected:


  private:



    // ------------------------- Internals ------------------------------------
  private:

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