DGtal  1.5.beta
DGtal::concepts::CPreCellularGridSpaceND< T > Struct Template Reference

Aim: This concept describes an unbounded cellular grid space in nD. In these spaces obtained by cartesian product, cells have a cubic shape that depends on the dimension: 0-cells are points, 1-cells are unit segments, 2-cells are squares, 3-cells are cubes, and so on. More...

#include <DGtal/topology/CPreCellularGridSpaceND.h>

Inheritance diagram for DGtal::concepts::CPreCellularGridSpaceND< T >:
[legend]

Public Types

typedef T::Integer Integer
 
typedef T::Space Space
 
typedef T::PreCellularGridSpace PreCellularGridSpace
 
typedef T::Cell Cell
 
typedef T::SCell SCell
 
typedef T::Surfel Surfel
 
typedef T::Sign Sign
 
typedef T::DirIterator DirIterator
 
typedef T::Point Point
 
typedef T::Vector Vector
 
typedef T::Cells Cells
 
typedef T::SCells SCells
 
typedef T::CellSet CellSet
 
typedef T::SCellSet SCellSet
 
typedef T::SurfelSet SurfelSet
 
typedef int Dummy
 
typedef T::template CellMap< Dummy >::Type CellMap
 
typedef T::template SCellMap< Dummy >::Type SCellMap
 
typedef T::template SurfelMap< Dummy >::Type SurfelMap
 

Public Member Functions

 BOOST_CONCEPT_ASSERT ((CInteger< Integer >))
 
 BOOST_STATIC_ASSERT ((ConceptUtils::SameType< Integer, typename Space::Integer >::value))
 
 BOOST_STATIC_ASSERT ((ConceptUtils::SameType< Point, typename Space::Point >::value))
 
 BOOST_STATIC_ASSERT ((ConceptUtils::SameType< Vector, typename Space::Vector >::value))
 
 BOOST_CONCEPT_ASSERT ((CConstSinglePassRange< Cells >))
 
 BOOST_CONCEPT_ASSERT ((CConstSinglePassRange< SCells >))
 
 BOOST_CONCEPT_ASSERT ((boost::UniqueAssociativeContainer< CellSet >))
 
 BOOST_CONCEPT_ASSERT ((boost::UniqueAssociativeContainer< SCellSet >))
 
 BOOST_CONCEPT_ASSERT ((boost::UniqueAssociativeContainer< SurfelSet >))
 
 BOOST_CONCEPT_ASSERT ((boost::SimpleAssociativeContainer< CellSet >))
 
 BOOST_CONCEPT_ASSERT ((boost::SimpleAssociativeContainer< SCellSet >))
 
 BOOST_CONCEPT_ASSERT ((boost::SimpleAssociativeContainer< SurfelSet >))
 
 BOOST_CONCEPT_ASSERT ((boost::UniqueAssociativeContainer< CellMap >))
 
 BOOST_CONCEPT_ASSERT ((boost::UniqueAssociativeContainer< SCellMap >))
 
 BOOST_CONCEPT_ASSERT ((boost::UniqueAssociativeContainer< SurfelMap >))
 
 BOOST_CONCEPT_ASSERT ((boost::PairAssociativeContainer< CellMap >))
 
 BOOST_CONCEPT_ASSERT ((boost::PairAssociativeContainer< SCellMap >))
 
 BOOST_CONCEPT_ASSERT ((boost::PairAssociativeContainer< SurfelMap >))
 
 BOOST_CONCEPT_USAGE (CPreCellularGridSpaceND)
 
void checkConstConstraints () const
 

Private Attributes

myX
 
Integer myInteger
 
Dimension myDim
 
Point myP1
 
Point myP2
 
Vector myV
 
Cell myCell
 
SCell mySCell
 
Cell myMutableCell
 
SCell myMutableSCell
 
bool myBool
 
Sign mySign
 
DirIterator myDirIt
 
Cells myCells
 
SCells mySCells
 

Detailed Description

template<typename T>
struct DGtal::concepts::CPreCellularGridSpaceND< T >

Aim: This concept describes an unbounded cellular grid space in nD. In these spaces obtained by cartesian product, cells have a cubic shape that depends on the dimension: 0-cells are points, 1-cells are unit segments, 2-cells are squares, 3-cells are cubes, and so on.

