KhalimskyPreSpaceND.h

 
#pragma once
 
#if defined(KhalimskyPreSpaceND_RECURSES)
#error Recursive header files inclusion detected in KhalimskyPreSpaceND.h
#else // defined(KhalimskyPreSpaceND_RECURSES)
#define KhalimskyPreSpaceND_RECURSES
 
#if !defined KhalimskyPreSpaceND_h
#define KhalimskyPreSpaceND_h
 
// Inclusions
#include <iostream>
#include <set>
#include <map>
#include <DGtal/base/Common.h>
#include <DGtal/kernel/CInteger.h>
#include <DGtal/kernel/PointVector.h>
#include <DGtal/kernel/SpaceND.h>
 
namespace DGtal
{
 
  // Pre-declaration
  template <
      Dimension dim,
      typename TInteger = DGtal::int32_t
  >
  class KhalimskyPreSpaceND;
 
 
  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  struct KhalimskyPreCell
  {
 
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
 
    // Aliases
  public:
    using Integer = TInteger;
    using UnsignedInteger = typename NumberTraits<Integer>::UnsignedVersion;
    using Point   = PointVector< dim, Integer >;
    using Self    = KhalimskyPreCell< dim, Integer >;
    using PreCell = Self;
    using PreCellularGridSpace = KhalimskyPreSpaceND< dim, TInteger >;
    using CellularGridSpace    = PreCellularGridSpace;
 
    // Public members
  public:
    Point coordinates; 
 
    // Standard interface
  public:
 
    PreCell const& preCell() const;
 
    explicit KhalimskyPreCell( Integer dummy = 0 );
 
 
    KhalimskyPreCell( Point const& aPoint );
 
    KhalimskyPreCell( KhalimskyPreCell const& aCell ) = default;
 
    KhalimskyPreCell & operator=( KhalimskyPreCell const& aCell ) = default;
 
    KhalimskyPreCell( KhalimskyPreCell && aCell ) = default;
 
    KhalimskyPreCell & operator=( KhalimskyPreCell && aCell ) = default;
 
    bool operator==( const KhalimskyPreCell & other ) const;
 
    bool operator!=( const KhalimskyPreCell & other ) const;
 
    bool operator<( const KhalimskyPreCell & other ) const;
 
    // --------------- CDrawableWithBoard2D realization -------------------
  public:
 
    std::string className() const;
 
  }; // KhalimskyPreCell
 
  template < Dimension dim,
             typename TInteger >
  std::ostream &
  operator<<( std::ostream & out,
              const KhalimskyPreCell< dim, TInteger > & object );
 
  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  struct SignedKhalimskyPreCell
  {
 
    // 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 Self    = SignedKhalimskyPreCell< dim, Integer >;
    using SPreCell = Self;
    using PreCellularGridSpace = KhalimskyPreSpaceND< dim, TInteger >;
    using CellularGridSpace    = PreCellularGridSpace;
 
    // Public members
  public:
    Point coordinates;  
    bool  positive;     
 
    // Standard interface
  public:
 
    SPreCell const& preCell() const;
 
    explicit SignedKhalimskyPreCell( Integer dummy = 0 );
 
    SignedKhalimskyPreCell( Point const& aPoint, bool positive );
 
    SignedKhalimskyPreCell( SignedKhalimskyPreCell const& aCell ) = default;
 
    SignedKhalimskyPreCell & operator=( SignedKhalimskyPreCell const& aCell ) = default;
 
    SignedKhalimskyPreCell( SignedKhalimskyPreCell && aCell ) = default;
 
    SignedKhalimskyPreCell & operator=( SignedKhalimskyPreCell && aCell ) = default;
 
    bool operator==( const SignedKhalimskyPreCell & other ) const;
 
    bool operator!=( const SignedKhalimskyPreCell & other ) const;
 
    bool operator<( const SignedKhalimskyPreCell & other ) const;
 
    // --------------- CDrawableWithBoard2D realization -------------------
  public:
 
    std::string className() const;
 
  }; // SignedKhalimskyPreCell
 
  template < Dimension dim,
             typename TInteger >
  std::ostream &
  operator<<( std::ostream & out,
              const SignedKhalimskyPreCell< dim, TInteger > & object );
 
  template < Dimension dim,
             typename TInteger = DGtal::int32_t >
  class PreCellDirectionIterator
  {
  public:
    typedef TInteger Integer;
    // Cells
    typedef KhalimskyPreCell< dim, Integer > Cell;
    typedef SignedKhalimskyPreCell< dim, Integer > SCell;
 
  public:
    explicit PreCellDirectionIterator( Cell cell, bool open = true );
 
