DGtal 1.4.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
76 struct CubicalCellData {
77 inline CubicalCellData() : data( 0 ) {}
78 CubicalCellData( uint32_t d ) : data( d ) {}
79 uint32_t data;
80 };
81
82 // Forward definitions.
83 template < typename TKSpace, typename TCellContainer >
84 class CubicalComplex;
85
86 template < typename TKSpace, typename TCellContainer >
87 CubicalComplex< TKSpace, TCellContainer >&
88 operator|=( CubicalComplex< TKSpace, TCellContainer >&,
89 const CubicalComplex< TKSpace, TCellContainer >& );
90 template < typename TKSpace, typename TCellContainer >
91 CubicalComplex< TKSpace, TCellContainer >&
92 operator&=( CubicalComplex< TKSpace, TCellContainer >&,
93 const CubicalComplex< TKSpace, TCellContainer >& );
94 template < typename TKSpace, typename TCellContainer >
95 CubicalComplex< TKSpace, TCellContainer >&
96 operator^=( CubicalComplex< TKSpace, TCellContainer >&,
97 const CubicalComplex< TKSpace, TCellContainer >& );
98 template < typename TKSpace, typename TCellContainer >
99 CubicalComplex< TKSpace, TCellContainer >&
100 operator-=( CubicalComplex< TKSpace, TCellContainer >&,
101 const CubicalComplex< TKSpace, TCellContainer >& );
102 template < typename TKSpace, typename TCellContainer >
103 CubicalComplex< TKSpace, TCellContainer >
104 operator| ( const CubicalComplex< TKSpace, TCellContainer >&,
105 const CubicalComplex< TKSpace, TCellContainer >& );
106 template < typename TKSpace, typename TCellContainer >
107 CubicalComplex< TKSpace, TCellContainer >
108 operator& ( const CubicalComplex< TKSpace, TCellContainer >&,
109 const CubicalComplex< TKSpace, TCellContainer >& );
110 template < typename TKSpace, typename TCellContainer >
111 CubicalComplex< TKSpace, TCellContainer >
112 operator^ ( const CubicalComplex< TKSpace, TCellContainer >&,
113 const CubicalComplex< TKSpace, TCellContainer >& );
114 template < typename TKSpace, typename TCellContainer >
115 CubicalComplex< TKSpace, TCellContainer >
116 operator- ( const CubicalComplex< TKSpace, TCellContainer >&,
117 const CubicalComplex< TKSpace, TCellContainer >& );
118
119 template < typename TKSpace, typename TCellContainer >
120 CubicalComplex< TKSpace, TCellContainer >
121 operator~ ( const CubicalComplex< TKSpace, TCellContainer >& );
122 template < typename TKSpace, typename TCellContainer >
123 CubicalComplex< TKSpace, TCellContainer >
124 operator* ( const CubicalComplex< TKSpace, TCellContainer >& );
125
126 template < typename TKSpace, typename TCellContainer >
127 bool
128 operator==( const CubicalComplex< TKSpace, TCellContainer >&,
129 const CubicalComplex< TKSpace, TCellContainer >& );
130 template < typename TKSpace, typename TCellContainer >
131 bool
132 operator!=( const CubicalComplex< TKSpace, TCellContainer >&,
133 const CubicalComplex< TKSpace, TCellContainer >& );
134 template < typename TKSpace, typename TCellContainer >
135 bool
136 operator<=( const CubicalComplex< TKSpace, TCellContainer >&,
137 const CubicalComplex< TKSpace, TCellContainer >& );
138 template < typename TKSpace, typename TCellContainer >
139 bool
140 operator>=( const CubicalComplex< TKSpace, TCellContainer >&,
141 const CubicalComplex< TKSpace, TCellContainer >& );
142
143
145 // template class CubicalComplex
173 template < typename TKSpace,
174 typename TCellContainer = typename TKSpace::template CellMap< CubicalCellData >::Type >
175 class CubicalComplex
176 {
177 // ----------------------- associated types ------------------------------
178 public:
179 typedef CubicalComplex< TKSpace, TCellContainer > Self;
180
181 BOOST_CONCEPT_ASSERT(( concepts::CCellularGridSpaceND< TKSpace > ));
182 BOOST_STATIC_ASSERT( IsPairAssociativeContainer< TCellContainer >::value );
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 > ));
188 BOOST_CONCEPT_ASSERT(( concepts::CSTLAssociativeContainer< TCellContainer > ));
189
190 template < typename K, typename C >
191 friend CubicalComplex<K,C>&
192 DGtal::operator|=( CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
193 template < typename K, typename C >
194 friend CubicalComplex<K,C>&
195 DGtal::operator&=( CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
196 template < typename K, typename C >
197 friend CubicalComplex<K,C>&
198 DGtal::operator^=( CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
199 template < typename K, typename C >
200 friend CubicalComplex<K,C>&
201 DGtal::operator-=( CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
202 template < typename K, typename C >
203 friend CubicalComplex<K,C>
204 DGtal::operator| ( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
205 template < typename K, typename C >
206 friend CubicalComplex<K,C>
207 DGtal::operator& ( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
208 template < typename K, typename C >
209 friend CubicalComplex<K,C>
210 DGtal::operator^ ( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
211 template < typename K, typename C >
212 friend CubicalComplex<K,C>
213 DGtal::operator- ( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
214 template < typename K, typename C >
215 friend CubicalComplex<K,C>
216 DGtal::operator~ ( const CubicalComplex<K,C>& );
217 template < typename K, typename C >
218 friend CubicalComplex<K,C>
219 DGtal::operator* ( const CubicalComplex<K,C>& );
220 template < typename K, typename C >
221 friend bool
222 DGtal::operator==( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
223 template < typename K, typename C >
224 friend bool
225 DGtal::operator!=( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
226 template < typename K, typename C >
227 friend bool
228 DGtal::operator<=( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
229 template < typename K, typename C >
230 friend bool
231 DGtal::operator>=( const CubicalComplex<K,C>&, const CubicalComplex<K,C>& );
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;
251 typedef CellContainer CellMap;
252 typedef typename CellMap::const_iterator CellMapConstIterator;
253 typedef typename CellMap::iterator CellMapIterator;
254
255
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
282 struct DefaultCellMapIteratorPriority {
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
306 struct ConstIterator
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;
314 typedef ConstIterator Self;
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
331 ConstIterator( ConstAlias<CubicalComplex> cc, Dimension d )
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
355 ConstIterator( ConstAlias<CubicalComplex> cc, Dimension d,
356 CellMapConstIterator it )
357 : myCC( &cc ), myD( d ), myIt( it )
358 {
359 ASSERT( d <= myCC->dimension );
360 myItEnd = myCC->end( d );
361 nextDimension();
362 }
363
364 private:
365 friend class boost::iterator_core_access;
366
367 void nextDimension()
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
394 Dimension dimension() const
395 {
396 return myD;
397 }
398
399 private:
400 const CubicalComplex* myCC;
401 Dimension myD;
402 CellMapConstIterator myIt;
403 CellMapConstIterator myItEnd;
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
435 Iterator( Alias<CubicalComplex> cc, Dimension d )
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
459 Iterator( Alias<CubicalComplex> cc, Dimension d,
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:
469 friend class boost::iterator_core_access;
470
471 void nextDimension()
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
498 Dimension dimension() const
499 {
500 return myD;
501 }
502
503 private:
504 CubicalComplex* myCC;
505 Dimension myD;
506 CellMapIterator myIt;
507 CellMapIterator myItEnd;
508 };
509
510 // ----------------------- STL inner types ------------------------------
511 public:
512
513 // Renaming for STL-type of iterator.
514 typedef ConstIterator const_iterator;
515 typedef Iterator 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
530 ~CubicalComplex();
531
532 protected:
538 CubicalComplex();
539 public:
540
547 CubicalComplex ( ConstAlias<KSpace> aK );
548
553 CubicalComplex ( const CubicalComplex & other );
554
561 template < typename TDigitalSet >
562 void construct ( const TDigitalSet & set );
563
569 CubicalComplex & operator= ( const CubicalComplex & other );
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
647 CellMap & getCells(const Dimension d) ;
648
651 ConstIterator begin() const;
652
655 ConstIterator end() const;
656
659 Iterator begin();
660
663 Iterator end();
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
885 void eraseCell( CellMapIterator it );
886
892 void eraseCells( CellMapIterator it, CellMapIterator itE );
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
1032 CellMapConstIterator begin( Dimension d ) const;
1033
1038 CellMapConstIterator end( Dimension d ) const;
1039
1044 CellMapIterator begin( Dimension d );
1045
1050 CellMapIterator end( Dimension d );
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
1076 CellMapIterator findCell( Dimension d, const Cell& aCell );
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
1162 CellType computeCellType( const Cell& c, CellMapIterator& it_cell_up,
1163 Dimension n = dimension );
1164
1165
1166 // ----------------------- Standard subcomplexes --------------------------------
1167 public:
1168
1173 CubicalComplex interior() const;
1174
1186 CubicalComplex boundary( bool hintClosed = false ) const;
1187
1200 void getInteriorAndBoundary( CubicalComplex& intcc,
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
1296 const KSpace* myKSpace;
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;
1327 typedef SequenceCategory 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)
DGtal::Alias
Aim: This class encapsulates its parameter class so that to indicate to the user that the object/poin...
Definition Alias.h:183
DGtal::ConstAlias
Aim: This class encapsulates its parameter class so that to indicate to the user that the object/poin...
Definition ConstAlias.h:187
DGtal::CubicalComplex
Aim: This class represents an arbitrary cubical complex living in some Khalimsky space....
Definition CubicalComplex.h:176
DGtal::CubicalComplex::findCell
CellMapConstIterator findCell(const Cell &aCell) const
DGtal::CubicalComplex::open
void open(Dimension k)
DGtal::CubicalComplex::find
ConstIterator find(const Cell &aCell) const
DGtal::CubicalComplex::Integer
KSpace::Integer Integer
Type for integers in the space.
Definition CubicalComplex.h:243
DGtal::CubicalComplex::insert
Iterator insert(Iterator position, const Cell &aCell)
DGtal::CubicalComplex::PreCell
Cell::PreCell PreCell
Type for a precell in the space.
Definition CubicalComplex.h:245
DGtal::CubicalComplex::closure
CubicalComplex closure(const CubicalComplex &S, bool hintClosed=false) const
DGtal::CubicalComplex::findCell
CellMapIterator findCell(const Cell &aCell)
DGtal::CubicalComplex::dim
Dimension dim() const
DGtal::CubicalComplex::space
const KSpace & space() const
DGtal::CubicalComplex::isCellBoundary
bool isCellBoundary(const Cell &aCell) const
DGtal::CubicalComplex::cellCoBoundary
Cells cellCoBoundary(const Cell &aCell, bool hintOpen=false) const
DGtal::CubicalComplex::CellContainer
TCellContainer CellContainer
Type for storing cells, an associative container Cell -> Data.
Definition CubicalComplex.h:234
DGtal::CubicalComplex::directCoFaces
void directCoFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintOpen=false) const
DGtal::CubicalComplex::isCellInterior
bool isCellInterior(const Cell &aCell) const
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, COLLAPSIBLE=0x20000000)
Flag Used to indicate in a cell data that this cell is collapsible.
DGtal::CubicalComplex::end
ConstIterator end() const
DGtal::CubicalComplex::construct
void construct(const TDigitalSet &set)
DGtal::CubicalComplex::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((boost::is_same< typename TKSpace::Cell, typename CellContainer::key_type >::value))
DGtal::CubicalComplex::KSpace
TKSpace KSpace
Type of the cellular grid space.
Definition CubicalComplex.h:233
DGtal::CubicalComplex::eraseCell
Size eraseCell(const Cell &aCell)
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, VALUE=0x0fffffff)
Value for a cell.
DGtal::CubicalComplex::eraseCells
Size eraseCells(Dimension d, CellConstIterator it, CellConstIterator itE)
DGtal::CubicalComplex::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CCellularGridSpaceND< TKSpace >))
DGtal::CubicalComplex::belongs
bool belongs(Dimension d, const PreCell &aCell) const
DGtal::CubicalComplex::Space
KSpace::Space Space
Type of the digital space.
Definition CubicalComplex.h:247
DGtal::CubicalComplex::computeCellType
CellType computeCellType(const Cell &c, CellMapIterator &it_cell_up, Dimension n=dimension)
DGtal::CubicalComplex::myKSpace
const KSpace * myKSpace
The Khalimsky space in which lives the cubical complex.
Definition CubicalComplex.h:1296
DGtal::CubicalComplex::max_size
Size max_size() const
DGtal::CubicalComplex::size_type
CellContainer::size_type size_type
Definition CubicalComplex.h:519
DGtal::CubicalComplex::Cell
KSpace::Cell Cell
Type for a cell in the space.
Definition CubicalComplex.h:244
DGtal::CubicalComplex::begin
CellMapIterator begin(Dimension d)
DGtal::CubicalComplex::className
std::string className() const
DGtal::CubicalComplex::equal_range
std::pair< Iterator, Iterator > equal_range(const Cell &aCell)
DGtal::CubicalComplex::getInteriorAndBoundary
void getInteriorAndBoundary(CubicalComplex &intcc, CubicalComplex &bdcc, bool hintClosed=false) const
DGtal::CubicalComplex::getCells
CellMap & getCells(const Dimension d)
DGtal::CubicalComplex::insertCell
void insertCell(Dimension d, const Cell &aCell, const Data &data=Data())
DGtal::CubicalComplex::insertCells
void insertCells(CellConstIterator it, CellConstIterator itE, const Data &data=Data())
DGtal::CubicalComplex::Self
CubicalComplex< TKSpace, TCellContainer > Self
Definition CubicalComplex.h:179
DGtal::CubicalComplex::const_reference
Cell const & const_reference
Definition CubicalComplex.h:518
DGtal::CubicalComplex::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CSTLAssociativeContainer< TCellContainer >))
DGtal::CubicalComplex::cellBoundary
Cells cellBoundary(const Cell &aCell, bool hintClosed=false) const
DGtal::CubicalComplex::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT(IsPairAssociativeContainer< TCellContainer >::value)
DGtal::CubicalComplex::begin
CellMapConstIterator begin(Dimension d) const
DGtal::CubicalComplex::close
void close(Dimension k)
DGtal::CubicalComplex::const_iterator
ConstIterator const_iterator
Definition CubicalComplex.h:514
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, REMOVED=0x10000000)
Flag Used to indicate in a cell data that this cell has been (virtually) removed.
DGtal::CubicalComplex::belongs
bool belongs(const PreCell &aCell) const
DGtal::CubicalComplex::eraseCells
void eraseCells(CellMapIterator it, CellMapIterator itE)
DGtal::CubicalComplex::end
CellMapConstIterator end(Dimension d) const
DGtal::CubicalComplex::Size
KSpace::Size Size
Type for a number of elements.
Definition CubicalComplex.h:248
DGtal::CubicalComplex::boundary
CubicalComplex boundary(bool hintClosed=false) const
DGtal::CubicalComplex::link
CubicalComplex link(const CubicalComplex &S, bool hintClosed=false, bool hintOpen=false) const
DGtal::CubicalComplex::star
CubicalComplex star(const CubicalComplex &S, bool hintOpen=false) const
DGtal::CubicalComplex::directFacesIterators
void directFacesIterators(CellMapIteratorOutputIterator &outIt, const Cell &aCell)
DGtal::CubicalComplex::myCells
std::vector< CellMap > myCells
Definition CubicalComplex.h:1301
DGtal::CubicalComplex::Point
KSpace::Point Point
Type for a point in the digital space.
Definition CubicalComplex.h:249
DGtal::CubicalComplex::operator[]
Data & operator[](const Cell &aCell)
DGtal::CubicalComplex::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((boost::is_base_of< CubicalCellData, Data >::value))
DGtal::CubicalComplex::erase
void erase(Iterator position)
DGtal::CubicalComplex::erase
Size erase(const Cell &aCell)
DGtal::CubicalComplex::end
CellMapIterator end(Dimension d)
DGtal::CubicalComplex::swap
void swap(CubicalComplex &other)
DGtal::CubicalComplex::directFaces
void directFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintClosed=false) const
DGtal::CubicalComplex::coFaces
void coFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintOpen=false) const
DGtal::CubicalComplex::getCells
const CellMap & getCells(const Dimension d) const
DGtal::CubicalComplex::nbCells
Size nbCells(Dimension d) const
DGtal::CubicalComplex::interior
CubicalComplex interior() const
DGtal::CubicalComplex::count
Size count(const Cell &aCell) const
DGtal::CubicalComplex::difference_type
CellContainer::difference_type difference_type
Definition CubicalComplex.h:520
DGtal::CubicalComplex::insertCells
void insertCells(Dimension d, CellConstIterator it, CellConstIterator itE, const Data &data=Data())
DGtal::CubicalComplex::insert
void insert(InputIterator first, InputIterator last)
DGtal::CubicalComplex::Cells
KSpace::Cells Cells
Type for a sequence of cells in the space.
Definition CubicalComplex.h:246
DGtal::CubicalComplex::operator()
bool operator()(const Cell &aCell) const
DGtal::CubicalComplex::DirIterator
KSpace::DirIterator DirIterator
Type for iterating over cell directions.
Definition CubicalComplex.h:250
DGtal::CubicalComplex::eraseCells
Size eraseCells(CellConstIterator it, CellConstIterator itE)
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, FIXED=0x40000000)
Flag Used to indicate in a cell data that this cell is fixed.
DGtal::CubicalComplex::belongs
bool belongs(const Cell &aCell) const
DGtal::CubicalComplex::findCell
CellMapConstIterator findCell(Dimension d, const Cell &aCell) const
DGtal::CubicalComplex::dim
Dimension dim(const Cell &aCell) const
DGtal::CubicalComplex::selfDisplay
void selfDisplay(std::ostream &out) const
DGtal::CubicalComplex::insertCell
void insertCell(const Cell &aCell, const Data &data=Data())
DGtal::CubicalComplex::CellMapIterator
CellMap::iterator CellMapIterator
Iterator for visiting type CellMap.
Definition CubicalComplex.h:253
DGtal::CubicalComplex::erase
void erase(Iterator first, Iterator last)
DGtal::CubicalComplex::fillData
void fillData(Data data=Data())
DGtal::CubicalComplex::eraseCell
void eraseCell(CellMapIterator it)
DGtal::CubicalComplex::dimension
static const Dimension dimension
The dimension of the embedding space.
Definition CubicalComplex.h:242
DGtal::CubicalComplex::fillData
void fillData(Dimension d, Data data=Data())
DGtal::CubicalComplex::clear
void clear(Dimension d)
DGtal::CubicalComplex::Data
CellContainer::mapped_type Data
Type of data associated to each cell.
Definition CubicalComplex.h:235
DGtal::CubicalComplex::operator=
CubicalComplex & operator=(const CubicalComplex &other)
DGtal::CubicalComplex::CellType
CellType
Possible cell types within a complex.
Definition CubicalComplex.h:257
DGtal::CubicalComplex::begin
ConstIterator begin() const
DGtal::CubicalComplex::CubicalComplex
CubicalComplex(ConstAlias< KSpace > aK)
DGtal::CubicalComplex::CellMap
CellContainer CellMap
Type for storing cells, an associative container Cell -> Data.
Definition CubicalComplex.h:251
DGtal::CubicalComplex::directCoFacesIterators
void directCoFacesIterators(CellMapIteratorOutputIterator &outIt, const Cell &aCell)
DGtal::CubicalComplex::insert
std::pair< Iterator, bool > insert(const Cell &aCell)
DGtal::CubicalComplex::equal_range
std::pair< ConstIterator, ConstIterator > equal_range(const Cell &aCell) const
DGtal::CubicalComplex::CellMapConstIterator
CellMap::const_iterator CellMapConstIterator
Const iterator for visiting type CellMap.
Definition CubicalComplex.h:252
DGtal::CubicalComplex::CubicalComplex
CubicalComplex(const CubicalComplex &other)
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, USER1=0x80000000)
User flag for a cell.
DGtal::CubicalComplex::isValid
bool isValid() const
DGtal::CubicalComplex::eraseCell
Size eraseCell(Dimension d, const Cell &aCell)
DGtal::CubicalComplex::findCell
CellMapIterator findCell(Dimension d, const Cell &aCell)
DGtal::CubicalComplex::euler
Integer euler() const
DGtal::CubicalComplex::belongs
bool belongs(Dimension d, const Cell &aCell) const
DGtal::CubicalComplex::find
Iterator find(const Cell &aCell)
DGtal::CubicalComplex::faces
void faces(CellOutputIterator &outIt, const Cell &aCell, bool hintClosed=false) const
DGtal::KhalimskySpaceND::Integer
TInteger Integer
Arithmetic ring induced by (+,-,*) and Integer numbers.
Definition KhalimskySpaceND.h:404
DGtal::KhalimskySpaceND::Point
PointVector< dim, Integer > Point
Definition KhalimskySpaceND.h:425
DGtal::KhalimskySpaceND::Size
NumberTraits< Integer >::UnsignedVersion Size
Type used to represent sizes in the digital space.
Definition KhalimskySpaceND.h:407
DGtal::KhalimskySpaceND::dimension
static const constexpr Dimension dimension
Definition KhalimskySpaceND.h:430
DGtal::KhalimskySpaceND::DirIterator
typename PreCellularGridSpace::DirIterator DirIterator
Definition KhalimskySpaceND.h:422
DGtal::KhalimskySpaceND::Cell
KhalimskyCell< dim, Integer > Cell
Definition KhalimskySpaceND.h:415
DGtal::KhalimskySpaceND::Cells
AnyCellCollection< Cell > Cells
Definition KhalimskySpaceND.h:439
DGtal
DGtal is the top-level namespace which contains all DGtal functions and types.
Definition ClosedIntegerHalfPlane.h:49
DGtal::operator>=
bool operator>=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Comparison operator on Points/Vectors (GreaterOrEqualThan).
DGtal::operator*
KForm< Calculus, order, duality > operator*(const typename Calculus::Scalar &scalar, const KForm< Calculus, order, duality > &form)
DGtal::operator^=
CubicalComplex< TKSpace, TCellContainer > & operator^=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:245
DGtal::operator==
bool operator==(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Equality operator between two Points/Vectors.
DGtal::uint32_t
boost::uint32_t uint32_t
unsigned 32-bit integer.
Definition BasicTypes.h:63
DGtal::operator&=
CubicalComplex< TKSpace, TCellContainer > & operator&=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:201
DGtal::operator!=
bool operator!=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Difference operator on Points/Vectors.
DGtal::operator~
CubicalComplex< TKSpace, TCellContainer > operator~(const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:61
DGtal::operator<<
std::ostream & operator<<(std::ostream &out, const ClosedIntegerHalfPlane< TSpace > &object)
DGtal::operator<=
bool operator<=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Comparison operator on Points/Vectors (LesserOrEqualThan).
DGtal::Dimension
DGtal::uint32_t Dimension
Definition Common.h:136
DGtal::operator^
CubicalComplex< TKSpace, TCellContainer > operator^(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:222
DGtal::operator|=
CubicalComplex< TKSpace, TCellContainer > & operator|=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:160
DGtal::operator-
KForm< Calculus, order, duality > operator-(const KForm< Calculus, order, duality > &form_a, const KForm< Calculus, order, duality > &form_b)
DGtal::operator&
CubicalComplex< TKSpace, TCellContainer > operator&(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:180
DGtal::operator|
CubicalComplex< TKSpace, TCellContainer > operator|(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:139
DGtal::operator-=
CubicalComplex< TKSpace, TCellContainer > & operator-=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition CubicalComplexFunctions.h:97
DGtal::ContainerTraits
Defines default container traits for arbitrary types.
Definition ContainerTraits.h:86
DGtal::CubicalComplex::ConstIterator::Base
boost::iterator_facade< ConstIterator, Cell const, std::forward_iterator_tag > Base
Definition CubicalComplex.h:313
DGtal::CubicalComplex::ConstIterator::ConstIterator
ConstIterator()
Default iterator. Invalid.
Definition CubicalComplex.h:321
DGtal::CubicalComplex::ConstIterator::equal
bool equal(const ConstIterator &other) const
Definition CubicalComplex.h:384
DGtal::CubicalComplex::ConstIterator::ConstIterator
ConstIterator(ConstAlias< CubicalComplex > cc, Dimension d, CellMapConstIterator it)
Definition CubicalComplex.h:355
DGtal::CubicalComplex::ConstIterator::ConstIterator
ConstIterator(ConstAlias< CubicalComplex > cc, Dimension d)
Definition CubicalComplex.h:331
DGtal::CubicalComplex::DefaultCellMapIteratorPriority::operator()
bool operator()(const CellMapIterator &it1, const CellMapIterator &it2) const
Definition CubicalComplex.h:293
DGtal::CubicalComplex::Iterator::Iterator
Iterator(Alias< CubicalComplex > cc, Dimension d, CellMapIterator it)
Definition CubicalComplex.h:459
DGtal::CubicalComplex::Iterator::equal
bool equal(const Iterator &other) const
Definition CubicalComplex.h:488
DGtal::CubicalComplex::Iterator::Base
boost::iterator_facade< Iterator, Cell const, std::forward_iterator_tag > Base
Definition CubicalComplex.h:418
DGtal::CubicalComplex::Iterator::Iterator
Iterator(Alias< CubicalComplex > cc, Dimension d)
Definition CubicalComplex.h:435
DGtal::CubicalComplex::Iterator::Iterator
Iterator()
Default iterator. Invalid.
Definition CubicalComplex.h:426
DGtal::CubicalComplex::Iterator::iterator_core_access
friend class boost::iterator_core_access
Definition CubicalComplex.h:469
DGtal::CubicalComplex::Iterator::DifferenceType
Base::difference_type DifferenceType
Definition CubicalComplex.h:423
DGtal::CubicalComplex::Iterator::dereference
Cell const & dereference() const
Definition CubicalComplex.h:493
DGtal::concepts::CCellularGridSpaceND
Aim: This concept describes a cellular grid space in nD. In these spaces obtained by cartesian produc...
Definition CCellularGridSpaceND.h:164
DGtal::concepts::CSTLAssociativeContainer
Aim: Defines the concept describing an Associative Container of the STL (https://www....
Definition CSTLAssociativeContainer.h:103