Description of concept 'CPreCellularGridSpaceND'

This concept is rather complex since it gathers all possible operations on cells. The idea is that only the space knows what are the cells, how to compute their adjacent or incident cells, how to extract their coordinates, where are the bounds, what is the topology and dimension of a cell, etc. Worse (!), you have two kinds of cells, normal cells (unsigned), and oriented cells (signed). The latter are used to define orientation and boundary operators.

Note
Another way of defining orientation and boundary operators is to define chains on cells and chain complexes. However, this is unnecessary here.

Models of CPreCellularGridSpaceND are used whenever you need to define a topology on a full digital space.

The space size only depends on the given integer precision.

We refer the reader to Cellular grid space and topology, unoriented and oriented cells, incidence for further details.

Refinement of

Associated types

  • Integer: the integral type for representing coordinates in the space (model of CInteger).
  • Space: the corresponding digital space (same dimension and same Integer type as this).
  • PreCelullarGridSpace: the pre-celullar grid space type associated to this model (can be itself).
  • Cell: the type that represents an unsigned cell. Cell's are ordered.
  • SCell: the type that represents a signed cell. SCell's are ordered.
  • Surfel: the type that represents a signed n-1-cell. Should be promotable to SCell and reciprocally. Surfel's are ordered.
  • Sign: the type that represents the sign/orientation of a cell. Should be promotable to bool and reciprocally (POS is true, NEG is false).
  • DirIterator: the type that represents an iterator over the open or closed directions of a cell (signed or not).
  • Point: the type for defining points in Space (same as Space::Point).
  • Vector: the type for defining vectors in Space (same as Space::Vector).
  • Cells: a container that stores unsigned cells (not a set, rather a enumerable collection type, model of CConstSinglePassRange).
  • SCells: a container that stores signed cells (not a set, rather a enumerable collection type, model of CConstSinglePassRange).
  • CellSet: a set container that stores unsigned cells (efficient for queries like find, model of boost::UniqueAssociativeContainer and boost::SimpleAssociativeContainer).
  • SCellSet: a set container that stores signed cells (efficient for queries like find, model of boost::UniqueAssociativeContainer and boost::SimpleAssociativeContainer).
  • SurfelSet: a set container that stores surfels, i.e. signed n-1-cells (efficient for queries like find, model of boost::UniqueAssociativeContainer and boost::SimpleAssociativeContainer).
  • CellMap<Value>: an associative container Cell->Value rebinder type (efficient for key queries). Use as typename X::template CellMap<Value>::Type, which is a model of boost::UniqueAssociativeContainer and boost::PairAssociativeContainer.
  • SCellMap<Value>: an associative container SCell->Value rebinder type (efficient for key queries). Use as typename X::template SCellMap<Value>::Type, which is a model of boost::UniqueAssociativeContainer and boost::PairAssociativeContainer.
  • SurfelMap<Value>: an associative container Surfel->Value rebinder type (efficient for key queries). Use as typename X::template SurfelMap<Value>::Type, which is a model of boost::UniqueAssociativeContainer and boost::PairAssociativeContainer.
Note
DirIterator should be use as follows:
Cell c;
for ( KSpace::DirIterator q = x.uDirs( c ); q != 0; ++q )
{
Dimension dir = *q;
...
}
typename PreCellularGridSpace::DirIterator DirIterator
DGtal::uint32_t Dimension
Definition: Common.h:136
KSpace::Cell Cell

Notation

  • X : A type that is a model of CPreCellularGridSpaceND
  • x : object of type X
  • k : object of type Dimension
  • i : object of type Integer
  • c : object of type Cell
  • sc : object of type SCell
  • s : object of type Surfel
  • p, p1, p2 : object of type Point
  • v : object of type Vector
  • sign: object of type Sign