    explicit PreCellDirectionIterator( SCell scell, bool open = true );
 
    Dimension operator*() const;
 
    PreCellDirectionIterator & operator++();
 
    bool operator!=( const Integer ) const;
 
    bool end() const;
 
    bool operator!=( const PreCellDirectionIterator & other ) const;
 
    bool operator==( const PreCellDirectionIterator & other ) const;
 
  private:
    Dimension myDir;
    Cell myCell;
    bool myOpen;
 
  private:
    void find();
  };
 
  // template class KhalimskyPreSpaceND
  template <
    Dimension dim,
    typename TInteger
  >
  class KhalimskyPreSpaceND
  {
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
 
  public:
    using Integer = TInteger;
 
    // Cells
    using Cell   = KhalimskyPreCell< dim, Integer >;
    using SCell  = SignedKhalimskyPreCell< dim, Integer >;
 
    using Surfel = SCell;
    using Sign = bool;
    using DirIterator = PreCellDirectionIterator< dim, Integer >;
 
    // Points and Vectors
    using Point   = PointVector< dim, Integer >;
    using Vector  = PointVector< dim, Integer >;
 
    using Space = SpaceND<dim, Integer>;
    using PreCellularGridSpace = KhalimskyPreSpaceND<dim, Integer>;
 
    // static constants
    static constexpr const Dimension dimension = dim;
    static constexpr const Dimension DIM = dim;
    static constexpr const Sign POS = true;
    static constexpr const Sign NEG = false;
 
    template <typename CellType>
    struct AnyCellCollection : public std::deque<CellType> {
      using Value         = CellType;
      using Container     = typename std::deque<CellType>;
      using Iterator      = typename std::deque<CellType>::iterator;
      using ConstIterator = typename std::deque<CellType>::const_iterator;
    };
 
    // Neighborhoods, Incident cells, Faces and Cofaces
    using Cells  = AnyCellCollection<Cell>;
    using SCells = AnyCellCollection<SCell>;
 
    // Sets, Maps
    using CellSet    = std::set<Cell>;
 
    using SCellSet   = std::set<SCell>;
 
    using SurfelSet  = std::set<SCell>;
 
    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;
    };
 
    // ----------------------- Pre-cell creation services --------------------------
  public:
 
    static Cell uCell( const Point & kp );
 
    static Cell uCell( Point p, const Cell & c );
 
    static SCell sCell( const Point & kp, Sign sign = POS );
 
    static SCell sCell( Point p, const SCell & c );
 
    static Cell uSpel( Point p );
 
    static SCell sSpel( Point p, Sign sign = POS );
 
    static Cell uPointel( Point p );
 
    static SCell sPointel( Point p, Sign sign = POS );
 
 
    // ----------------------- Read accessors to pre-cells ------------------------
  public:
    static Integer uKCoord( const Cell & c, Dimension k );
 
    static Integer uCoord( const Cell & c, Dimension k );
 
    static const Point & uKCoords( const Cell & c );
 
    static Point uCoords( const Cell & c );
 
    static Integer sKCoord( const SCell & c, Dimension k );
 
    static Integer sCoord( const SCell & c, Dimension k );
 
    static const Point & sKCoords( const SCell & c );
 
    static Point sCoords( const SCell & c );
 
    static Sign sSign( const SCell & c );
 
 
    // ----------------------- Write accessors to pre-cells ------------------------
  public:
 
    static void uSetKCoord( Cell & c, Dimension k, Integer i );
 
    static void sSetKCoord( SCell & c, Dimension k, Integer i );
 
    static void uSetCoord( Cell & c, Dimension k, Integer i );
 
    static void sSetCoord( SCell & c, Dimension k, Integer i );
 
    static void uSetKCoords( Cell & c, const Point & kp );
 
    static void sSetKCoords( SCell & c, const Point & kp );
 
    static void uSetCoords( Cell & c, const Point & kp );
 
    static void sSetCoords( SCell & c, const Point & kp );
 
    static void sSetSign( SCell & c, Sign s );
 
 
    // -------------------- Conversion signed/unsigned ------------------------
  public:
    static SCell signs( const Cell & p, Sign s );
 
    static Cell unsigns( const SCell & p );
 
    static SCell sOpp( const SCell & p );
 
 
    // ------------------------- Pre-cell topology services -----------------------
  public:
    static Integer uTopology( const Cell & p );
 
    static Integer sTopology( const SCell & p );
 
    static Dimension uDim( const Cell & p );
 
    static Dimension sDim( const SCell & p );
 
    static bool uIsSurfel( const Cell & b );
 
