DGtal  1.4.beta
CubicalComplex.h
1 
17 #pragma once
18 
31 #if defined(CubicalComplex_RECURSES)
32 #error Recursive header files inclusion detected in CubicalComplex.h
33 #else // defined(CubicalComplex_RECURSES)
35 #define CubicalComplex_RECURSES
36 
37 #if !defined CubicalComplex_h
39 #define CubicalComplex_h
40 
42 // Inclusions
43 #include <iostream>
44 #include <vector>
45 #include <string>
46 #include <algorithm>
47 #include <boost/type_traits.hpp>
48 #include <boost/iterator/iterator_facade.hpp>
49 #include "DGtal/base/Common.h"
50 #include "DGtal/base/ConstAlias.h"
51 #include "DGtal/base/Alias.h"
52 #include "DGtal/base/ContainerTraits.h"
53 #include "DGtal/base/CSTLAssociativeContainer.h"
54 #include "DGtal/topology/CCellularGridSpaceND.h"
56 
57 namespace DGtal
58 {
59 
76  struct CubicalCellData {
77  inline CubicalCellData() : data( 0 ) {}
78  CubicalCellData( uint32_t d ) : data( d ) {}
80  };
81 
82  // Forward definitions.
83  template < typename TKSpace, typename TCellContainer >
84  class CubicalComplex;
85 
86  template < typename TKSpace, typename TCellContainer >
90  template < typename TKSpace, typename TCellContainer >
94  template < typename TKSpace, typename TCellContainer >
98  template < typename TKSpace, typename TCellContainer >
102  template < typename TKSpace, typename TCellContainer >
106  template < typename TKSpace, typename TCellContainer >
110  template < typename TKSpace, typename TCellContainer >
114  template < typename TKSpace, typename TCellContainer >
118 
119  template < typename TKSpace, typename TCellContainer >
122  template < typename TKSpace, typename TCellContainer >
125 
126  template < typename TKSpace, typename TCellContainer >
127  bool
130  template < typename TKSpace, typename TCellContainer >
131  bool
134  template < typename TKSpace, typename TCellContainer >
135  bool
138  template < typename TKSpace, typename TCellContainer >
139  bool
142 
143 
145  // template class CubicalComplex
173  template < typename TKSpace,
174  typename TCellContainer = typename TKSpace::template CellMap< CubicalCellData >::Type >
176  {
177  // ----------------------- associated types ------------------------------
178  public:
180 
183 
184  // JOL: Not used, because unordered_set and unordered_map do not pass
185  // these concept checks.
186  // BOOST_CONCEPT_ASSERT(( boost::AssociativeContainer< TCellContainer > ));
187  // BOOST_CONCEPT_ASSERT(( boost::PairAssociativeContainer< TCellContainer > ));
189 
190  template < typename K, typename C >
191  friend CubicalComplex<K,C>&
193  template < typename K, typename C >
194  friend CubicalComplex<K,C>&
196  template < typename K, typename C >
197  friend CubicalComplex<K,C>&
199  template < typename K, typename C >
200  friend CubicalComplex<K,C>&
202  template < typename K, typename C >
203  friend CubicalComplex<K,C>
205  template < typename K, typename C >
206  friend CubicalComplex<K,C>
208  template < typename K, typename C >
209  friend CubicalComplex<K,C>
211  template < typename K, typename C >
212  friend CubicalComplex<K,C>
214  template < typename K, typename C >
215  friend CubicalComplex<K,C>
217  template < typename K, typename C >
218  friend CubicalComplex<K,C>
220  template < typename K, typename C >
221  friend bool
223  template < typename K, typename C >
224  friend bool
226  template < typename K, typename C >
227  friend bool
229  template < typename K, typename C >
230  friend bool
232 
233  typedef TKSpace KSpace;
234  typedef TCellContainer CellContainer;
235  typedef typename CellContainer::mapped_type Data;
236 
237  BOOST_STATIC_ASSERT (( boost::is_base_of< CubicalCellData, Data >::value ));
238  BOOST_STATIC_ASSERT (( boost::is_same< typename TKSpace::Cell, typename CellContainer::key_type >::value ));
239 
240 
242  static const Dimension dimension = KSpace::dimension;
243  typedef typename KSpace::Integer Integer;
244  typedef typename KSpace::Cell Cell;
245  typedef typename Cell::PreCell PreCell;
246  typedef typename KSpace::Cells Cells;
247  typedef typename KSpace::Space Space;
248  typedef typename KSpace::Size Size;
249  typedef typename KSpace::Point Point;
250  typedef typename KSpace::DirIterator DirIterator;
252  typedef typename CellMap::const_iterator CellMapConstIterator;
253  typedef typename CellMap::iterator CellMapIterator;
254 
255 
257  enum CellType {
260  Any
261  };
262 
264  BOOST_STATIC_CONSTANT( uint32_t, REMOVED = 0x10000000 );
266  BOOST_STATIC_CONSTANT( uint32_t, COLLAPSIBLE = 0x20000000 );
268  BOOST_STATIC_CONSTANT( uint32_t, FIXED = 0x40000000 );
270  BOOST_STATIC_CONSTANT( uint32_t, USER1 = 0x80000000 );
272  BOOST_STATIC_CONSTANT( uint32_t, VALUE = 0x0fffffff );
273 
274  // ----------------------- inner types ------------------------------------
275 
283 
293  bool operator()( const CellMapIterator& it1, const CellMapIterator& it2 ) const
294  {
295  uint32_t v1 = it1->second.data & VALUE;
296  uint32_t v2 = it2->second.data & VALUE;
297  return ( v1 < v2 )
298  || ( ( v1 == v2 ) && ( it1->first < it2->first ) );
299  }
300  };
301 
307  : public boost::iterator_facade< ConstIterator, Cell const,
308  std::forward_iterator_tag >
309  {
310  friend class CubicalComplex;
311 
312  typedef boost::iterator_facade< ConstIterator, Cell const,
313  std::forward_iterator_tag > Base;
315  typedef typename Base::value_type Value;
316  typedef typename Base::pointer Pointer;
317  typedef typename Base::reference Reference;
318  typedef typename Base::difference_type DifferenceType;
319 
321  ConstIterator() : myCC( 0 ), myD( 0 ) {}
322 
332  : myCC( &cc ), myD( d )
333  {
334  if ( myD <= myCC->dimension )
335  {
336  myIt = myCC->begin( myD );
337  myItEnd = myCC->end( myD );
338  nextDimension();
339  }
340  else
341  {
342  myD = myCC->dimension + 1;
343  myIt = myCC->end( myCC->dimension );
344  myItEnd = myCC->end( myCC->dimension );
345  }
346  }
347 
357  : myCC( &cc ), myD( d ), myIt( it )
358  {
359  ASSERT( d <= myCC->dimension );
360  myItEnd = myCC->end( d );
361  nextDimension();
362  }
363 
364  private:
366 
368  {
369  while ( myIt == myItEnd )
370  {
371  if ( ++myD > myCC->dimension ) break;
372  myIt = myCC->begin( myD );
373  myItEnd = myCC->end( myD );
374  }
375  }
376 
377  void increment()
378  {
379  ASSERT( myCC != 0 );
380  ++myIt;
381  nextDimension();
382  }
383 
384  bool equal( const ConstIterator& other ) const
385  {
386  return ( myD == other.myD ) && ( myIt == other.myIt );
387  }
388 
389  Cell const& dereference() const
390  {
391  return myIt->first;
392  }
393 
395  {
396  return myD;
397  }
398 
399  private:
404  };
405 
411  struct Iterator
412  : public boost::iterator_facade< Iterator, Cell const,
413  std::forward_iterator_tag >
414  {
415  friend class CubicalComplex;
416 
417  typedef boost::iterator_facade< Iterator, Cell const,
418  std::forward_iterator_tag > Base;
419  typedef Iterator Self;
420  typedef typename Base::value_type Value;
421  typedef typename Base::pointer Pointer;
422  typedef typename Base::reference Reference;
423  typedef typename Base::difference_type DifferenceType;
424 
426  Iterator() : myCC( 0 ), myD( 0 ) {}
427 
436  : myCC( &cc ), myD( d )
437  {
438  if ( myD <= myCC->dimension )
439  {
440  myIt = myCC->begin( myD );
441  myItEnd = myCC->end( myD );
442  nextDimension();
443  }
444  else
445  {
446  myD = myCC->dimension + 1;
447  myIt = myCC->end( myCC->dimension );
448  myItEnd = myCC->end( myCC->dimension );
449  }
450  }
451 
460  CellMapIterator it )
461  : myCC( &cc ), myD( d ), myIt( it )
462  {
463  ASSERT( d <= myCC->dimension );
464  myItEnd = myCC->end( d );
465  nextDimension();
466  }
467 
468  private:
470 
472  {
473  while ( myIt == myItEnd )
474  {
475  if ( ++myD > myCC->dimension ) break;
476  myIt = myCC->begin( myD );
477  myItEnd = myCC->end( myD );
478  }
479  }
480 
481  void increment()
482  {
483  ASSERT( myCC != 0 );
484  ++myIt;
485  nextDimension();
486  }
487 
488  bool equal( const Iterator& other ) const
489  {
490  return ( myD == other.myD ) && ( myIt == other.myIt );
491  }
492 
493  Cell const& dereference() const
494  {
495  return myIt->first;
496  }
497 
499  {
500  return myD;
501  }
502 
503  private:
508  };
509 
510  // ----------------------- STL inner types ------------------------------
511  public:
512 
513  // Renaming for STL-type of iterator.
516  typedef Cell value_type;
517  typedef Cell const& reference;
518  typedef Cell const& const_reference;
519  typedef typename CellContainer::size_type size_type;
520  typedef typename CellContainer::difference_type difference_type;
521  typedef Cell const* pointer;
522  typedef Cell const* const_pointer;
523 
524  // ----------------------- Standard services ------------------------------
525  public:
526 
531 
532  protected:
539  public:
540 
548 
553  CubicalComplex ( const CubicalComplex & other );
554 
561  template < typename TDigitalSet >
562  void construct ( const TDigitalSet & set );
563 
570 
574  void clear();
575 
580  void clear( Dimension d );
581 
588  void fillData( Data data = Data() );
589 
598  void fillData( Dimension d, Data data = Data() );
599 
604  Dimension dim() const;
605 
610  Dimension dim( const Cell& aCell ) const;
611 
616  Size nbCells( Dimension d ) const;
617 
625  Integer euler() const;
626 
630  const KSpace& space() const;
631 
632  // ---------- cell container operations ---------------
633  public:
634 
640  const CellMap & getCells(const Dimension d) const ;
641 
648 
652 
656 
660 
664 
669  Size count( const Cell& aCell ) const;
670 
672  Size size() const;
673 
676  Size max_size() const;
677 
679  bool empty() const;
680 
691  std::pair< ConstIterator, ConstIterator > equal_range( const Cell& aCell ) const;
692 
703  std::pair< Iterator, Iterator > equal_range( const Cell& aCell );
704 
709  void erase( Iterator position );
710 
716  Size erase( const Cell& aCell );
717 
723  void erase( Iterator first, Iterator last );
724 
729  ConstIterator find( const Cell& aCell ) const;
730 
735  Iterator find( const Cell& aCell );
736 
746  std::pair< Iterator, bool > insert( const Cell& aCell );
747 
755  Iterator insert( Iterator position, const Cell& aCell );
756 
764  template <class InputIterator>
765  void insert( InputIterator first, InputIterator last );
766 
774  void swap( CubicalComplex& other );
775 
776  // ---------- enhanced container operations ---------------
777  public:
778 
786  Data& operator[]( const Cell& aCell );
787 
795  bool operator()( const Cell& aCell ) const;
796 
803  void insertCell( const Cell& aCell, const Data& data = Data() );
804 
813  void insertCell( Dimension d, const Cell& aCell, const Data& data = Data() );
814 
825  template <typename CellConstIterator>
826  void insertCells( CellConstIterator it, CellConstIterator itE, const Data& data = Data() );
827 
839  template <typename CellConstIterator>
840  void insertCells( Dimension d, CellConstIterator it, CellConstIterator itE, const Data& data = Data() );
841 
846  bool belongs( const Cell& aCell ) const;
851  bool belongs( const PreCell& aCell ) const;
852 
858  bool belongs( Dimension d, const Cell& aCell ) const;
864  bool belongs( Dimension d, const PreCell& aCell ) const;
865 
871  Size eraseCell( const Cell& aCell );
872 
879  Size eraseCell( Dimension d, const Cell& aCell );
880 
886 
893 
903  template <typename CellConstIterator>
904  Size eraseCells( CellConstIterator it, CellConstIterator itE );
905 
916  template <typename CellConstIterator>
917  Size eraseCells( Dimension d, CellConstIterator it, CellConstIterator itE );
918 
933  template <typename CellOutputIterator>
934  void faces( CellOutputIterator& outIt, const Cell& aCell,
935  bool hintClosed = false ) const;
936 
953  template <typename CellOutputIterator>
954  void directFaces( CellOutputIterator& outIt, const Cell& aCell,
955  bool hintClosed = false ) const;
956 
970  template <typename CellMapIteratorOutputIterator>
971  void directFacesIterators( CellMapIteratorOutputIterator& outIt, const Cell& aCell );
972 
988  template <typename CellOutputIterator>
989  void coFaces( CellOutputIterator& outIt, const Cell& aCell,
990  bool hintOpen = false ) const;
991 
1008  template <typename CellOutputIterator>
1009  void directCoFaces( CellOutputIterator& outIt, const Cell& aCell,
1010  bool hintOpen = false ) const;
1011 
1025  template <typename CellMapIteratorOutputIterator>
1026  void directCoFacesIterators( CellMapIteratorOutputIterator& outIt, const Cell& aCell );
1027 
1033 
1039 
1045 
1051 
1056  CellMapConstIterator findCell( const Cell& aCell ) const;
1057 
1063  CellMapConstIterator findCell( Dimension d, const Cell& aCell ) const;
1064 
1069  CellMapIterator findCell( const Cell& aCell );
1070 
1077 
1078  // ---------- local operations for extracting specific subcomplexes -------------
1079  public:
1080 
1098  Cells cellBoundary( const Cell& aCell, bool hintClosed = false ) const;
1099 
1116  Cells cellCoBoundary( const Cell& aCell, bool hintOpen = false ) const;
1117 
1118 
1119  // ---------------------- local properties --------------------------------------
1120  public:
1128  bool isCellInterior( const Cell& aCell ) const;
1129 
1137  bool isCellBoundary( const Cell& aCell ) const;
1138 
1163  Dimension n = dimension );
1164 
1165 
1166  // ----------------------- Standard subcomplexes --------------------------------
1167  public:
1168 
1174 
1186  CubicalComplex boundary( bool hintClosed = false ) const;
1187 
1201  CubicalComplex& bdcc,
1202  bool hintClosed = false ) const;
1203 
1214  CubicalComplex closure( const CubicalComplex& S, bool hintClosed = false ) const;
1215 
1226  CubicalComplex star( const CubicalComplex& S, bool hintOpen = false ) const;
1227 
1242  CubicalComplex link( const CubicalComplex& S, bool hintClosed = false, bool hintOpen = false ) const;
1243 
1244  // ----------------------- global operations on complexes -----------------------
1245  public:
1246 
1250  void close();
1251 
1256  void close( Dimension k );
1257 
1261  void open();
1262 
1267  void open( Dimension k );
1268 
1269 
1270  // ----------------------- Interface --------------------------------------
1271  public:
1272 
1277  void selfDisplay ( std::ostream & out ) const;
1278 
1283  bool isValid() const;
1284 
1285  // --------------- CDrawableWithBoard2D realization ------------------
1286  public:
1290  std::string className() const;
1291 
1292  // ------------------------- Protected Datas ------------------------------
1293  protected:
1294 
1297 
1301  std::vector<CellMap> myCells;
1302 
1303 
1304  // ------------------------- Hidden services ------------------------------
1305  protected:
1306 
1307 
1308  private:
1309 
1310 
1311  // ------------------------- Internals ------------------------------------
1312  private:
1313 
1314 
1315  }; // end of class CubicalComplex
1316 
1322  template < typename TKSpace,
1323  typename TCellContainer >
1324  struct ContainerTraits< CubicalComplex< TKSpace, TCellContainer > >
1325  {
1326  //typedef typename ContainerTraits< TCellContainer >::Category Category;
1328  };
1329 
1330 
1337  template <typename TKSpace, typename TCellContainer>
1338  std::ostream&
1339  operator<< ( std::ostream & out,
1340  const CubicalComplex<TKSpace, TCellContainer> & object );
1341 
1342 } // namespace DGtal
1343 
1344 
1346 // Includes inline functions.
1347 #include "DGtal/topology/CubicalComplex.ih"
1348 
1349 // //
1351 
1352 #endif // !defined CubicalComplex_h
1353 
1354 #undef CubicalComplex_RECURSES
1355 #endif // else defined(CubicalComplex_RECURSES)
Aim: This class encapsulates its parameter class so that to indicate to the user that the object/poin...
Definition: Alias.h:183
Aim: This class encapsulates its parameter class so that to indicate to the user that the object/poin...
Definition: ConstAlias.h:187
Aim: This class represents an arbitrary cubical complex living in some Khalimsky space....
CellMapConstIterator findCell(const Cell &aCell) const
Cell const * const_pointer
void open(Dimension k)
CellMap & getCells(const Dimension d)
ConstIterator find(const Cell &aCell) const
KSpace::Integer Integer
Type for integers in the space.
Iterator insert(Iterator position, const Cell &aCell)
Cell::PreCell PreCell
Type for a precell in the space.
CubicalComplex closure(const CubicalComplex &S, bool hintClosed=false) const
CellMapIterator findCell(const Cell &aCell)
Dimension dim() const
bool isCellBoundary(const Cell &aCell) const
Cells cellCoBoundary(const Cell &aCell, bool hintOpen=false) const
TCellContainer CellContainer
Type for storing cells, an associative container Cell -> Data.
void directCoFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintOpen=false) const
bool isCellInterior(const Cell &aCell) const
BOOST_STATIC_CONSTANT(uint32_t, COLLAPSIBLE=0x20000000)
Flag Used to indicate in a cell data that this cell is collapsible.
ConstIterator end() const
void construct(const TDigitalSet &set)
BOOST_STATIC_ASSERT((boost::is_same< typename TKSpace::Cell, typename CellContainer::key_type >::value))
CubicalComplex & operator=(const CubicalComplex &other)
TKSpace KSpace
Type of the cellular grid space.
Size eraseCell(const Cell &aCell)
BOOST_STATIC_CONSTANT(uint32_t, VALUE=0x0fffffff)
Value for a cell.
Size eraseCells(Dimension d, CellConstIterator it, CellConstIterator itE)
BOOST_CONCEPT_ASSERT((concepts::CCellularGridSpaceND< TKSpace >))
const KSpace & space() const
bool belongs(Dimension d, const PreCell &aCell) const
KSpace::Space Space
Type of the digital space.
CellType computeCellType(const Cell &c, CellMapIterator &it_cell_up, Dimension n=dimension)
const KSpace * myKSpace
The Khalimsky space in which lives the cubical complex.
Size max_size() const
CellContainer::size_type size_type
KSpace::Cell Cell
Type for a cell in the space.
CellMapIterator begin(Dimension d)
std::string className() const
std::pair< Iterator, Iterator > equal_range(const Cell &aCell)
void getInteriorAndBoundary(CubicalComplex &intcc, CubicalComplex &bdcc, bool hintClosed=false) const
void insertCell(Dimension d, const Cell &aCell, const Data &data=Data())
void insertCells(CellConstIterator it, CellConstIterator itE, const Data &data=Data())
CubicalComplex< TKSpace, TCellContainer > Self
Cell const & const_reference
BOOST_CONCEPT_ASSERT((concepts::CSTLAssociativeContainer< TCellContainer >))
Cells cellBoundary(const Cell &aCell, bool hintClosed=false) const
BOOST_STATIC_ASSERT(IsPairAssociativeContainer< TCellContainer >::value)
CellMapConstIterator begin(Dimension d) const
void close(Dimension k)
ConstIterator const_iterator
BOOST_STATIC_CONSTANT(uint32_t, REMOVED=0x10000000)
Flag Used to indicate in a cell data that this cell has been (virtually) removed.
bool belongs(const PreCell &aCell) const
void eraseCells(CellMapIterator it, CellMapIterator itE)
CellMapConstIterator end(Dimension d) const
KSpace::Size Size
Type for a number of elements.
CubicalComplex boundary(bool hintClosed=false) const
CubicalComplex link(const CubicalComplex &S, bool hintClosed=false, bool hintOpen=false) const
CubicalComplex star(const CubicalComplex &S, bool hintOpen=false) const
void directFacesIterators(CellMapIteratorOutputIterator &outIt, const Cell &aCell)
std::vector< CellMap > myCells
KSpace::Point Point
Type for a point in the digital space.
BOOST_STATIC_ASSERT((boost::is_base_of< CubicalCellData, Data >::value))
void erase(Iterator position)
Size erase(const Cell &aCell)
CellMapIterator end(Dimension d)
void swap(CubicalComplex &other)
void directFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintClosed=false) const
void coFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintOpen=false) const
Size nbCells(Dimension d) const
CubicalComplex interior() const
Size count(const Cell &aCell) const
CellContainer::difference_type difference_type
void insertCells(Dimension d, CellConstIterator it, CellConstIterator itE, const Data &data=Data())
void insert(InputIterator first, InputIterator last)
KSpace::Cells Cells
Type for a sequence of cells in the space.
bool operator()(const Cell &aCell) const
KSpace::DirIterator DirIterator
Type for iterating over cell directions.
Size eraseCells(CellConstIterator it, CellConstIterator itE)
BOOST_STATIC_CONSTANT(uint32_t, FIXED=0x40000000)
Flag Used to indicate in a cell data that this cell is fixed.
bool belongs(const Cell &aCell) const
CellMapConstIterator findCell(Dimension d, const Cell &aCell) const
Dimension dim(const Cell &aCell) const
void selfDisplay(std::ostream &out) const
void insertCell(const Cell &aCell, const Data &data=Data())
CellMap::iterator CellMapIterator
Iterator for visiting type CellMap.
void erase(Iterator first, Iterator last)
void fillData(Data data=Data())
Data & operator[](const Cell &aCell)
const CellMap & getCells(const Dimension d) const
void eraseCell(CellMapIterator it)
static const Dimension dimension
The dimension of the embedding space.
void fillData(Dimension d, Data data=Data())
void clear(Dimension d)
CellContainer::mapped_type Data
Type of data associated to each cell.
CellType
Possible cell types within a complex.
ConstIterator begin() const
CubicalComplex(ConstAlias< KSpace > aK)
CellContainer CellMap
Type for storing cells, an associative container Cell -> Data.
void directCoFacesIterators(CellMapIteratorOutputIterator &outIt, const Cell &aCell)
std::pair< Iterator, bool > insert(const Cell &aCell)
std::pair< ConstIterator, ConstIterator > equal_range(const Cell &aCell) const
CellMap::const_iterator CellMapConstIterator
Const iterator for visiting type CellMap.
CubicalComplex(const CubicalComplex &other)
BOOST_STATIC_CONSTANT(uint32_t, USER1=0x80000000)
User flag for a cell.
bool isValid() const
Size eraseCell(Dimension d, const Cell &aCell)
CellMapIterator findCell(Dimension d, const Cell &aCell)
Integer euler() const
bool belongs(Dimension d, const Cell &aCell) const
Iterator find(const Cell &aCell)
void faces(CellOutputIterator &outIt, const Cell &aCell, bool hintClosed=false) const
TInteger Integer
Arithmetic ring induced by (+,-,*) and Integer numbers.
NumberTraits< Integer >::UnsignedVersion Size
Type used to represent sizes in the digital space.
typename PreCellularGridSpace::DirIterator DirIterator
AnyCellCollection< Cell > Cells
DGtal is the top-level namespace which contains all DGtal functions and types.
bool operator>=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Comparison operator on Points/Vectors (GreaterOrEqualThan).
CubicalComplex< TKSpace, TCellContainer > & operator^=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
bool operator==(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Equality operator between two Points/Vectors.
boost::uint32_t uint32_t
unsigned 32-bit integer.
Definition: BasicTypes.h:63
CubicalComplex< TKSpace, TCellContainer > & operator&=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
bool operator!=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Difference operator on Points/Vectors.
std::ostream & operator<<(std::ostream &out, const ATu0v1< TKSpace, TLinearAlgebra > &object)
CubicalComplex< TKSpace, TCellContainer > operator~(const CubicalComplex< TKSpace, TCellContainer > &)
bool operator<=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Comparison operator on Points/Vectors (LesserOrEqualThan).
DGtal::uint32_t Dimension
Definition: Common.h:137
CubicalComplex< TKSpace, TCellContainer > operator^(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
KForm< Calculus, order, duality > operator*(const typename Calculus::Scalar &scalar, const KForm< Calculus, order, duality > &form)
CubicalComplex< TKSpace, TCellContainer > & operator|=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
KForm< Calculus, order, duality > operator-(const KForm< Calculus, order, duality > &form_a, const KForm< Calculus, order, duality > &form_b)
CubicalComplex< TKSpace, TCellContainer > operator&(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
CubicalComplex< TKSpace, TCellContainer > operator|(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
CubicalComplex< TKSpace, TCellContainer > & operator-=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Defines default container traits for arbitrary types.
CubicalCellData(uint32_t d)
boost::iterator_facade< ConstIterator, Cell const, std::forward_iterator_tag > Base
friend class boost::iterator_core_access
ConstIterator()
Default iterator. Invalid.
Base::difference_type DifferenceType
bool equal(const ConstIterator &other) const
ConstIterator(ConstAlias< CubicalComplex > cc, Dimension d, CellMapConstIterator it)
ConstIterator(ConstAlias< CubicalComplex > cc, Dimension d)
bool operator()(const CellMapIterator &it1, const CellMapIterator &it2) const
Cell const & dereference() const
Iterator(Alias< CubicalComplex > cc, Dimension d, CellMapIterator it)
bool equal(const Iterator &other) const
boost::iterator_facade< Iterator, Cell const, std::forward_iterator_tag > Base
Iterator(Alias< CubicalComplex > cc, Dimension d)
Iterator()
Default iterator. Invalid.
friend class boost::iterator_core_access
Base::difference_type DifferenceType
Aim: This concept describes a cellular grid space in nD. In these spaces obtained by cartesian produc...
Aim: Defines the concept describing an Associative Container of the STL (https://www....