Definitions

  • digital coordinates are the natural coordinates of the cells of maximal dimension in the cellular space. For instance, it represents the coordinates of the pixels in an image. Two adjacent pixels have digital coordinates that differ by one in the cellular space. It is clear that incident cells (cells of lower dimension) may also have the same digital coordinates.
  • Khalimsky coordinates are a way to number cells such that any two cells have different coordinates. More precisely, digital coordinates are doubled and the odd parity depends on whether or not the cell is open along this coordinate axis.
  • a spel is a cell of maximal dimension (say n), a surfel is a cell of dimension n-1, a pointel is a cell of dimension 0. Spels have thus all their Khalimsky coordinates odd. Surfels have only one Khalimsky coordinate that is even. Pointels have all their Khalimsky coordinates even.
  • the topology of a cell along a dimension k is open if the cell is open along the k-th coordinate axis. We code open with 1 and closed with 0. The topology word of a cell is the integer whose k-th bit is the topology of the cell along the k-th axis. The dimension of a cell is the number of coordinates where the cell is open. It is also the sum of the bits of its topology word.
  • adjacent cells to some cell c are cells with the same topology as c but whose one of their digital coordinates differs by one. They are often called 1-adjacent.
  • incident cells to some cell c are cells that are either a face of c or such that c is one of their faces.

Valid expressions and semantics