    static bool sIsSurfel( const SCell & b );
 
    static bool uIsOpen( const Cell & p, Dimension k );
 
    static bool sIsOpen( const SCell & p, Dimension k );
 
 
    // -------------------- Iterator services for pre-cells ------------------------
  public:
 
    static DirIterator uDirs( const Cell & p );
 
    static DirIterator sDirs( const SCell & p );
 
    static DirIterator uOrthDirs( const Cell & p );
 
    static DirIterator sOrthDirs( const SCell & p );
 
    static Dimension uOrthDir( const Cell & s );
 
    static Dimension sOrthDir( const SCell & s );
 
 
    // -------------------- Unsigned pre-cell geometry services --------------------
  public:
 
    static Cell uGetIncr( Cell p, Dimension k );
 
    static bool uIsMax( const Cell & p, Dimension k );
 
 
    static bool uIsInside( const Cell & p, Dimension k );
 
 
    static bool uIsInside( const Cell & p );
 
    static Cell uGetDecr( Cell p, Dimension k );
 
    static bool uIsMin( const Cell & p, Dimension k );
 
    static Cell uGetAdd( Cell p, Dimension k, Integer x );
 
    static Cell uGetSub( Cell p, Dimension k, Integer x );
 
    static Cell uTranslation( Cell p, const Vector & vec );
 
    static Cell uProjection( Cell p, const Cell & bound, Dimension k );
 
    static void uProject( Cell & p, const Cell & bound, Dimension k );
 
    static bool uNext( Cell & p, const Cell & lower, const Cell & upper );
 
 
    // -------------------- Signed pre-cell geometry services --------------------
  public:
 
    static SCell sGetIncr( SCell p, Dimension k );
 
    static bool sIsMax( const SCell & p, Dimension k );
 
 
    static bool sIsInside( const SCell & p, Dimension k );
 
 
    static bool sIsInside( const SCell & p );
 
    static SCell sGetDecr( SCell p, Dimension k );
 
    static bool sIsMin( const SCell & p, Dimension k );
 
    static SCell sGetAdd( SCell p, Dimension k, Integer x );
 
    static SCell sGetSub( SCell p, Dimension k, Integer x );
 
    static SCell sTranslation( SCell p, const Vector & vec );
 
    static SCell sProjection( SCell p, const SCell & bound, Dimension k );
 
    static void sProject( SCell & p, const SCell & bound, Dimension k );
 
    static bool sNext( SCell & p, const SCell & lower, const SCell & upper );
 
 
    // ----------------------- Neighborhood services --------------------------
  public:
 
    static Cells uNeighborhood( const Cell & cell );
 
    static SCells sNeighborhood( const SCell & cell );
 
    static Cells uProperNeighborhood( const Cell & cell );
 
    static SCells sProperNeighborhood( const SCell & cell );
 
    static Cell uAdjacent( const Cell & p, Dimension k, bool up );
 
    static SCell sAdjacent( const SCell & p, Dimension k, bool up );
 
 
    // ----------------------- Incidence services --------------------------
  public:
 
    static Cell uIncident( Cell c, Dimension k, bool up );
 
    static SCell sIncident( SCell c, Dimension k, bool up );
 
    static Cells uLowerIncident( const Cell & c );
 
    static Cells uUpperIncident( const Cell & c );
 
    static SCells sLowerIncident( const SCell & c );
 
    static SCells sUpperIncident( const SCell & c );
 
    static Cells uFaces( const Cell & c );
 
    static Cells uCoFaces( const Cell & c );
 
    static bool sDirect( const SCell & p, Dimension k );
 
    static SCell sDirectIncident( SCell p, Dimension k );
 
    static SCell sIndirectIncident( SCell p, Dimension k );
 
 
 
    // ------------------------- Internals ------------------------------------
  private:
    static void uAddFaces( Cells & faces, const Cell & c, Dimension axis );
 
    static void uAddCoFaces( Cells & cofaces, const Cell & c, Dimension axis );
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    static void selfDisplay ( std::ostream & out );
 
    static constexpr bool isValid();
 
 
  }; // end of class KhalimskyPreSpaceND
 
  template < Dimension dim,
             typename TInteger >
  std::ostream&
  operator<< ( std::ostream & out,
               const KhalimskyPreSpaceND<dim, TInteger > & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/topology/KhalimskyPreSpaceND.ih"
 
//                                                                           //
 
#endif // !defined KhalimskyPreSpaceND_h
 
#undef KhalimskyPreSpaceND_RECURSES
#endif // else defined(KhalimskyPreSpaceND_RECURSES)