DGtal 1.3.0
Loading...
Searching...
No Matches
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
57namespace DGtal
58{
59
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 >
205 template < typename K, typename C >
208 template < typename K, typename C >
211 template < typename K, typename C >
214 template < typename K, typename C >
217 template < typename K, typename 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
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;
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 );
339 }
340 else
341 {
342 myD = myCC->dimension + 1;
343 myIt = 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 );
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
378 {
379 ASSERT( myCC != 0 );
380 ++myIt;
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 );
443 }
444 else
445 {
446 myD = myCC->dimension + 1;
447 myIt = 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 );
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
482 {
483 ASSERT( myCC != 0 );
484 ++myIt;
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.
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
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
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
1064
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,
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)
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
const KSpace & space() 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))
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 >))
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
CellMap & getCells(const Dimension d)
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.
Data & operator[](const Cell &aCell)
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
const CellMap & getCells(const Dimension d) 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())
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.
CubicalComplex & operator=(const CubicalComplex &other)
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.
PointVector< dim, Integer > Point
NumberTraits< Integer >::UnsignedVersion Size
Type used to represent sizes in the digital space.
static const constexpr Dimension dimension
typename PreCellularGridSpace::DirIterator DirIterator
KhalimskyCell< dim, Integer > Cell
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).
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 > &)
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.
CubicalComplex< TKSpace, TCellContainer > operator~(const CubicalComplex< TKSpace, TCellContainer > &)
std::ostream & operator<<(std::ostream &out, const ClosedIntegerHalfPlane< TSpace > &object)
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 > &)
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
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
Cell const & dereference() const
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....