Name Expression Type requirements Return type Precondition Semantics Post condition Complexity
dimension X::dimension Dimension the dimension of the space
DIM X::dimension Dimension the dimension of the space
POS X::POS Sign the positive sign for cells
NEG X::NEG Sign the negative sign for cells
Make unsigned cell x.uCell(p) Cell returns the unsigned cell with Khalimsky coordinates equal to p
Make unsigned cell x.uCell(p, c) Cell returns the unsigned cell with digital coordinates equal to p and topology equal to c
Make signed cell x.sCell(p, sign = POS) SCell returns the signed cell with Khalimsky coordinates equal to p and sign sign
Make signed cell x.sCell(p, sc) SCell returns the signed cell with digital coordinates equal to p and sign and topology equal to sc
Make unsigned spel x.uSpel(p) Cell returns the unsigned spel with digital coordinates equal to p
Make signed spel x.sSpel(p, sign = POS) SCell returns the signed spel with digital coordinates equal to p and sign sign
Make unsigned pointel x.uPointel(p) Cell returns the unsigned pointel with digital coordinates equal to p
Make signed pointel x.sPointel(p, sign = POS) SCell returns the signed pointel with digital coordinates equal to p and sign sign
Get Khalimsky coordinate x.uKCoord(c, k) Integer returns the Khalimsky coordinate of cell c along axis k
Get digital coordinate x.uCoord(c, k) Integer returns the digital coordinate of cell c along axis k
Get Khalimsky coordinates x.uKCoords(c) Point returns the Khalimsky coordinates of cell c
Get digital coordinates x.uCoords(c) Point returns the digital coordinates of cell c
Get Khalimsky coordinate x.sKCoord(sc, k) Integer returns the Khalimsky coordinate of signed cell sc along axis k
Get digital coordinate x.sCoord(sc, k) Integer returns the digital coordinate of signed cell sc along axis k
Get Khalimsky coordinates x.sKCoords(sc, k) Point returns the Khalimsky coordinates of signed cell sc
Get digital coordinates x.sCoords(sc, k) Point returns the digital coordinates of signed cell sc
Set Khalimsky coordinate x.uSetKCoord(c,k,i) Sets the k-th Khalimsky coordinate of c to i
Set digital coordinate x.uSetCoord(c,k,i) Sets the k-th digital coordinate of c to i
Set Khalimsky coordinates x.uSetKCoords(c,p) Sets the Khalimsky coordinates of c to p
Set digital coordinates x.uSetCoords(c,p) Sets the digital coordinates of c to p
Set Khalimsky coordinate x.sSetKCoord(sc,k,i) Sets the k-th Khalimsky coordinate of sc to i
Set digital coordinate x.sSetCoord(sc,k,i) Sets the k-th digital coordinate of sc to i
Set Khalimsky coordinates x.sSetKCoords(sc,p) Sets the Khalimsky coordinates of sc to p
Set digital coordinates x.sSetCoords(sc,p) Sets the digital coordinates of sc to p
Sign/orient cell x.signs(c,sign) returns the signed cell with same topology as c and sign sign
Change sign x.sSetSign(sc, sign) Sets the sign of the signed cell sc to sign
Get sign x.sSign(sc) Sign returns the sign of cell sc
Unsign/unorient signed cell x.unsigns(sc) returns the unsigned cell with same topology as sc
Flip sign x.sOpp(sc) returns the signed cell with opposite sign to sc
Get topology word x.uTopology(c) Integer returns the topology word of unsigned cell c
Get topology word x.sTopology(sc) Integer returns the topology word of signed cell sc
Get cell dimension x.uDim(c) Dimension returns the dimension of the unsigned cell c
Get cell dimension x.sDim(sc) Dimension returns the dimension of the signed cell sc
Surfel test x.uIsSurfel(s) bool returns 'true' iff the unsigned cell c has dimension n-1
Surfel test x.sIsSurfel(sc) bool returns 'true' iff the signed cell sc has dimension n-1
Open test x.uIsOpen(c,k) bool returns 'true' iff the unsigned cell c is open along the k-th axis
Open test x.sIsOpen(sc,k) bool returns 'true' iff the signed cell sc is open along the k-th axis
Get open directions x.uDirs(c) DirIterator returns a kind of iterator that enumerates the open directions of c
Get open directions x.sDirs(sc) DirIterator returns a kind of iterator that enumerates the open directions of sc
Get closed directions x.uOrthDirs(c) DirIterator returns a kind of iterator that enumerates the closed directions of c
Get closed directions x.sOrthDirs(sc) DirIterator returns a kind of iterator that enumerates the closed directions of sc
Get closed direction of surfel x.uOrthDir(c) x.uIsSurfel(c) Dimension returns the closed direction of the n-1-cell c
Get closed direction of surfel x.sOrthDir(sc) x.sIsSurfel(sc) Dimension returns the closed direction of the signed n-1-cell sc
Get next cell along some axis x.uGetIncr(c,k) Cell returns the same cell as c except the k-th coordinate that is incremented
Get previous cell along some axis x.uGetDecr(c,k) Cell returns the same cell as c except the k-th coordinate that is decremented
Maximal coordinate test x.uIsMax(c,k) bool returns 'true' iff the cell has the maximal possible k-th coordinate
Minimal coordinate test x.uIsMin(c,k) bool returns 'true' iff the cell has the minimal possible k-th coordinate
Inside test along some axis x.uIsInside(c,k) bool returns 'true' iff the cell c has a valid k-th coordinate
Get cell further along some axis x.uGetAdd(c,k,i) Cell returns the same cell as c except the k-th coordinate that is increased by i
Get cell before along some axis x.uGetSub(c,k,i) Cell returns the same cell as c except the k-th coordinate that is decreased by i
Get the translation of a cell x.uTranslation(c,v) Cell returns the cell that is the translation of c by the vector v
Get the projection of a cell x.uProjection(c,bc,k) bc is a Cell Cell returns the same cell as c except for the k-th coordinate that is equal to the one of bc
Projection of a cell x.uProject(c,bc,k) bc is a Cell modifies cell c such that its k-th coordinate that is equal to the one of bc
Next cell within bounds x.uNext(c,lc,uc) lc, uc are Cell bool cell c becomes the next cell with same topology within lower and upper bounds lc and uc, returns 'true' iff c is still within bounds
Get next cell along some axis x.sGetIncr(sc,k) SCell returns the same cell as sc except the k-th coordinate that is incremented
Get previous cell along some axis x.sGetDecr(sc,k) SCell returns the same cell as sc except the k-th coordinate that is decremented
Maximal coordinate test x.sIsMax(sc,k) bool returns 'true' iff the cell has the maximal possible k-th coordinate
Minimal coordinate test x.sIsMin(sc,k) bool returns 'true' iff the cell has the minimal possible k-th coordinate
Inside test along some axis x.sIsInside(sc,k) bool returns 'true' iff the cell sc has a valid k-th coordinate
Get cell further along some axis x.sGetAdd(sc,k,i) SCell returns the same cell as sc except the k-th coordinate that is increased by i
Get cell before along some axis x.sGetSub(sc,k,i) SCell returns the same cell as sc except the k-th coordinate that is decreased by i
Get the translation of a cell x.sTranslation(sc,v) SCell returns the cell that is the translation of sc by the vector v
Get the projection of a cell x.sProjection(sc,bc,k) bc is a SCell SCell returns the same cell as sc except for the k-th coordinate that is equal to the one of bc
Projection of a cell x.sProject(sc,bc,k) bc is a SCell modifies cell sc such that its k-th coordinate that is equal to the one of bc
Next cell within bounds x.sNext(sc,lc,uc) lc, uc are SCell bool cell sc becomes the next cell with same topology within lower and upper bounds lc and uc, returns 'true' iff sc is still within bounds
Neighborhood x.uNeighborhood(c) Cells returns the range of cells that forms the 1-neighborhood of c
Neighborhood x.sNeighborhood(sc) SCells returns the range of signed cells that forms the 1-neighborhood of sc
Proper neighborhood x.uProperNeighborhood(c) Cells returns the range of cells that forms the proper 1-neighborhood of c, hence without c itself
Proper neighborhood x.sProperNeighborhood(sc) SCells returns the range of signed cells that forms the proper 1-neighborhood of sc, hence without sc itself
Adjacent cell x.uAdjacent(c,k,b) b is a bool Cell return the cell adjacent to c along axis k either with greater coordinate (b is true) or lesser
Adjacent cell x.sAdjacent(sc,k,b) b is a bool SCell return the signed cell adjacent to sc along axis k either with greater coordinate (b is true) or lesser
Incident cell x.uIncident(c,k,b) b is a bool Cell return the cell incident to c along axis k either with greater coordinate (b is true) or lesser
Incident cell x.sIncident(sc,k,b) b is a bool SCell return the signed cell incident to sc along axis k either with greater coordinate (b is true) or lesser
Lower incident cells x.uLowerIncident(c) Cells return all the cells just lower incident to c (1-dim less)
Lower incident cells x.sLowerIncident(sc) SCells return all the signed cells just lower incident to sc (1-dim less)
Upper incident cells x.uUpperIncident(c) Cells return all the cells just upper incident to c (1-dim more)
Upper incident cells x.sUpperIncident(sc) SCells return all the signed cells just upper incident to c (1-dim more)
Faces of a cell x.uFaces(c) Cells return all the faces of the cell c
Co-Faces of a cell x.uCoFaces(c) Cells return all the co-faces of the cell c
Direct orientation x.sDirect(sc,k) bool return the direct orientation of cell sc along axis k
Direct incident cell x.sDirectIncident(sc,k) SCell return the signed cell that is the direct incident cell to sc along axis k
Indirect incident cell x.sIndirectIncident(sc,k) SCell return the signed cell that is the indirect incident cell to sc along axis k
Interior voxel x.interiorVoxel(sc ) Point sc must be a (n-1)-scell return the interior voxel of a signed surfel
Exterior voxel x.exteriorVoxel(sc) Point sc must be a (n-1)-scell return the exterior voxel of a signed surfel

