DGtal  1.1.0
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)
34 
35 #define CubicalComplex_RECURSES
36 
37 #if !defined CubicalComplex_h
38 
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 ) {}
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 
257  enum CellType {
258  Maximal ,
259  Free ,
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 
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 
560  template < typename TDigitalSet >
561  void construct ( const TDigitalSet & set );
562 
568  CubicalComplex & operator= ( const CubicalComplex & other );
569 
573  void clear();
574 
579  void clear( Dimension d );
580 
587  void fillData( Data data = Data() );
588 
597  void fillData( Dimension d, Data data = Data() );
598 
603  Dimension dim() const;
604 
609  Dimension dim( const Cell& aCell ) const;
610 
615  Size nbCells( Dimension d ) const;
616 
624  Integer euler() const;
625 
629  const KSpace& space() const;
630 
631  // ---------- cell container operations ---------------
632  public:
633 
639  const CellMap & getCells(const Dimension d) const ;
640 
646  CellMap & getCells(const Dimension d) ;
647 
650  ConstIterator begin() const;
651 
654  ConstIterator end() const;
655 
658  Iterator begin();
659 
662  Iterator end();
663 
668  Size count( const Cell& aCell ) const;
669 
671  Size size() const;
672 
675  Size max_size() const;
676 
678  bool empty() const;
679 
690  std::pair< ConstIterator, ConstIterator > equal_range( const Cell& aCell ) const;
691 
702  std::pair< Iterator, Iterator > equal_range( const Cell& aCell );
703 
708  void erase( Iterator position );
709 
715  Size erase( const Cell& aCell );
716 
722  void erase( Iterator first, Iterator last );
723 
728  ConstIterator find( const Cell& aCell ) const;
729 
734  Iterator find( const Cell& aCell );
735 
745  std::pair< Iterator, bool > insert( const Cell& aCell );
746 
754  Iterator insert( Iterator position, const Cell& aCell );
755 
763  template <class InputIterator>
764  void insert( InputIterator first, InputIterator last );
765 
773  void swap( CubicalComplex& other );
774 
775  // ---------- enhanced container operations ---------------
776  public:
777 
785  Data& operator[]( const Cell& aCell );
786 
794  bool operator()( const Cell& aCell ) const;
795 
802  void insertCell( const Cell& aCell, const Data& data = Data() );
803 
812  void insertCell( Dimension d, const Cell& aCell, const Data& data = Data() );
813 
824  template <typename CellConstIterator>
825  void insertCells( CellConstIterator it, CellConstIterator itE, const Data& data = Data() );
826 
838  template <typename CellConstIterator>
839  void insertCells( Dimension d, CellConstIterator it, CellConstIterator itE, const Data& data = Data() );
840 
845  bool belongs( const Cell& aCell ) const;
846  bool belongs( const PreCell& aCell ) const;
847 
853  bool belongs( Dimension d, const Cell& aCell ) const;
854  bool belongs( Dimension d, const PreCell& aCell ) const;
855 
861  Size eraseCell( const Cell& aCell );
862 
869  Size eraseCell( Dimension d, const Cell& aCell );
870 
875  void eraseCell( CellMapIterator it );
876 
882  void eraseCells( CellMapIterator it, CellMapIterator itE );
883 
893  template <typename CellConstIterator>
894  Size eraseCells( CellConstIterator it, CellConstIterator itE );
895 
906  template <typename CellConstIterator>
907  Size eraseCells( Dimension d, CellConstIterator it, CellConstIterator itE );
908 
923  template <typename CellOutputIterator>
924  void faces( CellOutputIterator& outIt, const Cell& aCell,
925  bool hintClosed = false ) const;
926 
943  template <typename CellOutputIterator>
944  void directFaces( CellOutputIterator& outIt, const Cell& aCell,
945  bool hintClosed = false ) const;
946 
960  template <typename CellMapIteratorOutputIterator>
961  void directFacesIterators( CellMapIteratorOutputIterator& outIt, const Cell& aCell );
962 
978  template <typename CellOutputIterator>
979  void coFaces( CellOutputIterator& outIt, const Cell& aCell,
980  bool hintOpen = false ) const;
981 
998  template <typename CellOutputIterator>
999  void directCoFaces( CellOutputIterator& outIt, const Cell& aCell,
1000  bool hintOpen = false ) const;
1001 
1015  template <typename CellMapIteratorOutputIterator>
1016  void directCoFacesIterators( CellMapIteratorOutputIterator& outIt, const Cell& aCell );
1017 
1022  CellMapConstIterator begin( Dimension d ) const;
1023 
1028  CellMapConstIterator end( Dimension d ) const;
1029 
1034  CellMapIterator begin( Dimension d );
1035 
1040  CellMapIterator end( Dimension d );
1041 
1046  CellMapConstIterator findCell( const Cell& aCell ) const;
1047 
1053  CellMapConstIterator findCell( Dimension d, const Cell& aCell ) const;
1054 
1059  CellMapIterator findCell( const Cell& aCell );
1060 
1066  CellMapIterator findCell( Dimension d, const Cell& aCell );
1067 
1068  // ---------- local operations for extracting specific subcomplexes -------------
1069  public:
1070 
1088  Cells cellBoundary( const Cell& aCell, bool hintClosed = false ) const;
1089 
1106  Cells cellCoBoundary( const Cell& aCell, bool hintOpen = false ) const;
1107 
1108 
1109  // ---------------------- local properties --------------------------------------
1110  public:
1118  bool isCellInterior( const Cell& aCell ) const;
1119 
1127  bool isCellBoundary( const Cell& aCell ) const;
1128 
1152  CellType computeCellType( const Cell& c, CellMapIterator& it_cell_up,
1153  Dimension n = dimension );
1154 
1155 
1156  // ----------------------- Standard subcomplexes --------------------------------
1157  public:
1158 
1163  CubicalComplex interior() const;
1164 
1176  CubicalComplex boundary( bool hintClosed = false ) const;
1177 
1190  void getInteriorAndBoundary( CubicalComplex& intcc,
1191  CubicalComplex& bdcc,
1192  bool hintClosed = false ) const;
1193 
1204  CubicalComplex closure( const CubicalComplex& S, bool hintClosed = false ) const;
1205 
1216  CubicalComplex star( const CubicalComplex& S, bool hintOpen = false ) const;
1217 
1232  CubicalComplex link( const CubicalComplex& S, bool hintClosed = false, bool hintOpen = false ) const;
1233 
1234  // ----------------------- global operations on complexes -----------------------
1235  public:
1236 
1240  void close();
1241 
1246  void close( Dimension k );
1247 
1251  void open();
1252 
1257  void open( Dimension k );
1258 
1259 
1260  // ----------------------- Interface --------------------------------------
1261  public:
1262 
1267  void selfDisplay ( std::ostream & out ) const;
1268 
1273  bool isValid() const;
1274 
1275  // --------------- CDrawableWithBoard2D realization ------------------
1276  public:
1280  std::string className() const;
1281 
1282  // ------------------------- Protected Datas ------------------------------
1283  protected:
1284 
1286  const KSpace* myKSpace;
1287 
1291  std::vector<CellMap> myCells;
1292 
1293 
1294  // ------------------------- Hidden services ------------------------------
1295  protected:
1296 
1297 
1298  private:
1299 
1300 
1301  // ------------------------- Internals ------------------------------------
1302  private:
1303 
1304 
1305  }; // end of class CubicalComplex
1306 
1312  template < typename TKSpace,
1313  typename TCellContainer >
1314  struct ContainerTraits< CubicalComplex< TKSpace, TCellContainer > >
1315  {
1316  //typedef typename ContainerTraits< TCellContainer >::Category Category;
1317  typedef SequenceCategory Category;
1318  };
1319 
1320 
1327  template <typename TKSpace, typename TCellContainer>
1328  std::ostream&
1329  operator<< ( std::ostream & out,
1330  const CubicalComplex<TKSpace, TCellContainer> & object );
1331 
1332 } // namespace DGtal
1333 
1334 
1336 // Includes inline functions.
1337 #include "DGtal/topology/CubicalComplex.ih"
1338 
1339 // //
1341 
1342 #endif // !defined CubicalComplex_h
1343 
1344 #undef CubicalComplex_RECURSES
1345 #endif // else defined(CubicalComplex_RECURSES)
DGtal::CubicalComplex::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((boost::is_same< typename TKSpace::Cell, typename CellContainer::key_type >::value))
DGtal::KhalimskyPreCell< dim, Integer >
DGtal::CubicalComplex::ConstIterator::ConstIterator
ConstIterator(ConstAlias< CubicalComplex > cc, Dimension d)
Definition: CubicalComplex.h:331
DGtal::SequenceCategory
Definition: ContainerTraits.h:66
DGtal::CubicalComplex::Iterator
Definition: CubicalComplex.h:414
DGtal::CubicalComplex::Space
KSpace::Space Space
Type of the digital space.
Definition: CubicalComplex.h:247
DGtal::CubicalComplex::ConstIterator::myIt
CellMapConstIterator myIt
Definition: CubicalComplex.h:402
DGtal::CubicalComplex::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT(IsPairAssociativeContainer< TCellContainer >::value)
DGtal::CubicalComplex::end
CellMapIterator end(Dimension d)
DGtal::KhalimskySpaceND::dimension
static constexpr const Dimension dimension
Definition: KhalimskySpaceND.h:430
DGtal::CubicalComplex::clear
void clear()
DGtal::CubicalComplex::belongs
bool belongs(Dimension d, const PreCell &aCell) const
DGtal::CubicalComplex::Iterator::Self
Iterator Self
Definition: CubicalComplex.h:419
DGtal::CubicalComplex::CellMapIterator
CellMap::iterator CellMapIterator
Iterator for visiting type CellMap.
Definition: CubicalComplex.h:253
DGtal::CubicalComplex::belongs
bool belongs(const PreCell &aCell) const
DGtal::operator-
KForm< Calculus, order, duality > operator-(const KForm< Calculus, order, duality > &form_a, const KForm< Calculus, order, duality > &form_b)
DGtal::CubicalComplex::findCell
CellMapIterator findCell(Dimension d, const Cell &aCell)
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::reference
Cell const & reference
Definition: CubicalComplex.h:517
DGtal::CubicalComplex::close
void close()
DGtal::CubicalComplex::Iterator::myCC
CubicalComplex * myCC
Definition: CubicalComplex.h:504
DGtal::uint32_t
boost::uint32_t uint32_t
unsigned 32-bit integer.
Definition: BasicTypes.h:63
DGtal::CubicalComplex::swap
void swap(CubicalComplex &other)
DGtal::CubicalComplex::Iterator::myItEnd
CellMapIterator myItEnd
Definition: CubicalComplex.h:507
DGtal::CubicalComplex::Iterator::myIt
CellMapIterator myIt
Definition: CubicalComplex.h:506
DGtal::CubicalComplex::Integer
KSpace::Integer Integer
Type for integers in the space.
Definition: CubicalComplex.h:243
DGtal::CubicalComplex::equal_range
std::pair< ConstIterator, ConstIterator > equal_range(const Cell &aCell) const
DGtal::CubicalComplex::begin
CellMapIterator begin(Dimension d)
DGtal::CubicalComplex::CubicalComplex
CubicalComplex(ConstAlias< KSpace > aK)
DGtal::CubicalComplex::cellBoundary
Cells cellBoundary(const Cell &aCell, bool hintClosed=false) const
DGtal::CubicalComplex::directFacesIterators
void directFacesIterators(CellMapIteratorOutputIterator &outIt, const Cell &aCell)
DGtal::CubicalComplex::euler
Integer euler() const
DGtal::CubicalComplex::Iterator::dereference
Cell const & dereference() const
Definition: CubicalComplex.h:493
DGtal::CubicalCellData::CubicalCellData
CubicalCellData(uint32_t d)
Definition: CubicalComplex.h:78
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, USER1=0x80000000)
User flag for a cell.
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::KhalimskySpaceND::Cells
AnyCellCollection< Cell > Cells
Definition: KhalimskySpaceND.h:439
DGtal::CubicalComplex::Iterator::equal
bool equal(const Iterator &other) const
Definition: CubicalComplex.h:488
DGtal::ContainerTraits< CubicalComplex< TKSpace, TCellContainer > >::Category
SequenceCategory Category
Definition: CubicalComplex.h:1317
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::CubicalComplex::begin
ConstIterator begin() const
DGtal::CubicalComplex::isCellInterior
bool isCellInterior(const Cell &aCell) const
DGtal::CubicalComplex::insert
std::pair< Iterator, bool > insert(const Cell &aCell)
DGtal::CubicalComplex::Maximal
@ Maximal
Definition: CubicalComplex.h:258
DGtal::Dimension
DGtal::uint32_t Dimension
Definition: Common.h:133
DGtal::CubicalComplex::eraseCells
void eraseCells(CellMapIterator it, CellMapIterator itE)
DGtal::CubicalComplex::CellMapConstIterator
CellMap::const_iterator CellMapConstIterator
Const iterator for visiting type CellMap.
Definition: CubicalComplex.h:252
DGtal::operator<=
bool operator<=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Comparison operator on Points/Vectors (LesserOrEqualThan).
DGtal::CubicalComplex::Iterator::Iterator
Iterator()
Default iterator. Invalid.
Definition: CubicalComplex.h:426
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::end
Iterator end()
DGtal::CubicalComplex::closure
CubicalComplex closure(const CubicalComplex &S, bool hintClosed=false) const
DGtal::CubicalComplex::insertCell
void insertCell(const Cell &aCell, const Data &data=Data())
DGtal::CubicalComplex::begin
Iterator begin()
DGtal::CubicalComplex::faces
void faces(CellOutputIterator &outIt, const Cell &aCell, bool hintClosed=false) const
DGtal::CubicalComplex::fillData
void fillData(Dimension d, Data data=Data())
DGtal::CubicalComplex::find
ConstIterator find(const Cell &aCell) const
DGtal::operator!=
bool operator!=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Difference operator on Points/Vectors.
DGtal::CubicalComplex::Data
CellContainer::mapped_type Data
Type of data associated to each cell.
Definition: CubicalComplex.h:235
DGtal::CubicalComplex::ConstIterator::increment
void increment()
Definition: CubicalComplex.h:377
DGtal::CubicalCellData
Definition: CubicalComplex.h:76
DGtal::CubicalComplex::erase
void erase(Iterator first, Iterator last)
DGtal::CubicalComplex::ConstIterator::nextDimension
void nextDimension()
Definition: CubicalComplex.h:367
DGtal::CubicalComplex::getCells
CellMap & getCells(const Dimension d)
DGtal::CubicalComplex::insert
void insert(InputIterator first, InputIterator last)
DGtal::CubicalComplex::CellContainer
TCellContainer CellContainer
Type for storing cells, an associative container Cell -> Data.
Definition: CubicalComplex.h:234
DGtal::CubicalCellData::data
uint32_t data
Definition: CubicalComplex.h:79
DGtal::CubicalComplex::erase
Size erase(const Cell &aCell)
DGtal::CubicalComplex::CellType
CellType
Possible cell types within a complex.
Definition: CubicalComplex.h:257
DGtal::CubicalComplex::ConstIterator::Base
boost::iterator_facade< ConstIterator, Cell const, std::forward_iterator_tag > Base
Definition: CubicalComplex.h:313
DGtal::CubicalComplex::ConstIterator::dimension
Dimension dimension() const
Definition: CubicalComplex.h:394
DGtal::CubicalComplex::myKSpace
const KSpace * myKSpace
The Khalimsky space in which lives the cubical complex.
Definition: CubicalComplex.h:1286
DGtal::CubicalComplex::Iterator::nextDimension
void nextDimension()
Definition: CubicalComplex.h:471
DGtal::CubicalComplex::belongs
bool belongs(Dimension d, const Cell &aCell) const
DGtal::CubicalComplex::Iterator::myD
Dimension myD
Definition: CubicalComplex.h:505
DGtal::CubicalComplex::size_type
CellContainer::size_type size_type
Definition: CubicalComplex.h:519
DGtal::SpaceND
Definition: SpaceND.h:96
DGtal::CubicalComplex::selfDisplay
void selfDisplay(std::ostream &out) const
DGtal::CubicalComplex::insertCell
void insertCell(Dimension d, const Cell &aCell, const Data &data=Data())
DGtal::CubicalComplex::getInteriorAndBoundary
void getInteriorAndBoundary(CubicalComplex &intcc, CubicalComplex &bdcc, bool hintClosed=false) const
DGtal::CubicalComplex::count
Size count(const Cell &aCell) const
DGtal::CubicalComplex::directCoFacesIterators
void directCoFacesIterators(CellMapIteratorOutputIterator &outIt, const Cell &aCell)
DGtal::operator-=
CubicalComplex< TKSpace, TCellContainer > & operator-=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:97
DGtal::operator&=
CubicalComplex< TKSpace, TCellContainer > & operator&=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:201
DGtal::CubicalComplex::construct
void construct(const TDigitalSet &set)
DGtal::CubicalComplex::Iterator::Pointer
Base::pointer Pointer
Definition: CubicalComplex.h:421
DGtal::CubicalComplex::KSpace
TKSpace KSpace
Type of the cellular grid space.
Definition: CubicalComplex.h:233
DGtal::CubicalComplex::CubicalComplex
CubicalComplex()
DGtal::CubicalComplex::begin
CellMapConstIterator begin(Dimension d) const
DGtal::CubicalComplex::ConstIterator::myCC
const CubicalComplex * myCC
Definition: CubicalComplex.h:400
DGtal::CubicalComplex::Self
CubicalComplex< TKSpace, TCellContainer > Self
Definition: CubicalComplex.h:179
DGtal::KhalimskySpaceND::Size
NumberTraits< Integer >::UnsignedVersion Size
Type used to represent sizes in the digital space.
Definition: KhalimskySpaceND.h:407
DGtal::CubicalComplex::ConstIterator::ConstIterator
ConstIterator()
Default iterator. Invalid.
Definition: CubicalComplex.h:321
DGtal::CubicalComplex::findCell
CellMapIterator findCell(const Cell &aCell)
DGtal::CubicalComplex::operator=
CubicalComplex & operator=(const CubicalComplex &other)
DGtal
DGtal is the top-level namespace which contains all DGtal functions and types.
Definition: ClosedIntegerHalfPlane.h:49
DGtal::CubicalComplex::eraseCells
Size eraseCells(CellConstIterator it, CellConstIterator itE)
DGtal::operator~
CubicalComplex< TKSpace, TCellContainer > operator~(const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:61
DGtal::CubicalComplex::interior
CubicalComplex interior() const
DGtal::CubicalComplex::ConstIterator
Definition: CubicalComplex.h:309
DGtal::CubicalComplex::ConstIterator::equal
bool equal(const ConstIterator &other) const
Definition: CubicalComplex.h:384
DGtal::CubicalComplex::eraseCell
Size eraseCell(Dimension d, const Cell &aCell)
DGtal::CubicalComplex::find
Iterator find(const Cell &aCell)
DGtal::CubicalComplex::Any
@ Any
Definition: CubicalComplex.h:260
DGtal::CubicalComplex::pointer
Cell const * pointer
Definition: CubicalComplex.h:521
DGtal::CubicalComplex::insertCells
void insertCells(CellConstIterator it, CellConstIterator itE, const Data &data=Data())
DGtal::CubicalComplex::Cell
KSpace::Cell Cell
Type for a cell in the space.
Definition: CubicalComplex.h:244
DGtal::operator>=
bool operator>=(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Comparison operator on Points/Vectors (GreaterOrEqualThan).
DGtal::CubicalComplex::belongs
bool belongs(const Cell &aCell) const
DGtal::CubicalComplex::Iterator::increment
void increment()
Definition: CubicalComplex.h:481
DGtal::CubicalComplex::link
CubicalComplex link(const CubicalComplex &S, bool hintClosed=false, bool hintOpen=false) const
DGtal::CubicalComplex::ConstIterator::Value
Base::value_type Value
Definition: CubicalComplex.h:315
DGtal::CubicalComplex::Iterator::Reference
Base::reference Reference
Definition: CubicalComplex.h:422
DGtal::CubicalComplex::eraseCells
Size eraseCells(Dimension d, CellConstIterator it, CellConstIterator itE)
DGtal::CubicalComplex::PreCell
Cell::PreCell PreCell
Type for a precell in the space.
Definition: CubicalComplex.h:245
DGtal::operator|=
CubicalComplex< TKSpace, TCellContainer > & operator|=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:160
DGtal::operator|
CubicalComplex< TKSpace, TCellContainer > operator|(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:139
DGtal::CubicalComplex::eraseCell
void eraseCell(CellMapIterator it)
DGtal::CubicalComplex::ConstIterator::iterator_core_access
friend class boost::iterator_core_access
Definition: CubicalComplex.h:365
DGtal::CubicalComplex::space
const KSpace & space() const
DGtal::CubicalComplex::computeCellType
CellType computeCellType(const Cell &c, CellMapIterator &it_cell_up, Dimension n=dimension)
DGtal::CubicalComplex::iterator
Iterator iterator
Definition: CubicalComplex.h:515
DGtal::CubicalComplex::DefaultCellMapIteratorPriority::operator()
bool operator()(const CellMapIterator &it1, const CellMapIterator &it2) const
Definition: CubicalComplex.h:293
DGtal::CubicalComplex::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CCellularGridSpaceND< TKSpace >))
DGtal::CubicalComplex::insert
Iterator insert(Iterator position, const Cell &aCell)
DGtal::CubicalComplex::max_size
Size max_size() const
DGtal::CubicalComplex::equal_range
std::pair< Iterator, Iterator > equal_range(const Cell &aCell)
DGtal::CubicalComplex::nbCells
Size nbCells(Dimension d) const
DGtal::concepts::CSTLAssociativeContainer
Aim: Defines the concept describing an Associative Container of the STL (https://www....
Definition: CSTLAssociativeContainer.h:103
DGtal::CubicalComplex::clear
void clear(Dimension d)
DGtal::CubicalCellData::CubicalCellData
CubicalCellData()
Definition: CubicalComplex.h:77
DGtal::CubicalComplex::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(uint32_t, VALUE=0x0fffffff)
Value for a cell.
DGtal::CubicalComplex::const_iterator
ConstIterator const_iterator
Definition: CubicalComplex.h:514
DGtal::CubicalComplex::Cells
KSpace::Cells Cells
Type for a sequence of cells in the space.
Definition: CubicalComplex.h:246
DGtal::ContainerTraits
Defines default container traits for arbitrary types.
Definition: ContainerTraits.h:86
DGtal::CubicalComplex::isValid
bool isValid() const
DGtal::CubicalComplex::Free
@ Free
Definition: CubicalComplex.h:259
DGtal::operator<<
std::ostream & operator<<(std::ostream &out, const ClosedIntegerHalfPlane< TSpace > &object)
DGtal::CubicalComplex::ConstIterator::DifferenceType
Base::difference_type DifferenceType
Definition: CubicalComplex.h:318
DGtal::CubicalComplex::myCells
std::vector< CellMap > myCells
Definition: CubicalComplex.h:1291
DGtal::CubicalComplex::close
void close(Dimension k)
DGtal::CubicalComplex::~CubicalComplex
~CubicalComplex()
DGtal::CubicalComplex::DirIterator
KSpace::DirIterator DirIterator
Type for iterating over cell directions.
Definition: CubicalComplex.h:250
DGtal::CubicalComplex::dim
Dimension dim(const Cell &aCell) const
DGtal::CubicalComplex::operator[]
Data & operator[](const Cell &aCell)
DGtal::CubicalComplex::ConstIterator::Self
ConstIterator Self
Definition: CubicalComplex.h:314
DGtal::CubicalComplex::directCoFaces
void directCoFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintOpen=false) const
DGtal::KhalimskySpaceND::DirIterator
typename PreCellularGridSpace::DirIterator DirIterator
Definition: KhalimskySpaceND.h:422
DGtal::CubicalComplex::open
void open(Dimension k)
DGtal::CubicalComplex::directFaces
void directFaces(CellOutputIterator &outIt, const Cell &aCell, bool hintClosed=false) const
DGtal::CubicalComplex::findCell
CellMapConstIterator findCell(Dimension d, const Cell &aCell) const
DGtal::operator&
CubicalComplex< TKSpace, TCellContainer > operator&(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:180
DGtal::CubicalComplex::ConstIterator::myItEnd
CellMapConstIterator myItEnd
Definition: CubicalComplex.h:403
DGtal::CubicalComplex::open
void open()
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::value_type
Cell value_type
Definition: CubicalComplex.h:516
DGtal::CubicalComplex::CellMap
CellContainer CellMap
Type for storing cells, an associative container Cell -> Data.
Definition: CubicalComplex.h:251
DGtal::CubicalComplex::Iterator::Iterator
Iterator(Alias< CubicalComplex > cc, Dimension d, CellMapIterator it)
Definition: CubicalComplex.h:459
DGtal::PointVector< dim, Integer >
DGtal::CubicalComplex::Iterator::iterator_core_access
friend class boost::iterator_core_access
Definition: CubicalComplex.h:469
DGtal::CubicalComplex::Size
KSpace::Size Size
Type for a number of elements.
Definition: CubicalComplex.h:248
DGtal::CubicalComplex::Iterator::DifferenceType
Base::difference_type DifferenceType
Definition: CubicalComplex.h:423
DGtal::CubicalComplex::ConstIterator::ConstIterator
ConstIterator(ConstAlias< CubicalComplex > cc, Dimension d, CellMapConstIterator it)
Definition: CubicalComplex.h:355
DGtal::operator^=
CubicalComplex< TKSpace, TCellContainer > & operator^=(CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:245
DGtal::CubicalComplex::Iterator::Iterator
Iterator(Alias< CubicalComplex > cc, Dimension d)
Definition: CubicalComplex.h:435
DGtal::CubicalComplex::empty
bool empty() const
DGtal::CubicalComplex::Iterator::dimension
Dimension dimension() const
Definition: CubicalComplex.h:498
DGtal::CubicalComplex::dimension
static const Dimension dimension
The dimension of the embedding space.
Definition: CubicalComplex.h:242
DGtal::CubicalComplex::boundary
CubicalComplex boundary(bool hintClosed=false) const
DGtal::CubicalComplex::eraseCell
Size eraseCell(const Cell &aCell)
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::operator*
KForm< Calculus, order, duality > operator*(const typename Calculus::Scalar &scalar, const KForm< Calculus, order, duality > &form)
DGtal::CubicalComplex::Iterator::Value
Base::value_type Value
Definition: CubicalComplex.h:420
DGtal::KhalimskySpaceND::Integer
TInteger Integer
Arithmetic ring induced by (+,-,*) and Integer numbers.
Definition: KhalimskySpaceND.h:404
DGtal::CubicalComplex::dim
Dimension dim() const
DGtal::CubicalComplex::fillData
void fillData(Data data=Data())
DGtal::CubicalComplex::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((boost::is_base_of< CubicalCellData, Data >::value))
DGtal::CubicalComplex::const_reference
Cell const & const_reference
Definition: CubicalComplex.h:518
DGtal::CubicalComplex::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CSTLAssociativeContainer< TCellContainer >))
DGtal::operator^
CubicalComplex< TKSpace, TCellContainer > operator^(const CubicalComplex< TKSpace, TCellContainer > &, const CubicalComplex< TKSpace, TCellContainer > &)
Definition: CubicalComplexFunctions.h:222
DGtal::operator==
bool operator==(PointVector< ptDim, LeftEuclideanRing, LeftContainer > const &lhs, PointVector< ptDim, RightEuclideanRing, RightContainer > const &rhs)
Equality operator between two Points/Vectors.
DGtal::CubicalComplex::Point
KSpace::Point Point
Type for a point in the digital space.
Definition: CubicalComplex.h:249
DGtal::CubicalComplex::CubicalComplex
CubicalComplex(const CubicalComplex &other)
DGtal::CubicalComplex::end
ConstIterator end() const
DGtal::CubicalComplex::cellCoBoundary
Cells cellCoBoundary(const Cell &aCell, bool hintOpen=false) const
DGtal::CubicalComplex
Aim: This class represents an arbitrary cubical complex living in some Khalimsky space....
Definition: CubicalComplex.h:176
DGtal::CubicalComplex::Iterator::Base
boost::iterator_facade< Iterator, Cell const, std::forward_iterator_tag > Base
Definition: CubicalComplex.h:418
DGtal::CubicalComplex::isCellBoundary
bool isCellBoundary(const Cell &aCell) const
DGtal::CubicalComplex::end
CellMapConstIterator end(Dimension d) const
DGtal::CubicalComplex::ConstIterator::Pointer
Base::pointer Pointer
Definition: CubicalComplex.h:316
DGtal::CubicalComplex::const_pointer
Cell const * const_pointer
Definition: CubicalComplex.h:522
DGtal::CubicalComplex::findCell
CellMapConstIterator findCell(const Cell &aCell) const
DGtal::IsPairAssociativeContainer
Definition: ContainerTraits.h:377
DGtal::CubicalComplex::DefaultCellMapIteratorPriority
Definition: CubicalComplex.h:282
DGtal::CubicalComplex::star
CubicalComplex star(const CubicalComplex &S, bool hintOpen=false) const
DGtal::CubicalComplex::ConstIterator::dereference
Cell const & dereference() const
Definition: CubicalComplex.h:389
DGtal::CubicalComplex::erase
void erase(Iterator position)
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::insertCells
void insertCells(Dimension d, CellConstIterator it, CellConstIterator itE, const Data &data=Data())
DGtal::CubicalComplex::size
Size size() const
DGtal::KhalimskyCell< dim, Integer >
DGtal::CubicalComplex::ConstIterator::Reference
Base::reference Reference
Definition: CubicalComplex.h:317
DGtal::CubicalComplex::className
std::string className() const
DGtal::CubicalComplex::operator()
bool operator()(const Cell &aCell) const
DGtal::CubicalComplex::difference_type
CellContainer::difference_type difference_type
Definition: CubicalComplex.h:520
DGtal::CubicalComplex::ConstIterator::myD
Dimension myD
Definition: CubicalComplex.h:401
Generated on Fri Oct 9 2020 08:57:48 for DGtal by doxygen 1.8.20