Invariants

Models

Notes

Template Parameters
Tthe type that should be a model of CPreCellularGridSpaceND.

Definition at line 285 of file CPreCellularGridSpaceND.h.

Member Typedef Documentation

◆ Cell

template<typename T >
typedef T::Cell DGtal::concepts::CPreCellularGridSpaceND< T >::Cell

Definition at line 293 of file CPreCellularGridSpaceND.h.

◆ CellMap

template<typename T >
typedef T::template CellMap<Dummy>::Type DGtal::concepts::CPreCellularGridSpaceND< T >::CellMap

Definition at line 306 of file CPreCellularGridSpaceND.h.

◆ Cells

template<typename T >
typedef T::Cells DGtal::concepts::CPreCellularGridSpaceND< T >::Cells

Definition at line 300 of file CPreCellularGridSpaceND.h.

◆ CellSet

template<typename T >
typedef T::CellSet DGtal::concepts::CPreCellularGridSpaceND< T >::CellSet

Definition at line 302 of file CPreCellularGridSpaceND.h.

◆ DirIterator

template<typename T >
typedef T::DirIterator DGtal::concepts::CPreCellularGridSpaceND< T >::DirIterator

Definition at line 297 of file CPreCellularGridSpaceND.h.

◆ Dummy

template<typename T >
typedef int DGtal::concepts::CPreCellularGridSpaceND< T >::Dummy

Definition at line 305 of file CPreCellularGridSpaceND.h.

◆ Integer

template<typename T >
typedef T::Integer DGtal::concepts::CPreCellularGridSpaceND< T >::Integer

Definition at line 290 of file CPreCellularGridSpaceND.h.

◆ Point

template<typename T >
typedef T::Point DGtal::concepts::CPreCellularGridSpaceND< T >::Point

Definition at line 298 of file CPreCellularGridSpaceND.h.

◆ PreCellularGridSpace

template<typename T >
typedef T::PreCellularGridSpace DGtal::concepts::CPreCellularGridSpaceND< T >::PreCellularGridSpace

Definition at line 292 of file CPreCellularGridSpaceND.h.

◆ SCell

template<typename T >
typedef T::SCell DGtal::concepts::CPreCellularGridSpaceND< T >::SCell

Definition at line 294 of file CPreCellularGridSpaceND.h.

◆ SCellMap

template<typename T >
typedef T::template SCellMap<Dummy>::Type DGtal::concepts::CPreCellularGridSpaceND< T >::SCellMap

Definition at line 307 of file CPreCellularGridSpaceND.h.

◆ SCells

template<typename T >
typedef T::SCells DGtal::concepts::CPreCellularGridSpaceND< T >::SCells

Definition at line 301 of file CPreCellularGridSpaceND.h.

◆ SCellSet

template<typename T >
typedef T::SCellSet DGtal::concepts::CPreCellularGridSpaceND< T >::SCellSet

Definition at line 303 of file CPreCellularGridSpaceND.h.

◆ Sign

template<typename T >
typedef T::Sign DGtal::concepts::CPreCellularGridSpaceND< T >::Sign

Definition at line 296 of file CPreCellularGridSpaceND.h.

◆ Space

template<typename T >
typedef T::Space DGtal::concepts::CPreCellularGridSpaceND< T >::Space

Definition at line 291 of file CPreCellularGridSpaceND.h.

◆ Surfel

template<typename T >
typedef T::Surfel DGtal::concepts::CPreCellularGridSpaceND< T >::Surfel

Definition at line 295 of file CPreCellularGridSpaceND.h.

◆ SurfelMap

template<typename T >
typedef T::template SurfelMap<Dummy>::Type DGtal::concepts::CPreCellularGridSpaceND< T >::SurfelMap

Definition at line 308 of file CPreCellularGridSpaceND.h.

◆ SurfelSet

template<typename T >
typedef T::SurfelSet DGtal::concepts::CPreCellularGridSpaceND< T >::SurfelSet

Definition at line 304 of file CPreCellularGridSpaceND.h.

◆ Vector

template<typename T >
typedef T::Vector DGtal::concepts::CPreCellularGridSpaceND< T >::Vector

Definition at line 299 of file CPreCellularGridSpaceND.h.

Member Function Documentation

◆ BOOST_CONCEPT_ASSERT() [1/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::PairAssociativeContainer< CellMap >)  )

◆ BOOST_CONCEPT_ASSERT() [2/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::PairAssociativeContainer< SCellMap >)  )

◆ BOOST_CONCEPT_ASSERT() [3/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::PairAssociativeContainer< SurfelMap >)  )

◆ BOOST_CONCEPT_ASSERT() [4/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::SimpleAssociativeContainer< CellSet >)  )

◆ BOOST_CONCEPT_ASSERT() [5/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::SimpleAssociativeContainer< SCellSet >)  )

◆ BOOST_CONCEPT_ASSERT() [6/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::SimpleAssociativeContainer< SurfelSet >)  )

◆ BOOST_CONCEPT_ASSERT() [7/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::UniqueAssociativeContainer< CellMap >)  )

◆ BOOST_CONCEPT_ASSERT() [8/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::UniqueAssociativeContainer< CellSet >)  )

◆ BOOST_CONCEPT_ASSERT() [9/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::UniqueAssociativeContainer< SCellMap >)  )

◆ BOOST_CONCEPT_ASSERT() [10/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::UniqueAssociativeContainer< SCellSet >)  )

◆ BOOST_CONCEPT_ASSERT() [11/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::UniqueAssociativeContainer< SurfelMap >)  )

◆ BOOST_CONCEPT_ASSERT() [12/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (boost::UniqueAssociativeContainer< SurfelSet >)  )

◆ BOOST_CONCEPT_ASSERT() [13/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (CConstSinglePassRange< Cells >)  )

◆ BOOST_CONCEPT_ASSERT() [14/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (CConstSinglePassRange< SCells >)  )

◆ BOOST_CONCEPT_ASSERT() [15/15]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_ASSERT ( (CInteger< Integer >)  )

◆ BOOST_CONCEPT_USAGE()

◆ BOOST_STATIC_ASSERT() [1/3]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_STATIC_ASSERT ( (ConceptUtils::SameType< Integer, typename Space::Integer >::value)  )

◆ BOOST_STATIC_ASSERT() [2/3]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_STATIC_ASSERT ( (ConceptUtils::SameType< Point, typename Space::Point >::value)  )

◆ BOOST_STATIC_ASSERT() [3/3]

template<typename T >
DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_STATIC_ASSERT ( (ConceptUtils::SameType< Vector, typename Space::Vector >::value)  )

◆ checkConstConstraints()

template<typename T >
void DGtal::concepts::CPreCellularGridSpaceND< T >::checkConstConstraints ( ) const
inline

Definition at line 337 of file CPreCellularGridSpaceND.h.

338  {
339  ConceptUtils::sameType( myCell, myX.uCell( myP1 ) );
341  ConceptUtils::sameType( mySCell, myX.sCell( myP1 ) );
344  ConceptUtils::sameType( myCell, myX.uSpel( myP1 ) );
345  ConceptUtils::sameType( mySCell, myX.sSpel( myP1 ) );
347  ConceptUtils::sameType( myCell, myX.uPointel( myP1 ) );
348  ConceptUtils::sameType( mySCell, myX.sPointel( myP1 ) );
349  ConceptUtils::sameType( mySCell, myX.sPointel( myP1, myBool ) );
352  ConceptUtils::sameType( myP1, myX.uKCoords( myCell ) );
353  ConceptUtils::sameType( myP1, myX.uCoords( myCell ) );
356  ConceptUtils::sameType( myP1, myX.sKCoords( mySCell ) );
357  ConceptUtils::sameType( myP1, myX.sCoords( mySCell ) );
358  myX.uSetKCoord( myMutableCell, myDim, myInteger );
359  myX.uSetCoord( myMutableCell, myDim, myInteger );
360  myX.uSetKCoords( myMutableCell, myP1 );
361  myX.uSetCoords( myMutableCell, myP1 );
362  myX.sSetKCoord( myMutableSCell, myDim, myInteger );
363  myX.sSetCoord( myMutableSCell, myDim, myInteger );
364  myX.sSetKCoords( myMutableSCell, myP1 );
365  myX.sSetCoords( myMutableSCell, myP1 );
367  myX.sSetSign( myMutableSCell, mySign );
370  ConceptUtils::sameType( myCell, myX.unsigns( mySCell ) );
371  ConceptUtils::sameType( myInteger, myX.uTopology( myCell ) );
372  ConceptUtils::sameType( myInteger, myX.sTopology( mySCell ) );
375  ConceptUtils::sameType( myBool, myX.uIsSurfel( myCell ) );
376  ConceptUtils::sameType( myBool, myX.sIsSurfel( mySCell ) );
377  ConceptUtils::sameType( myBool, myX.uIsOpen( myCell, myDim ) );
381  ConceptUtils::sameType( myDirIt, myX.uOrthDirs( myCell ) );
382  ConceptUtils::sameType( myDirIt, myX.sOrthDirs( mySCell ) );
383  ConceptUtils::sameType( myDim, myX.uOrthDir( myCell ) );
384  ConceptUtils::sameType( myDim, myX.sOrthDir( mySCell ) );
385  // -------------------- Unsigned cell geometry services --------------------
386  ConceptUtils::sameType( myCell, myX.uGetIncr( myCell, myDim ) );
387  ConceptUtils::sameType( myCell, myX.uGetDecr( myCell, myDim ) );
390  ConceptUtils::sameType( myBool, myX.uIsInside( myCell, myDim ) );
393  ConceptUtils::sameType( myCell, myX.uTranslation( myCell, myV ) );
394  ConceptUtils::sameType( myCell, myX.uProjection( myCell, myCell, myDim ) );
395  myX.uProject( myMutableCell, myCell, myDim );
397  // -------------------- Signed cell geometry services --------------------
402  ConceptUtils::sameType( myBool, myX.sIsInside( mySCell, myDim ) );
405  ConceptUtils::sameType( mySCell, myX.sTranslation( mySCell, myV ) );
406  ConceptUtils::sameType( mySCell, myX.sProjection( mySCell, mySCell, myDim ) );
407  myX.sProject( myMutableSCell, mySCell, myDim );
409  // ----------------------- Neighborhood services --------------------------
410  ConceptUtils::sameType( myCells, myX.uNeighborhood( myCell ) );
411  ConceptUtils::sameType( myCells, myX.uProperNeighborhood( myCell ) );
412  ConceptUtils::sameType( mySCells, myX.sNeighborhood( mySCell ) );
413  ConceptUtils::sameType( mySCells, myX.sProperNeighborhood( mySCell ) );
414  ConceptUtils::sameType( myCell, myX.uAdjacent( myCell, myDim, myBool ) );
416  // ----------------------- Incidence services --------------------------
417  ConceptUtils::sameType( myCell, myX.uIncident( myCell, myDim, myBool ) );
419  ConceptUtils::sameType( myCells, myX.uLowerIncident( myCell ) );
420  ConceptUtils::sameType( myCells, myX.uUpperIncident( myCell ) );
421  ConceptUtils::sameType( mySCells, myX.sLowerIncident( mySCell ) );
422  ConceptUtils::sameType( mySCells, myX.sUpperIncident( mySCell ) );
424  ConceptUtils::sameType( myCells, myX.uCoFaces( myCell ) );
426  ConceptUtils::sameType( mySCell, myX.sDirectIncident( mySCell, myDim ) );
427  ConceptUtils::sameType( mySCell, myX.sIndirectIncident( mySCell, myDim ) );
428  ConceptUtils::sameType( mySCell, myX.sIndirectIncident( mySCell, myDim ) );
429  ConceptUtils::sameType( myP1, myX.interiorVoxel( mySCell) );
430  ConceptUtils::sameType( myP1, myX.exteriorVoxel( mySCell) );
431 
432 }

References DGtal::concepts::CPreCellularGridSpaceND< T >::myBool, DGtal::concepts::CPreCellularGridSpaceND< T >::myCell, DGtal::concepts::CPreCellularGridSpaceND< T >::myCells, DGtal::concepts::CPreCellularGridSpaceND< T >::myDim, DGtal::concepts::CPreCellularGridSpaceND< T >::myDirIt, DGtal::concepts::CPreCellularGridSpaceND< T >::myInteger, DGtal::concepts::CPreCellularGridSpaceND< T >::myMutableCell, DGtal::concepts::CPreCellularGridSpaceND< T >::myMutableSCell, DGtal::concepts::CPreCellularGridSpaceND< T >::myP1, DGtal::concepts::CPreCellularGridSpaceND< T >::mySCell, DGtal::concepts::CPreCellularGridSpaceND< T >::mySCells, DGtal::concepts::CPreCellularGridSpaceND< T >::mySign, DGtal::concepts::CPreCellularGridSpaceND< T >::myV, DGtal::concepts::CPreCellularGridSpaceND< T >::myX, and DGtal::concepts::ConceptUtils::sameType().

Referenced by DGtal::concepts::CPreCellularGridSpaceND< T >::BOOST_CONCEPT_USAGE().

Field Documentation

◆ myBool

template<typename T >
bool DGtal::concepts::CPreCellularGridSpaceND< T >::myBool
private

◆ myCell

◆ myCells

◆ myDim

◆ myDirIt

◆ myInteger

◆ myMutableCell

template<typename T >
Cell DGtal::concepts::CPreCellularGridSpaceND< T >::myMutableCell
mutableprivate

◆ myMutableSCell

template<typename T >
SCell DGtal::concepts::CPreCellularGridSpaceND< T >::myMutableSCell
mutableprivate

◆ myP1

◆ myP2

template<typename T >
Point DGtal::concepts::CPreCellularGridSpaceND< T >::myP2
private

Definition at line 438 of file CPreCellularGridSpaceND.h.

◆ mySCell

◆ mySCells

◆ mySign

◆ myV

◆ myX


The documentation for this struct was generated from the following file: