DGtal 1.4.0

►Nboost  
CAdaptableBinaryFunction  Go to http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html 
CAdaptableBinaryPredicate  Go to http://www.sgi.com/tech/stl/AdaptableBinaryPredicate.html 
CAdaptableGenerator  Go to http://www.sgi.com/tech/stl/AdaptableGenerator.html 
CAdaptablePredicate  Go to http://www.sgi.com/tech/stl/AdaptablePredicate.html 
CAdaptableUnaryFunction  Go to http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html 
CAdjacencyGraphConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/AdjacencyGraph.html 
CAssignable  Go to http://www.sgi.com/tech/stl/Assignable.html 
CAssociativeContainer  Go to http://www.sgi.com/tech/stl/AssociativeContainer.html 
CBackInsertionSequence  Go to http://www.sgi.com/tech/stl/BackInsertionSequence.html 
CBidirectionalIterator  Go to http://www.sgi.com/tech/stl/BidirectionalIterator.html 
CBinaryFunction  Go to http://www.sgi.com/tech/stl/BinaryFunction.html 
CBinaryPredicate  Go to http://www.sgi.com/tech/stl/BinaryPredicate.html 
CCollection  Go to http://www.sgi.com/tech/stl/Collection.html 
CConst_BinaryPredicate  Go to http://www.boost.org/libs/concept_check/reference.htm 
CContainer  Go to http://www.sgi.com/tech/stl/Container.html 
CConvertible  Go to http://www.boost.org/libs/concept_check/reference.htm 
CCopyConstructible  Go to http://www.sgi.com/tech/stl/CopyConstructible.html 
CDefaultConstructible  Go to http://www.sgi.com/tech/stl/DefaultConstructible.html 
CDigitalSurface_graph_traversal_category  
CEdgeListGraphConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/EdgeListGraph.html 
CEqualityComparable  Go to http://www.sgi.com/tech/stl/EqualityComparable.html 
CForwardContainer  Go to http://www.sgi.com/tech/stl/ForwardContainer.html 
CForwardIterator  Go to http://www.sgi.com/tech/stl/ForwardIterator.html 
CFrontInsertionSequence  Go to http://www.sgi.com/tech/stl/FrontInsertionSequence.html 
CGenerator  Go to http://www.sgi.com/tech/stl/Generator.html 
►Cgraph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >  
Cadjacency_iterator  
Cedge_iterator  
Cout_edge_iterator  
►Cgraph_traits< DGtal::Object< TDigitalTopology, TDigitalSet > >  
Cadjacency_iterator  
Cedge_iterator  
Cout_edge_iterator  
CGraphConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/Graph.html 
Chash< DGtal::BigInteger >  
Chash< DGtal::KhalimskyCell< dim, TInteger > >  Extend boost namespace to define a boost::hash function on DGtal::KhalimskyCell 
Chash< DGtal::SignedKhalimskyCell< dim, TInteger > >  Extend boost namespace to define a boost::hash function on DGtal::SignedKhalimskyCell 
CIncidenceGraphConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/IncidenceGraph.html 
CInputIterator  Go to http://www.sgi.com/tech/stl/InputIterator.html 
CInteger  Go to http://www.boost.org/libs/concept_check/reference.htm 
Cis_integral  Go to http://www.boost.org/doc/libs/1_52_0/libs/type_traits/doc/html/index.html 
Cis_unsigned  Go to http://www.boost.org/doc/libs/1_52_0/libs/type_traits/doc/html/index.html 
CLessThanComparable  Go to http://www.sgi.com/tech/stl/LessThanComparable.html 
CMultiPassInputIterator  Go to http://www.boost.org/doc/libs/1_52_0/libs/utility/MultiPassInputIterator.html 
CMultipleAssociativeContainer  Go to http://www.sgi.com/tech/stl/MultipleAssociativeContainer.html 
CMutable_BidirectionalIterator  Go to http://www.boost.org/libs/concept_check/reference.htm 
CMutable_Container  Go to http://www.boost.org/libs/concept_check/reference.htm 
CMutable_ForwardContainer  Go to http://www.boost.org/libs/concept_check/reference.htm 
CMutable_ForwardIterator  Go to http://www.boost.org/libs/concept_check/reference.htm 
CMutable_RandomAccessContainer  Go to http://www.boost.org/libs/concept_check/reference.htm 
CMutable_RandomAccessIterator  Go to http://www.boost.org/libs/concept_check/reference.htm 
CMutable_ReversibleContainer  Go to http://www.boost.org/libs/concept_check/reference.htm 
CObject_graph_traversal_category  
COutputIterator  Go to http://www.sgi.com/tech/stl/OutputIterator.html 
CPairAssociativeContainer  Go to http://www.sgi.com/tech/stl/PairAssociativeContainer.html 
CRandomAccessContainer  Go to http://www.sgi.com/tech/stl/RandomAccessContainer.html 
CRandomAccessIterator  Go to http://www.sgi.com/tech/stl/RandomAccessIterator.html 
CReversibleContainer  Go to http://www.sgi.com/tech/stl/ReversibleContainer.html 
CSequence  Go to http://www.sgi.com/tech/stl/Sequence.html 
CSGIAssignable  Go to http://www.boost.org/libs/concept_check/reference.htm 
CSignedInteger  Go to http://www.sgi.com/tech/stl/SignedInteger.html 
CSimpleAssociativeContainer  Go to http://www.sgi.com/tech/stl/SimpleAssociativeContainer.html 
CSortedAssociativeContainer  Go to http://www.sgi.com/tech/stl/SortedAssociativeContainer.html 
CUnaryFunction  Go to http://www.sgi.com/tech/stl/UnaryFunction.html 
CUnaryPredicate  Go to http://www.sgi.com/tech/stl/Predicate.html 
CUniqueAssociativeContainer  Go to http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html 
CUnsignedInteger  Go to http://www.boost.org/libs/concept_check/reference.htm 
CVertexListGraphConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/VertexListGraph.html 
►Nboost_concepts  
CBidirectionalTraversalConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/BidirectionalTraversal.html 
CForwardTraversalConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/ForwardTraversal.html 
CIncrementableIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/IncrementableIterator.html 
CInteroperableIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/InteroperableIterator.html 
CLvalueIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/LvalueIteratorConcept.html 
CRandomAccessTraversalConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/RandomAccessTraversal.html 
CReadableIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/ReadableIterator.html 
CSinglePassIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/SinglePassIterator.html 
CSwappableIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/SwappableIterator.html 
CWritableIteratorConcept  Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/WritableIterator.html 
►NDGtal  DGtal is the toplevel namespace which contains all DGtal functions and types 
►Nconcepts  Aim: Gathers several functions useful for concept checks 
►NConceptUtils  
CCheckFalse  
CCheckTag  
CCheckTrue  
CCheckTrue< TagTrue >  
CCheckTrueOrFalse  
CCheckUnknown  
CCheckUnknown< TagUnknown >  
CSameType  
CSameType< T, T >  
CBoard3DTo2D  Aim: The concept CDrawableWithBoard3DTo2D specifies what are the classes that admit an export with Board3DTo2D 
CC3DParametricCurve  Aim: 
CC3DParametricCurveDecorator  Aim: 
CCAdditivePrimitiveComputer  Aim: Defines the concept describing an object that computes some primitive from input points given group by group, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes 
CCAdjacency  Aim: The concept CAdjacency defines an elementary adjacency relation between points of a digital space 
CCBackInsertable  Aim: Represents types for which a std::back_insert_iterator can be constructed with std::back_inserter. Back Insertion Sequence are refinements of CBackInsertable. They require more services than CBackInsertable, for instance read services or erase services 
CCBidirectionalRange  Aim: Defines the concept describing a bidirectional range 
CCBidirectionalRangeFromPoint  Aim: refined concept of single pass range with a begin() method from a point 
CCBidirectionalRangeWithWritableIterator  Aim: refined concept of bidirectional range which require that a reverse output iterator exists 
CCBidirectionalRangeWithWritableIteratorFromPoint  Aim: refined concept of single pass range with an routputIterator() method from a point 
CCBidirectionalSegmentComputer  Aim: Defines the concept describing a bidirectional segment computer, ie. a model of concepts::CSegment that can extend itself in the two possible directions 
CCBinner  Aim: Represents an object that places a quantity into a bin, i.e. a functor that associates a natural integer to a continuous value 
CCBoundedNumber  Aim: The concept CBoundedNumber specifies what are the bounded numbers. Models of this concept should be listed in NumberTraits class and should have the isBounded property 
CCCellEmbedder  Aim: A cell embedder is a mapping from unsigned cells to Euclidean points. It adds inner types to functor 
CCCellFunctor  Aim: Defines a functor on cells 
CCCellularGridSpaceND  Aim: This concept describes a cellular grid space in nD. In these spaces obtained by cartesian product, cells have a cubic shape that depends on the dimension: 0cells are points, 1cells are unit segments, 2cells are squares, 3cells are cubes, and so on 
CCColorMap  Aim: Defines the concept describing a color map. A color map converts a value within a given range into an RGB triple 
CCCommutativeRing  Aim: Defines the mathematical concept equivalent to a unitary commutative ring 
CCConstBidirectionalRange  Aim: Defines the concept describing a bidirectional const range 
CCConstBidirectionalRangeFromPoint  Aim: refined concept of const bidirectional range with a begin() method from a point 
CCConstImage  Aim: Defines the concept describing a readonly image, which is a refinement of CPointFunctor 
CCConstSinglePassRange  Aim: Defines the concept describing a const single pass range 
CCConstSinglePassRangeFromPoint  Aim: refined concept of const single pass range with a begin() method from a point 
CCCurveLocalGeometricEstimator  Aim: This concept describes an object that can process a range so as to return one estimated quantity for each element of the range (or a given subrange) 
CCDenseMatrix  Aim: Represent any dynamic or static sized matrix having dense representation 
CCDenseVector  Aim: Represent any dynamic or static sized matrix having dense representation 
CCDigitalBoundedShape  Aim: designs the concept of bounded shapes in DGtal (shape for which upper and lower bounding bounds are available) 
CCDigitalMetricSpace  Aim: defines the concept of digital metric spaces 
CCDigitalOrientedShape  Aim: characterizes models of digital oriented shapes. For example, models should provide an orientation method for points on a SpaceND. Returned value type corresponds to DGtal::Orientation 
CCDigitalSet  Aim: Represents a set of points within the given domain. This set of points is modifiable by the user. It is thus very close to the STL concept of simple associative container (like set std::set<Point>), except that there is a notion of maximal set of points (the whole domain) 
CCDigitalSetArchetype  Aim: The archetype of a container class for storing sets of digital points within some given domain 
CCDigitalSurfaceContainer  Aim: The digital surface container concept describes a minimal set of inner types and methods so as to describe the data of digital surfaces 
CCDigitalSurfaceEmbedder  Aim: A digital surface embedder is a specialized mapping from signed cells to Euclidean points. It adds inner types to functor as well as a method to access the digital surface 
CCDigitalSurfaceLocalEstimator  Aim: This concept describes an object that can process a range over some generic digital surface so as to return one estimated quantity for each element of the range (or a given subrange) 
CCDigitalSurfaceTracker  Aim: 
CCDiscreteExteriorCalculusVectorSpace  Aim: Lift linear algebra container concept into the dec package 
CCDomain  Aim: This concept represents a digital domain, i.e. a non mutable subset of points of the given digital space 
CCDomainAdjacency  Aim: Refines the concept CAdjacency by telling that the adjacency is specific to a given domain of the embedding digital space 
CCDomainArchetype  Aim: The archetype of a class that represents a digital domain, i.e. a non mutable subset of points of the given digital space 
CCDrawableWithBoard2D  Aim: The concept CDrawableWithBoard2D specifies what are the classes that admit an export with Board2D 
CCDrawableWithBoard3DTo2D  
CCDrawableWithDisplay3D  
CCDrawableWithViewer3D  Aim: The concept CDrawableWithViewer3D specifies what are the classes that admit an export with Viewer3D 
CCDynamicBidirectionalSegmentComputer  Aim: Defines the concept describing a dynamic and bidirectional segment computer, ie. a model of concepts::CSegment that can extend and retract itself in either direction 
CCDynamicMatrix  Aim: Represent any dynamic sized matrix having sparse or dense representation 
CCDynamicSegmentComputer  Aim: Defines the concept describing a dynamic segment computer, ie. a model of CSegment that can extend and retract itself (in the direction that is relative to the underlying iterator). 
CCDynamicVector  Aim: Represent any dynamic sized column vector having sparse or dense representation 
CCEuclideanBoundedShape  
CCEuclideanOrientedShape  Aim: characterizes models of digital oriented shapes. For example, models should provide an orientation method for real points. Returned value type corresponds to DGtal::Orientation 
CCEuclideanRing  Aim: Defines the mathematical concept equivalent to a unitary commutative ring with a division operator 
CCForwardSegmentComputer  Aim: Defines the concept describing a forward segment computer. Like any model of CIncrementalSegmentComputer, it can control its own extension (in the direction that is relative to the underlying iterator) so that an implicit predicate P remains true. However, contrary to models of CIncrementalSegmentComputer, it garantees that P is also true for any subrange of the whole segment at any time. This extra constraint is necessary to be able to incrementally check whether or not the segment is maximal 
CCGlobalGeometricEstimator  Aim: This concept describes an object that can process a range so as to return one estimated quantity for the whole range 
CCGraphVisitor  Aim: Defines the concept of a visitor onto a graph, that is an object that traverses vertices of the graph according to some order. The user can either use the visitor as is, or even constrain the traversal with a given predicate 
CCImage  Aim: Defines the concept describing a read/write image, having an output iterator 
CCImageCacheReadPolicy  Aim: Defines the concept describing a cache read policy 
CCImageCacheWritePolicy  Aim: Defines the concept describing a cache write policy 
CCImageFactory  Aim: Defines the concept describing an image factory 
CCImplicitFunction  Aim: Describes any function of the form f(x), where x is some real point in the given space, and f(x) is some value 
CCImplicitFunctionDiff1  Aim: Describes a 1differentiable function of the form f(x), where x is some real point in the given space, and f(x) is some value 
CCIncrementalPrimitiveComputer  Aim: Defines the concept describing an object that computes some primitive from input points given one at a time, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes 
CCIncrementalSegmentComputer  Aim: Defines the concept describing an incremental segment computer, ie. a model of CSegmentFactory that can, in addition, incrementally check whether or not an implicit predicate P is true. In other words, it can control its own extension from a range of one element (in the direction that is relative to the underlying iterator) so that an implicit predicate P remains true. 
CCInteger  Aim: Concept checking for Integer Numbers. More precisely, this concept is a refinement of both CEuclideanRing and CIntegralNumber 
CCIntegralNumber  Aim: Concept checking for Integral Numbers. Models of this concept should be listed in NumberTraits class and should have the isIntegral property 
CCLabel  Aim: Define the concept of DGtal labels. Models of CLabel can be defaultconstructible, assignable and equality comparable 
CCLinearAlgebra  Aim: Check right multiplication between matrix and vector and internal matrix multiplication. Matrix and vector scalar types should be the same 
CCLinearAlgebraSolver  Aim: Describe a linear solver defined over a linear algebra. Problems are of the form: 
CCLMSTDSSFilter  Aim: Defines the concept describing a functor which filters DSSes for LMST calculations 
CCLMSTTangentFromDSS  Aim: Defines the concept describing a functor which calculates a direction of the 2D DSS and an eccentricity [72] of a given point in this DSS 
CCLocalEstimatorFromSurfelFunctor  Aim: this concept describes functors on digtal surface surfel which can be used to define local estimator using the adapter LocalEstimatorFromSurfelFunctorAdapter 
CCMatrix  Aim: Represent any static or dynamic sized matrix having sparse or dense representation 
CCMetricSpace  Aim: defines the concept of metric spaces 
CCNormalVectorEstimator  Aim: Represents the concept of estimator of normal vector along digital surfaces 
CCOrientationFunctor  Aim: This concept gathers models implementing an orientation test of \( k+1 \) points in a space of dimension \( n \) 
CCOrientationFunctor2  Aim: This concept is a refinement of COrientationFunctor, useful for simple algebraic curves that can be uniquely defined by only two points. 
CCPointEmbedder  Aim: A point embedder is a mapping from digital points to Euclidean points. It adds inner types to functor 
CCPointFunctor  Aim: Defines a functor on points 
CCPointPredicate  Aim: Defines a predicate on a point 
CCPolarPointComparator2D  Aim: This concept gathers classes that are able to compare the position of two given points \( P, Q \) around a pole \( O \). More precisely, they compare the oriented angles lying between the horizontal line passing by \( O \) and the rays \( [OP) \) and \( [OQ) \) (in a counterclockwise orientation). This is equivalent to compare the angle in radians from 0 (included) to 2 π (excluded) 
CCPositiveIrreducibleFraction  Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q nonnegative integers, with gcd(p,q)=1 
CCPowerMetric  Aim: defines the concept of special weighted metrics, so called power metrics 
CCPowerSeparableMetric  Aim: defines the concept of separable metrics 
CCPreCellularGridSpaceND  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: 0cells are points, 1cells are unit segments, 2cells are squares, 3cells are cubes, and so on 
CCPredicate  Aim: Defines a predicate function, ie. a functor mapping a domain into the set of booleans 
CCPrimitiveComputer  Aim: Defines the concept describing an object that computes some primitive from input points, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes 
CCQuantity  Aim: defines the concept of quantity in DGtal 
CCSCellEmbedder  Aim: A cell embedder is a mapping from signed cells to Euclidean points. It adds inner types to functor 
CCSegment  Aim: Defines the concept describing a segment, ie. a valid and not empty range 
CCSegmentComputerEstimator  Aim: This concept is a refinement of CCurveLocalGeometricEstimator devoted to the estimation of a geometric quantiy along a segment detected by a segment computer 
CCSegmentFactory  Aim: Defines the concept describing a segment ie. a valid and not empty subrange, which can construct instances of its own type or of derived type 
CCSeparableMetric  Aim: defines the concept of separable metrics 
CCSignedNumber  Aim: Concept checking for Signed Numbers. Models of this concept should be listed in NumberTraits class and should have the isSigned property 
CCSinglePassRange  Aim: Defines the concept describing a range 
CCSinglePassRangeFromPoint  Aim: refined concept of single pass range with a begin() method from a point 
CCSinglePassRangeWithWritableIterator  Aim: refined concept of const single pass range which require that an output iterator exists 
CCSinglePassRangeWithWritableIteratorFromPoint  Aim: refined concept of single pass range with a outputIterator() method from a point 
CCSpace  Aim: Defines the concept describing a digital space, ie a cartesian product of integer lines 
CCSparseMatrix  Aim: Represent any dynamic or static sized matrix having sparse representation 
CCStack  Aim: This concept gathers classes that provide a stack interface 
CCStaticMatrix  Aim: Represent any static sized matrix having sparse or dense representation 
CCStaticVector  Aim: Represent any static sized column vector having sparse or dense representation 
CCSTLAssociativeContainer  Aim: Defines the concept describing an Associative Container of the STL (https://www.sgi.com/tech/stl/AssociativeContainer.html) 
CCSurfelLocalEstimator  Aim: This concept describes an object that can process a range of surfels (that are supposed to belong to some (abstract) surface) so as to return one estimated quantity for each element of the range (or a given subrange) 
CCSurfelPredicate  Aim: Defines a predicate on a surfel 
CCTrivialConstImage  Aim: Defines the concept describing a readonly image, which is a refinement of CPointFunctor 
CCTrivialImage  Aim: Defines the concept describing an image without extra ranges, which is a refinement of CTrivialConstImage 
CCUnaryFunctor  Aim: Defines a unary functor, which associates arguments to results 
CCUnaryFunctor< X, A &, R & >  
CCUndirectedSimpleGraph  Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices 
►CCUndirectedSimpleLocalGraph  Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices 
CVertexMap  
CCUnsignedNumber  Aim: Concept checking for Unsigned numbers. Models of this concept should be listed in NumberTraits class and should have the isUnsigned property 
CCVector  Aim: Represent any static or dynamic sized column vector having sparse or dense representation 
CCVectorSpace  Aim: Base concept for vector space structure 
CCVertexMap  Aim: models of CVertexMap concept implement mapping between graph vertices and values 
CCVertexPredicate  Aim: Defines a predicate on a vertex 
CCVertexPredicateArchetype  Aim: Defines a an archetype for concept CVertexPredicate 
CCWithGradientMap  Aim: Such object provides a gradient map that associates to each argument some real vector 
CDisplay3D  Aim: The concept CDrawableWithDisplay3D specifies what are the classes that admit an export with Display3D 
Ndec_helper  Namespace for functions useful to Discrete Exterior Calculus package 
►Ndeprecated  Deprecated functions and types of the DGtal library 
►Nconcepts  
CCConvolutionWeights  Aim: defines models of centered convolution kernel used for normal vector integration for instance 
CConstantConvolutionWeights  Aim: implement a trivial constant convolution kernel which returns 1 to each distance 
CDigitalShapesIntersection  Aim: Intersection between two models of CDigitalBoundedShape and CDigitalOrientedShape 
CDigitalShapesMinus  Aim: Minus between two models of CDigitalBoundedShape and CDigitalOrientedShape 
CDigitalShapesUnion  Aim: Union between two models of CDigitalBoundedShape and CDigitalOrientedShape 
CDomainMetricAdjacency  Aim: Describes digital adjacencies in a digital domain that are defined with the 1norm and the infinitynorm 
CEuclideanShapesIntersection  Aim: Intersection between two models of CEuclideanBoundedShape and CEuclideanOrientedShape 
CEuclideanShapesMinus  Aim: Minus between two models of CEuclideanBoundedShape and CEuclideanOrientedShape 
CEuclideanShapesUnion  Aim: Union between two models of CEuclideanBoundedShape and CEuclideanOrientedShape 
CGaussianConvolutionWeights  Aim: implement a Gaussian centered convolution kernel 
►CIntegralInvariantNormalVectorEstimator  Aim: This class implement an Integral Invariant normal vector estimator 
CCovarianceMatrix2NormalDirectionFunctor  
CLocalConvolutionNormalVectorEstimator  Aim: Computes the normal vector at a surface element by convolution of elementary normal vector to adjacent surfel 
CSetPredicate  Aim: The predicate returning true iff the point is in the set given at construction. The set given at construction is aliased in the predicate and not cloned, which means that the lifetime of the set should exceed the lifetime of the predicate 
►Ndetail  detail namespace gathers internal classes and functions 
CBoundedLatticePolytopeSpecializer  Aim: It is just a helper class for BoundedLatticePolytope to add dimension specific static methods 
CBoundedLatticePolytopeSpecializer< 3, TInteger >  Aim: 3D specialization for BoundedLatticePolytope to add dimension specific static methods 
CBoundedRationalPolytopeSpecializer  Aim: It is just a helper class for BoundedRationalPolytope to add dimension specific static methods 
CBoundedRationalPolytopeSpecializer< 3, TInteger >  Aim: 3D specialization for BoundedRationalPolytope to add dimension specific static methods 
CComparatorAdapter  
CComparatorAdapter< Container, true, false, false >  Unordered setlike adapter 
CComparatorAdapter< Container, true, false, true >  Unordered maplike adapter 
CComparatorAdapter< Container, true, true, false >  Setlike adapter 
CComparatorAdapter< Container, true, true, true >  Maplike adapter 
CConvexityHelperInternalInteger  
CConvexityHelperInternalInteger< DGtal::BigInteger, safe >  
CConvexityHelperInternalInteger< DGtal::int32_t, false >  
CConvexityHelperInternalInteger< DGtal::int32_t, true >  
CConvexityHelperInternalInteger< DGtal::int64_t, false >  
CConvexityHelperInternalInteger< DGtal::int64_t, true >  
CCurvatureFromDCA  
CCurvatureFromDCA< false >  
CCurvatureFromDSSBaseEstimator  
CCurvatureFromDSSLength  
CCurvatureFromDSSLengthAndWidth  
CDistanceFromDCA  
CDSSDecorator  Aim: Abstract DSSDecorator for ArithmeticalDSSComputer. Has 2 virtual methods returning the first and last leaning point: 
CDSSDecorator4ConcavePart  Aim: adapter for TDSS used by FP in CONCAVE parts. Has 2 methods: 
CDSSDecorator4ConvexPart  Aim: adapter for TDSS used by FP in CONVEX parts. Has 2 methods: 
CEqualPredicateFromLessThanComparator  
CEuclideanDivisionHelper  Aim: Small stucture that provides a static method returning the Euclidean division of two integers 
CEuclideanDivisionHelper< double >  
CEuclideanDivisionHelper< float >  
CEuclideanDivisionHelper< long double >  
CFFTWComplexCast  Facility to cast to the complex type used by fftw 
CFFTWWrapper  Wrapper to fftw functions depending on value type 
CFFTWWrapper< double >  
CFFTWWrapper< float >  
CFFTWWrapper< long double >  
CHasNestedTypeCategory  Aim: Checks whether type T has a nested type called 'Category' or not. NB: from en.wikipedia.org/wiki/Substitution_failure_is_not_an_error NB: to avoid various compiler issues, we use BOOST_STATIC_CONSTANT according to http://www.boost.org/development/int_const_guidelines.html 
CHasNestedTypeType  Aim: Checks whether type IC has a nested type called 'Type' or not. NB: from en.wikipedia.org/wiki/Substitution_failure_is_not_an_error NB: to avoid various compiler issues, we use BOOST_STATIC_CONSTANT according to http://www.boost.org/development/int_const_guidelines.html 
CIsAssociativeContainerFromCategory  
CIsCirculator  Aim: Checks whether type IC is a circular or a classical iterator. Static value set to 'true' for a circulator, 'false' otherwise. 1) if type IC has no nested type 'Type', it is a classical iterator and 'false' is returned. 2) if type IC has a nested type 'Type', 'true' is returned is 'Type' is CirculatorType, 'false' otherwise 
CIsCirculator< IC, true >  
CIsCirculatorFromType  Aim: In order to check whether type IC is a circular or a classical iterator, the nested type called 'Type' is read. 
CIsCirculatorFromType< IC, CirculatorType >  
CIsContainerFromCategory  
CIsMultipleAssociativeContainerFromCategory  
CIsOrderedAssociativeContainerFromCategory  
CIsPairAssociativeContainerFromCategory  
CIsSequenceContainerFromCategory  
CIsSimpleAssociativeContainerFromCategory  
CIsUniqueAssociativeContainerFromCategory  
CIsUnorderedAssociativeContainerFromCategory  
CIteratorCirculatorTypeImpl  Aim: Defines the Iterator or Circulator type as a nested type according to the value of b 
CIteratorCirculatorTypeImpl< true >  
CKeyComparatorForPairKeyData  
CLabelledMapMemFunctor  
Cmonomial_node  
CNormalizedTangentVectorFromDSS  
CNormalVectorFromDCA  
CPointOnProbingRay  
CPointValueCompare  Aim: Small binary predicate to order candidates points according to their (absolute) distance value 
CPosDepScaleDepSCEstimator  
CPosDepScaleIndepSCEstimator  
CPosIndepScaleDepSCEstimator  
CPosIndepScaleIndepSCEstimator  
Cpower_node  
CSetFunctionsImpl  Aim: Specialize set operations (union, intersection, difference, symmetric_difference) according to the given type of container. It uses standard algorithms when containers are ordered, otherwise it provides a default implementation 
CSetFunctionsImpl< Container, false, true >  
CSetFunctionsImpl< Container, true, false >  
CSetFunctionsImpl< Container, true, true >  
CTangentAngleFromDSS  
CTangentVectorFromDCA  
CTangentVectorFromDSS  
CtoCoordinateImpl  Aim: Define a simple functor that can cast a signed integer (possibly a DGtal::BigInteger) into another 
CtoCoordinateImpl< DGtal::BigInteger, DGtal::BigInteger >  
CtoCoordinateImpl< DGtal::BigInteger, TOutput >  
Ctop_node  
CValueConverter  Generic definition of a class for converting type X toward type Y 
CValueConverter< std::string, double >  Specialized definitions of a class for converting type X toward type Y 
CValueConverter< std::string, float >  Specialized definitions of a class for converting type X toward type Y 
CValueConverter< std::string, int >  Specialized definitions of a class for converting type X toward type Y 
CValueConverter< X, std::string >  Specialized definitions of a class for converting type X toward type Y 
►Ndetails  
CBoolToTag  Convert a boolean to the corresponding DGtal tag (TagTrue or TagFalse) 
CBoolToTag< false >  
CNumberTraitsImplFundamental  NumberTraits common part for fundamental integer and floatingpoint types 
►Nexperimental  Experimental functions and types of the DGtal library 
►CChamferNorm2D  Aim: implements a model of CSeparableMetric for Chamfer and path based norms 
CLessOrEqThanAngular  
CLessThanAngular  
►CImageContainerByHashTree  Model of CImageContainer implementing the association key<>Value using a hash tree. This class provides a builtin iterator 
CIterator  Builtin iterator on an HashTree. This iterator visits all node in the tree 
CNode  
►Nfunctions  functions namespace gathers all DGtal functionsxs 
NHull2D  Hull2D namespace gathers useful functions to compute and return the convex hull or the alphashape of a range of 2D points 
Nsetops  
►Nfunctors  functors namespace gathers all DGtal functors 
►Ndeprecated  
CSCellToMidPoint  Aim: transforms a scell into a real point (the coordinates are divided by 2) 
►NShapeGeometricFunctors  
CShapeFirstPrincipalCurvatureFunctor  Aim: A functor RealPoint > Quantity that returns the first principal curvature at given point (i.e. smallest principal curvature) 
CShapeFirstPrincipalDirectionFunctor  Aim: A functor RealPoint > RealVector that returns the first principal direction at given point (i.e. direction of smallest principal curvature) 
CShapeGaussianCurvatureFunctor  Aim: A functor RealPoint > Quantity that returns the gaussian curvature at given point 
CShapeMeanCurvatureFunctor  Aim: A functor RealPoint > Quantity that returns the mean curvature at given point 
CShapeNormalVectorFunctor  Aim: A functor RealPoint > Quantity that returns the normal vector at given point 
CShapePositionFunctor  Aim: A functor RealPoint > Quantity that returns the position of the point itself 
CShapePrincipalCurvaturesAndDirectionsFunctor  Aim: A functor RealPoint > (Scalar,Scalar,RealVector,RealVector that returns the principal curvatures and the principal directions as a tuple at given point (k1,k2,d1,d2) 
CShapeSecondPrincipalCurvatureFunctor  Aim: A functor RealPoint > Quantity that returns the second principal curvature at given point (i.e. greatest principal curvature) 
CShapeSecondPrincipalDirectionFunctor  Aim: A functor RealPoint > RealVector that returns the second principal direction at given point (i.e. direction of second/greatest principal curvature) 
CAbs  
CAndBoolFct2  
CBackwardRigidTransformation2D  Aim: implements backward rigid transformation of point in the 2D integer space. Warring: This version uses closest neighbor interpolation 
CBackwardRigidTransformation3D  Aim: implements backward rigid transformation of point in 3D integer space around any arbitrary axis. This implementation uses the Rodrigues' rotation formula. Warring: This version uses closest neighbor interpolation 
CBallConstantFunction  
CBallConstantPointFunction  
CBasicDomainSubSampler  Aim: Functor that subsamples an initial domain by given a grid size and a shift vector. By this way, for a given point considered in a new domain, it allows to recover the point coordinates in the source domain. Such functor can be usefull to apply basic image subsampling in any dimensions by using ImageAdapter class 
CBinaryPointPredicate  Aim: The predicate returns true when the given binary functor returns true for the two PointPredicates given at construction 
CBinaryPointPredicate< TPointPredicate1, TPointPredicate2, AndBoolFct2 >  
CBinaryPointPredicate< TPointPredicate1, TPointPredicate2, OrBoolFct2 >  
CBlueChannel  
CBoundaryPredicate  Aim: The predicate on surfels that represents the frontier between a region and its complementary in an image. It can be used with ExplicitDigitalSurface or LightExplicitDigitalSurface so as to define a digital surface. Such surfaces may of course be open 
CCast  Aim: Define a simple functor using the static cast operator 
CCeil  Functor that rounds up 
CCeil< void >  Functor that rounds up 
CColorRGBEncoder  
CComposer  Aim: Define a new Functor from the composition of two other functors 
CConstantPointPredicate  Aim: The predicate that returns always the same value boolCst 
►CConstImageFunctorHolder  Transform a pointdependent (and possibly domaindependent) functor into a constant image 
CConstRange  Constant range on a ConstImageFunctorHolder 
CConstValue  Aim: Define a simple functor that returns a constant value (0 by default) 
CConstValueCell  Aim: Define a simple functor that returns a constant quantity (0 by default) 
CDomainPredicate  Aim: The predicate returning true iff the point is in the domain given at construction. It is just a wrapper class around the methods Domain::isInside( const Point & ), where Domain stands for any model of CDomain 
CDomainRigidTransformation2D  Aim: implements bounds of transformed domain 
CDomainRigidTransformation3D  Aim: implements bounds of transformed domain 
CDummyEstimatorFromSurfels  
CElementaryConvolutionNormalVectorEstimator  Aim: Estimates normal vector by convolution of elementary normal vector to adjacent surfel 
CEmbedderFromNormalVectors  Functor that projects a face vertex of a surface mesh onto the tangent plane given by a perface normal vector. This functor can be used in PolygonalCalculus to correct the embedding of digital surfaces using an estimated normal vector field (see [26]) 
CEqualPointPredicate  Aim: The predicate returns true when the point given as argument equals the reference point given at construction 
CFalseBoolFct0  
CFalsePointPredicate  Aim: The predicate that returns always false 
CFlipDomainAxis  Aim: Functor that flips the domain coordinate system from some selected axis. For instance, if a flip on the y axis is applied on a domain of bounds (0, 0, 0) (MaxX, MaxY, MaxZ), then the coordinate of P(x,y,z) will transformed in P(x, MaxYy, z) 
CFloor  Functor that rounds down 
CFloor< void >  Functor that rounds down 
CForwardRigidTransformation2D  Aim: implements forward rigid transformation of point in the 2D integer space. Warring: This version uses closest neighbor interpolation 
CForwardRigidTransformation3D  Aim: implements forward rigid transformation of point in 3D integer space around any arbitrary axis. This implementation uses the Rodrigues' rotation formula. Warring: This version uses closest neighbor interpolation 
CFrontierPredicate  Aim: The predicate on surfels that represents the frontier between two regions in an image. It can be used with ExplicitDigitalSurface or LightExplicitDigitalSurface so as to define a digital surface. Such surfaces may of course be open 
CFunctorHolder  Aim: hold any callable object (function, functor, lambda, ...) as a C(Unary)Functor model 
CGaussianKernel  Aim: defines a functor on double numbers which corresponds to a Gaussian convolution kernel. This functor acts from [0,1] to [0,1] 
CGreenChannel  
CHatFunction  
CHatPointFunction  
CIdentity  Aim: Define a simple default functor that just returns its argument 
CIdentityBoolFct1  
CIICurvatureFunctor  Aim: A functor Real > Real that returns the 2d curvature by transforming the given volume. This functor is valid only in 2D space 
CIIFirstPrincipalCurvature3DFunctor  Aim: A functor Matrix > Real that returns the first principal curvature value by diagonalizing the given covariance matrix. This functor is valid starting from 3D space. Note that by first we mean the value with first greatest curvature in absolute value 
CIIFirstPrincipalDirectionFunctor  Aim: A functor Matrix > RealVector that returns the first principal curvature direction by diagonalizing the given covariance matrix. This functor is valid starting from 2D space and is equivalent to IITangentDirectionFunctor in 2D. Note that by first we mean the direction with greatest curvature in absolute value 
CIIGaussianCurvature3DFunctor  Aim: A functor Matrix > Real that returns the Gaussian curvature by diagonalizing the given covariance matrix. This functor is valid starting from 3D space. Note that the Gaussian curvature is computed by multiplying the two gretest curvature values in absolute value 
CIIMeanCurvature3DFunctor  Aim: A functor Real > Real that returns the 3d mean curvature by transforming the given volume. This functor is valid only in 3D space 
CIINormalDirectionFunctor  Aim: A functor Matrix > RealVector that returns the normal direction by diagonalizing the given covariance matrix 
CIIPrincipalCurvatures3DFunctor  Aim: A functor Matrix > std::pair<Real,Real> that returns the first and the second principal curvature value by diagonalizing the given covariance matrix. This functor is valid starting from 3D space. Note that by first we mean the value with first greatest curvature in absolute value 
CIIPrincipalCurvaturesAndDirectionsFunctor  Aim: A functor Matrix > std::pair<RealVector,RealVector> that returns the first and the second principal curvature directions by diagonalizing the given covariance matrix. This functor is valid only for 3D space. Note that by second we mean the direction with second greatest curvature in absolute value 
CIIPrincipalDirectionsFunctor  Aim: A functor Matrix > std::pair<RealVector,RealVector> that returns the first and the second principal curvature directions by diagonalizing the given covariance matrix. This functor is valid starting from 3D space. Note that by second we mean the direction with second greatest curvature in absolute value 
CIISecondPrincipalCurvature3DFunctor  Aim: A functor Matrix > Real that returns the second principal curvature value by diagonalizing the given covariance matrix. This functor is valid starting from 3D space. Note that by second we mean the value with second greatest curvature in absolute value 
CIISecondPrincipalDirectionFunctor  Aim: A functor Matrix > RealVector that returns the second principal curvature direction by diagonalizing the given covariance matrix. This functor is valid starting from 3D space. Note that by second we mean the direction with second greatest curvature in absolute value 
CIITangentDirectionFunctor  Aim: A functor Matrix > RealVector that returns the tangent direction by diagonalizing the given covariance matrix. This functor is valid only in 2D space 
CImpliesBoolFct2  
CIntervalForegroundPredicate  Aim: Define a simple Foreground predicate thresholding image values between two constant values (the first one being excluded) 
CIntervalThresholder  Aim: A small functor with an operator () that compares one value to an interval 
CIsLowerPointPredicate  Aim: The predicate returns true when the point is below (or equal) the given upper bound 
CIsUpperPointPredicate  Aim: The predicate returns true when the point is above (or equal) the given lower bound 
CIsWithinPointPredicate  Aim: The predicate returns true when the point is within the given bounds 
CLambda64Function  
CLambdaExponentialFunction  
CLambdaSinFromPiFunction  
CLargeTruncationFunctor  Binary functor that returns the algebraic quotient i of a/b with any fractional part discarded (truncation toward zero). Note that \( i \leq a/b \) 
CLinearLeastSquareFittingNormalVectorEstimator  Aim: Estimates normal vector using CGAL linear least squares plane fitting 
CMax  
CMeanChannels  
CMin  Duplicated STL functors 
CMinus  
CMongeJetFittingGaussianCurvatureEstimator  Aim: Estimates Gaussian curvature using CGAL Jet Fitting and Monge Form 
CMongeJetFittingMeanCurvatureEstimator  Aim: Estimates Mean curvature using CGAL Jet Fitting and Monge Form 
CMongeJetFittingNormalVectorEstimator  Aim: Estimates normal vector using CGAL Jet Fitting and Monge Form 
CMongeJetFittingPrincipalCurvaturesEstimator  Aim: Estimates Gaussian curvature using CGAL Jet Fitting and Monge Form 
CMultiplicationByScalar  
CNotBoolFct1  
CNotPointPredicate  Aim: The predicate returns true when the point predicate given at construction return false. Thus inverse a predicate: NOT operator 
COrBoolFct2  
CPair1st  Aim: Define a simple functor that returns the first member of a pair 
CPair1stMutator  Aim: Define a simple unary functor that returns a reference on the first member of a pair in order to update it 
CPair2nd  Aim: Define a simple functor that returns the second member of a pair 
CPair2ndMutator  Aim: Define a simple unary functor that returns a reference on the first member of a pair in order to update it 
CPoint2DEmbedderIn3D  Aim: Functor that embeds a 2D point into a 3D space from two axis vectors and an origin point given in the 3D space 
CPoint2ShapePredicate  
CPoint2ShapePredicateComparator  Aim: A small struct with an operator that compares two values according to two bool template parameters 
CPoint2ShapePredicateComparator< T, false, false >  Aim: A small struct with an operator that compares two values (<) 
CPoint2ShapePredicateComparator< T, false, true >  Aim: A small struct with an operator that compares two values (<=) 
CPoint2ShapePredicateComparator< T, true, false >  Aim: A small struct with an operator that compares two values (>) 
CPoint2ShapePredicateComparator< T, true, true >  Aim: A small struct with an operator that compares two values (>=) 
CPointFunctorFromPointPredicateAndDomain  Create a point functor from a point predicate and a domain 
CPointFunctorHolder  Aim: hold any object callable on points as a DGtal::concepts::CPointFunctor model 
CPointFunctorPredicate  Aim: The predicate returns true when the predicate returns true for the value assigned to a given point in the point functor 
CPolarPointComparatorBy2x2DetComputer  Aim: Class that implements a binary point predicate, which is able to compare the position of two given points \( P, Q \) around a pole \( O \). More precisely, it compares the oriented angles lying between the horizontal line passing by \( O \) and the rays \( [OP) \) and \( [OQ) \) (in a counterclockwise orientation) 
CPositionFunctorFrom2DPoint  Functor that returns the position of any point/vector with respect to a digital straight line of shift myShift. We recall that the shift vector is a vector translating a point of remainder \( r \) to a point of remainder \( r + \omega \). See Digital straight lines and segments for further details 
CPredicateCombiner  Aim: The predicate returns true when the given binary functor returns true for the two Predicates given at construction 
CProjector  Aim: Functor that maps a point P of dimension i to a point Q of dimension j. The member myDims is an array containing the coordinates  (0, 1, ..., j1) by default  that are copied from P to Q 
CRedChannel  
CRescaling  Aim: Functor allowing to rescale a value. Values of the initial scale [initMin,initMax] are rescaled to the new scale [newMin,newMax] 
CRound  Functor that rounds to the nearest integer 
CRound< void >  Functor that rounds to the nearest integer 
CSCellToArrow  Aim: transforms a signed cell into an arrow, ie. a pair pointvector 
CSCellToCode  Aim: transforms a 2d signed cell, basically a linel, into a code (0,1,2 or 3), 
CSCellToIncidentPoints  Aim: transforms a signed cell c into a pair of points corresponding to the signed cells of greater dimension that are indirectly and directly incident to c 
CSCellToInnerPoint  Aim: transforms a signed cell c into a point corresponding to the signed cell of greater dimension that is indirectly incident to c 
CSCellToOuterPoint  Aim: transforms a signed cell c into a point corresponding to the signed cell of greater dimension that is directly incident to c 
CSCellToPoint  Aim: transforms a scell into a point 
CSimpleThresholdForegroundPredicate  Aim: Define a simple Foreground predicate thresholding image values given a single thresold. More precisely, the functor operator() returns true if the value is greater than a given threshold 
CSliceRotator2D  Special Point Functor that adds one dimension to a 2D point and apply on it a rotation of angle alpha according to a given direction and the domain center. It also checks if the resulting point is inside the 3D domain, else it returns a particular point (by default the point at domain origin (from the domain method lowerBound()) 
►CSphereFittingEstimator  Aim: Use Patate library to perform a local sphere fitting 
CPatatePoint  
CQuantity  Quantity type: a 3sphere (model of CQuantity) 
CSphericalHoughNormalVectorEstimator  Aim: This functor estimates normal vector for a collection of surfels using spherical accumulator based Hough voting 
CStrictTruncationFunctor  BinaryFunctor that computes the algebraic quotient i of a/b with any non zero fractional part discarded (truncation toward zero), and that returns i+1 (resp. i1) if a is negative (resp. positive) if b divides a. Since we assume that a is not equal to 0, we have \( i < a/b \). See also LargeTruncationFunctor 
CSurfelSetPredicate  Aim: The predicate returning true iff the point is in the domain given at construction 
CTensorVotingFeatureExtraction  Aim: Implements a functor to detect feature points from normal tensor voting strategy 
CThresholder  Aim: A small functor with an operator () that compares one value to a threshold value according to two bool template parameters 
CThresholder< T, false, false >  
CThresholder< T, false, true >  
CThresholder< T, true, false >  
CThresholder< T, true, true >  
CTrueBoolFct0  
CTruePointPredicate  Aim: The predicate that returns always true 
CTrunc  Functor that rounds towards zero 
CTrunc< void >  Functor that rounds towards zero 
CUnaryMinus  
CVCMAbsoluteCurvatureFunctor  Aim: A functor Surfel > Quantity that returns the absolute curvature at given surfel. This class has meaning only in 2D 
CVCMFirstPrincipalAbsoluteCurvatureFunctor  Aim: A functor Surfel > Quantity that returns the first principal absolute curvature (greatest curvature) at given surfel. This class has meaning only in 3D 
CVCMMeanAbsoluteCurvatures3DFunctor  Aim: A functor Surfel > Quantity that returns the mean of absolute curvatures at given surfel: (abs(k1)+abs(k2))/2. This class has meaning only in 3D 
CVCMNormalVectorFunctor  Aim: A functor Surfel > Quantity that returns the outer normal vector at given surfel 
CVCMSecondPrincipalAbsoluteCurvatureFunctor  Aim: A functor Surfel > Quantity that returns the second principal absolute curvature (smallest curvature) at given surfel. This class has meaning only in 3D 
CVectorRounding  
CXorBoolFct2  
NZ2i  Z2i this namespace gathers the standard of types for 2D imagery 
NZ3i  Z3i this namespace gathers the standard of types for 3D imagery 
CAccFlower2D  Aim: Model of the concept StarShaped represents any accelerated flower in the plane 
CAddTextureImage2DWithFunctor  Class to insert a custom 2D textured image by using a conversion functor and allows to change the default mode (GrayScale mode) to color mode 
CAddTextureImage3DWithFunctor  Class to insert a custom 3D textured image by using a conversion functor and allows to change the default mode (GrayScale mode) to color mode 
CAlias  Aim: This class encapsulates its parameter class so that to indicate to the user that the object/pointer will be only aliased. Therefore the user is reminded that the argument parameter is given to the function without any additional cost and may be modified, while he is aware that the lifetime of the argument parameter must be at least as long as the object itself. Note that an instance of Alias<T> is itself a light object (it holds only an enum and a pointer) 
►CAlphaThickSegmentComputer  Aim: This class is devoted to the recognition of alpha thick segments as described in [51] . From a maximal diagonal alphaMax thickness, it recognizes thick segments and may thus take into account some noise in the input contour. Moreover points of the segment may not be (digitally) connected and may have floating point coordinates. Connection is only given by the order of the points 
CState  
CAngleComputer  
►CAngleLinearMinimizer  Aim: Used to minimize the angle variation between different angles while taking into accounts min and max constraints. Example ( 
CValueInfo  
CAngleLinearMinimizerByAdaptiveStepGradientDescent  
CAngleLinearMinimizerByGradientDescent  
CAngleLinearMinimizerByRelaxation  
CArithDSSIterator  Aim: An iterator on the points of a Digital Straight Segment. Template parameters are the integer type and the connectivity of the DSS (8connectivity as default value) 
►CArithmeticalDSL  Aim: This class represents a naive (resp. standard) digital straight line (DSL), ie. the set of digital points \( (x,y) \in \mathbb{Z}^2 \) such that \( \mu \leq ax  by < \mu + \omega \) with \( a,b,\mu,\omega \in \mathbb{Z} \), \( \gcd(a,b) = 1 \) and \( \omega = \max(a,b) \) (resp. \( \omega = a + b \)). Note that any DSL such that \( \omega = \max(a,b) \) (resp. \( \omega = a + b \)) is simply 8connected (resp. 4connected) 
CConstIterator  Aim: This class aims at representing an iterator that provides a way to scan the points of a DSL. It is both a model of readable iterator and of bidirectional iterator 
CArithmeticalDSLKernel  Aim: Small class that contains the code that depends on the arithmetical thickness (either naive or standard) of a digital straight line (DSL). It provides mainly two static methods: 
CArithmeticalDSLKernel< TCoordinate, 4 >  
CArithmeticalDSS  Aim: This class represents a naive (resp. standard) digital straight segment (DSS), ie. the sequence of simply 8 (resp. 4)connected digital points contained in a naive (resp. standard) digital straight line (DSL) between two points of it 
CArithmeticalDSSComputer  Aim: This class is a wrapper around ArithmeticalDSS that is devoted to the dynamic recognition of digital straight segments (DSS) along any sequence of digital points 
CArithmeticalDSSComputerOnSurfels  Aim: This class is a wrapper around ArithmeticalDSS that is devoted to the dynamic recognition of digital straight segments (DSS) along any sequence of 3D surfels 
CArithmeticalDSSFactory  Aim: Set of static methods that create digital straight segments (DSS) from some input parameters, eg. patterns (or reversed patterns) from two upper leaning points (or lower leaning points) 
CArithmeticConversionTraits  Aim: Trait class to get result type of arithmetic binary operators between two given types 
CArithmeticConversionTraits< __gmp_expr< GMP1, GMP2 >, U, typename std::enable_if< std::is_integral< U >::value >::type >  Specialization when second operand is a BigInteger 
CArithmeticConversionTraits< __gmp_expr< GMPL1, GMPL2 >, __gmp_expr< GMPR1, GMPR2 > >  Specialization when both operands are BigInteger 
CArithmeticConversionTraits< LeftEuclideanRing, PointVector< dim, RightEuclideanRing, RightContainer >, typename std::enable_if< IsArithmeticConversionValid< LeftEuclideanRing, RightEuclideanRing >::value &&! IsAPointVector< LeftEuclideanRing >::value >::type >  Specialization of ArithmeticConversionTraits when right operand is a PointVector 
CArithmeticConversionTraits< PointVector< dim, LeftEuclideanRing, LeftContainer >, PointVector< dim, RightEuclideanRing, RightContainer >, typename std::enable_if< IsArithmeticConversionValid< LeftEuclideanRing, RightEuclideanRing >::value >::type >  Specialization of ArithmeticConversionTraits when both operands are PointVector 
CArithmeticConversionTraits< PointVector< dim, LeftEuclideanRing, LeftContainer >, RightEuclideanRing, typename std::enable_if< IsArithmeticConversionValid< LeftEuclideanRing, RightEuclideanRing >::value &&! IsAPointVector< RightEuclideanRing >::value >::type >  Specialization of ArithmeticConversionTraits when left operand is a PointVector 
CArithmeticConversionTraits< T, __gmp_expr< GMP1, GMP2 >, typename std::enable_if< std::is_integral< T >::value >::type >  Specialization when first operand is a BigInteger 
CArithmeticConversionTraits< T, U, typename std::enable_if< ! std::is_same< T, typename std::remove_cv< typename std::remove_reference< T >::type >::type >::value! std::is_same< U, typename std::remove_cv< typename std::remove_reference< U >::type >::type >::value >::type >  Specialization in order to remove const specifiers and references from given types 
CArithmeticConversionTraits< T, U, typename std::enable_if< std::is_arithmetic< T >::value &&std::is_arithmetic< U >::value >::type >  Specialization for (fundamental) arithmetic types 
CArrayImageAdapter< TArrayIterator, HyperRectDomain< TSpace > >  Aim: Image adapter for generic arrays with subdomain view capability 
CArrayImageIterator  Aim: Random access iterator over an image given his definition domain and viewable domain 
CAssociativeCategory  
CAstroid2D  Aim: Model of the concept StarShaped represents an astroid 
CATSolver2D  Aim: This class solves AmbrosioTortorelli functional on a twodimensional digital space (a 2D grid or 2D digital surface) for a piecewise smooth scalar/vector function u represented as one/several 2form(s) and a discontinuity function v represented as a 0form. The 2form(s) u is a regularized approximation of an input vector data g, while v represents the set of discontinuities of u. The norm chosen for u is the \( l_2 \)norm 
CAvnaimEtAl2x2DetSignComputer  Aim: Class that provides a way of computing the sign of the determinant of a 2x2 matrix from its four coefficients, ie 
CBackInsertionSequenceToStackAdapter  Aim: This class implements a dynamic adapter to an instance of a model of back insertion sequence in order to get a stack interface. This class is a model of CStack 
CBall2D  Aim: Model of the concept StarShaped represents any circle in the plane 
CBall3D  Aim: Model of the concept StarShaped3D represents any Sphere in the space 
CBidirectionalCategory  
CBidirectionalSegmentComputer  
CBinomialConvolver  Aim: This class represents a 2D contour convolved by some binomial. It computes first and second order derivatives so as to be able to estimate tangent and curvature. In particular, it smoothes digital contours but could be used for other kind of contours 
CBinomialConvolverEstimator  Aim: This class encapsulates a BinomialConvolver and a functor on BinomialConvolver so as to be a model of CCurveLocalGeometricEstimator 
CBits  
CBLUELocalLengthEstimator  Aim: Best Linear Unbiased Two step length estimator 
CBoard2D  Aim: This class specializes a 'Board' class so as to display DGtal objects more naturally (with <<). The user has simply to declare a Board2D object and uses stream operators to display most digital objects. Furthermore, one can use this class to modify the current style for drawing 
CBoard3D  The class Board3D is a type of Display3D which export the figures in the format OBJ/MTL when calling the method saveOBJ 
CBoard3DTo2D  Class for PDF, PNG, PS, EPS, SVG export drawings with Cairo with 3D>2D projection 
CBoard3DTo2DFactory  Factory for GPL Display3D: 
►CBoundedLatticePolytope  Aim: Represents an nD lattice polytope, i.e. a convex polyhedron bounded with vertices with integer coordinates, as a set of inequalities. Otherwise said, it is a Hrepresentation of a polytope (as an intersection of halfspaces). A limitation is that we model only bounded polytopes, i.e. polytopes that can be included in a finite bounding box 
CLeftStrictUnitCell  
CLeftStrictUnitSegment  
CRightStrictUnitCell  
CRightStrictUnitSegment  
CUnitCell  
CUnitSegment  
CBoundedLatticePolytopeCounter  Aim: Useful to compute quickly the lattice points within a polytope, i.e. a convex polyhedron 
►CBoundedRationalPolytope  Aim: Represents an nD rational polytope, i.e. a convex polyhedron bounded by vertices with rational coordinates, as a set of inequalities. Otherwise said, it is a Hrepresentation of a polytope (as an intersection of halfspaces). A limitation is that we model only bounded polytopes, i.e. polytopes that can be included in a finite bounding box 
CRational  
CUnitCell  
CUnitSegment  
CBreadthFirstVisitor  Aim: This class is useful to perform a breadthfirst exploration of a graph given a starting point or set (called initial core) 
CC2x2DetComputer  Aim: This concept gathers all models that are able to compute the (sign of the) determinant of a 2x2 matrix with integral entries 
CCameraDirection  CameraDirection class to set camera direction 
CCameraPosition  CameraPosition class to set camera position 
CCameraUpVector  CameraUpVector class to set camera upvector 
CCameraZNearFar  CameraZNearFar class to set near and far distance 
CCanonicCellEmbedder  Aim: A trivial embedder for signed and unsigned cell, which corresponds to the canonic injection of cell centroids into Rn 
CCanonicDigitalSurfaceEmbedder  Aim: A trivial embedder for digital surfaces, which corresponds to the canonic injection of cell centroids into Rn 
CCanonicEmbedder  Aim: A trivial embedder for digital points, which corresponds to the canonic injection of Zn into Rn 
CCanonicSCellEmbedder  Aim: A trivial embedder for signed cell, which corresponds to the canonic injection of cell centroids into Rn 
CCBidirectionalIteratorArchetype  An archetype of BidirectionalIterator 
CCConstBidirectionalIteratorArchetype  An archetype of ConstBidirectionalIterator 
CCellGeometry  Aim: Computes and stores sets of cells and provides methods to compute intersections of lattice and rational polytopes with cells 
CCellGeometryFunctions  
CCellGeometryFunctions< TKSpace, 1, 2 >  
CCellGeometryFunctions< TKSpace, 1, 3 >  
CCellGeometryFunctions< TKSpace, 2, 2 >  
CCellGeometryFunctions< TKSpace, 2, 3 >  
CCellGeometryFunctions< TKSpace, 3, 3 >  
CCForwardIteratorArchetype  An archetype of ForwardIterator 
CChordGenericNaivePlaneComputer  Aim: A class that recognizes pieces of digital planes of given axis width. When the width is 1, it corresponds to naive planes. Contrary to ChordNaivePlaneComputer, the axis is not specified at initialization of the object. This class uses three instances of ChordNaivePlaneComputer, one per axis 
►CChordGenericStandardPlaneComputer  Aim: A class that recognizes pieces of digital planes of given diagonal width. When the width is \(1 \times \sqrt{3}\), it corresponds to standard planes. Contrary to ChordStandardPlaneComputer, the axis is not specified at initialization of the object. This class uses four instances of ChordStandardPlaneComputer of axis z, by transforming points \((x,y,z)\) to \((x \pm z, y \pm z, z)\) 
CTransform  
►CChordNaivePlaneComputer  Aim: A class that contains the chordbased algorithm for recognizing pieces of digital planes of given axis width [ Gerard, DebledRennesson, Zimmermann, 2005 ]. When the width is 1, it corresponds to naive planes. The axis is specified at initialization of the object 
CState  
CCircleFrom2Points  Aim: Represents a circle that passes through a given point and that is thus uniquely defined by two other points. It is able to return for any given point its signed distance to itself 
CCircleFrom3Points  Aim: Represents a circle uniquely defined by three 2D points and that is able to return for any given 2D point its signed distance to itself 
CCirculator  Aim: Provides an adapter for classical iterators that can iterate through the underlying data structure as in a loop. The increment (resp. decrement) operator encapsulates the validity test and the assignement to the begin (resp. end) iterator of a given range, when the end (resp. beginning) has been reached. For instance, the preincrement operator does: 
CCirculatorType  
CClippingPlane  Class for adding a Clipping plane through the Viewer3D stream. Realizes the concept CDrawableWithViewer3D 
CClock  
►CClone  Aim: This class encapsulates its parameter class to indicate that the given parameter is required to be duplicated (generally, this is done to have a longer lifetime than the function itself). On one hand, the user is reminded of the possible cost of duplicating the argument parameter, while he is also aware that the lifetime of the parameter is not a problem for the function. On the other hand, the Clone class is smart enough to enforce duplication only if needed. Substantial speedup can be achieve through this mechanism 
CTempPtr  Internal class that is used for a late deletion of an acquired pointer 
CClosedIntegerHalfPlane  Aim: A halfspace specified by a vector N and a constant c. The halfspace is the set \( \{ P \in Z^2, N.P \le c \} \) 
CCOBAGenericNaivePlaneComputer  Aim: A class that recognizes pieces of digital planes of given axis width. When the width is 1, it corresponds to naive planes. Contrary to COBANaivePlaneComputer, the axis is not specified at initialization of the object. This class uses three instances of COBANaivePlaneComputer, one per axis 
►CCOBAGenericStandardPlaneComputer  Aim: A class that recognizes pieces of digital planes of given axis width. When the diagonal width is \( 1 \times \sqrt{3} \), it corresponds to standard planes. Contrary to COBANaivePlaneComputer, the axis is not specified at initialization of the object. This class uses four instances of COBANaivePlaneComputer of axis z, by transforming points \((x,y,z)\) to \((x \pm z, y \pm z, z)\) 
CTransform  
►CCOBANaivePlaneComputer  Aim: A class that contains the COBA algorithm (Emilie Charrier, Lilian Buzer, DGCI2008) for recognizing pieces of digital planes of given axis width. When the width is 1, it corresponds to naive planes. The axis is specified at initialization of the object 
CState  
CColMajorStorage  Tag (empty structure) specifying a colmajor storage order 
CColor  Structure representing an RGB triple with alpha component 
CColorBrightnessColorMap  Aim: This class template may be used to (linearly) convert scalar values in a given range into a color with given lightness 
CCompareLocalEstimators  Aim: Functor to compare two local geometric estimators 
CConnectivityException  
CConstAlias  Aim: This class encapsulates its parameter class so that to indicate to the user that the object/pointer will be only const aliased (and hence left unchanged). Therefore the user is reminded that the argument parameter is given to the function without any additional cost and may not be modified, while he is aware that the lifetime of the argument parameter must be at least as long as the object itself. Note that an instance of ConstAlias<T> is itself a light object (it holds only an enum and a pointer) 
CConstImageAdapter  Aim: implements a const image adapter with a given domain (i.e. a subdomain) and 2 functors : g for domain, f for accessing point values 
CConstIteratorAdapter  This class adapts any iterator so that operator* returns another element than the one pointed to by the iterator 
CConstRangeAdapter  Aim: model of CConstBidirectionalRange that adapts any range of elements bounded by two iterators [itb, ite) and provides services to (circularly)iterate over it (in a readonly manner) 
CConstRangeFromPointAdapter  Aim: model of CConstBidirectionalRangeFromPoint that adapts any bidirectional range and provides services to iterate over it (in a readonly manner) 
CContainerCategory  
CContainerTraits  Defines default container traits for arbitrary types 
CContainerTraits< boost::unordered_map< Value, T, Hash, Pred, Alloc > >  Defines container traits for boost::unordered_map<> 
CContainerTraits< boost::unordered_multimap< Value, T, Hash, Pred, Alloc > >  Defines container traits for boost::unordered_multimap<> 
CContainerTraits< boost::unordered_multiset< Value, Hash, Pred, Alloc > >  Defines container traits for boost::unordered_multiset<> 
CContainerTraits< boost::unordered_set< Value, Hash, Pred, Alloc > >  Defines container traits for boost::unordered_set<> 
CContainerTraits< CubicalComplex< TKSpace, TCellContainer > >  
CContainerTraits< std::array< T, N > >  Defines container traits for std::array<> 
CContainerTraits< std::deque< T, Alloc > >  Defines container traits for std::deque<> 
CContainerTraits< std::forward_list< T, Alloc > >  Defines container traits for std::forward_list<> 
CContainerTraits< std::list< T, Alloc > >  Defines container traits for std::list<> 
CContainerTraits< std::map< Key, T, Compare, Alloc > >  Defines container traits for std::map<> 
CContainerTraits< std::multimap< Key, T, Compare, Alloc > >  Defines container traits for std::multimap<> 
CContainerTraits< std::multiset< T, Compare, Alloc > >  Defines container traits for std::multiset<> 
CContainerTraits< std::set< T, Compare, Alloc > >  Defines container traits for std::set<> 
CContainerTraits< std::unordered_map< Key, T, Hash, Pred, Alloc > >  Defines container traits for std::unordered_map<> 
CContainerTraits< std::unordered_multimap< Key, T, Hash, Pred, Alloc > >  Defines container traits for std::unordered_multimap<> 
CContainerTraits< std::unordered_multiset< Key, Hash, Pred, Alloc > >  Defines container traits for std::unordered_multiset<> 
CContainerTraits< std::unordered_set< Key, Hash, Pred, Alloc > >  Defines container traits for std::unordered_set<> 
CContainerTraits< std::vector< T, Alloc > >  Defines container traits for std::vector<> 
CContourHelper  Aim: a helper class to process sequences of points 
CConvexCellComplex  Aim: represents a ddimensional complex in a ddimensional space with the following properties and restrictions: 
►CConvexHullCommonKernel  Aim: the common part of all geometric kernels for computing the convex hull or Delaunay triangulation of a range of points 
CHalfSpace  
CConvexHullIntegralKernel  Aim: a geometric kernel to compute the convex hull of digital points with integeronly arithmetic 
CConvexHullRationalKernel  Aim: a geometric kernel to compute the convex hull of floating points with integeronly arithmetic. Floating points are approximated with rational points with fixed precision (a given number of bits). All remaining computations are exact, as long as there is no overflow 
CConvexityHelper  Aim: Provides a set of functions to facilitate the computation of convex hulls and polytopes, as well as shortcuts to build cell complex representing a Delaunay complex 
CCorrectedNormalCurrentComputer  Aim: Utility class to compute curvature measures induced by (1) a corrected normal current defined by a surface mesh with prescribed normals and (2) the standard LipschitzKilling invariant forms of area and curvatures 
CCorrectedNormalCurrentFormula  Aim: A helper class that provides static methods to compute corrected normal current formulas of curvatures 
CCountedConstPtrOrConstPtr  Aim: Smart or simple const pointer on T . It can be a smart pointer based on reference counts or a simple pointer on T depending either on a boolean value given at construction or on the constructor used. In the first case, we will call this pointer object smart, otherwise we will call it simple 
►CCountedPtr  Aim: Smart pointer based on reference counts 
CCounter  
CCountedPtrOrPtr  Aim: Smart or simple pointer on T. It can be a smart pointer based on reference counts or a simple pointer on T depending either on a boolean value given at construction or on the constructor used. In the first case, we will call this pointer object smart, otherwise we will call it simple 
CCowPtr  Aim: Copy on write shared pointer 
CCSinglePassIteratorArchetype  An archetype of SingePassIterator 
CCubicalCellData  
►CCubicalComplex  Aim: This class represents an arbitrary cubical complex living in some Khalimsky space. Cubical complexes are sets of cells of different dimensions related together with incidence relations. Two cells in a cubical complex are incident if and only if they are incident in the surrounding Khalimsky space. In other words, cubical complexes are defined here as subsets of Khalimsky spaces 
CConstIterator  
CDefaultCellMapIteratorPriority  
CIterator  
CCurvatureFromBinomialConvolverFunctor  Aim: This class is a functor for getting the curvature of a binomial convolver 
CCurvatureFromDCAEstimator  
CCurvatureFromDSSEstimator  
CCurvatureFromDSSLengthEstimator  
CCustomColors  Custom style class redefining the pen color and the fill color. You may use Board2D::Color::None for transparent color 
CCustomColors3D  
CCustomFillColor  Custom style class redefining the fill color. You may use Board2D::Color::None for transparent color 
CCustomPen  Custom style class redefining the pen attributes. You may use Board2D::Color::None for transparent color 
CCustomPenColor  Custom style class redefining the pen color. You may use Board2D::Color::None for transparent color 
CCustomStyle  
CCustomStyle3D  Modifier class in a Display3D stream. Useful to choose your own style for a given class. Realizes the concept CDrawableWithDisplay3D 
CDecoratorParametricCurveTransformation  Aim: Implements a decorator for applying transformations to parametric curves 
CDefaultConstImageRange  Aim: model of CConstBidirectionalRangeFromPoint that adapts the domain of an image in order to iterate over the values associated to its domain points (in a readonly as well as a writeonly manner). 
CDefaultImageRange  Aim: model of CConstBidirectionalRangeFromPoint and CBidirectionalRangeWithWritableIteratorFromPoint that adapts the domain of an image in order to iterate over the values associated to its domain points (in a readonly as well as a writeonly manner). 
CDelaunayIntegralKernel  Aim: a geometric kernel to compute the Delaunay triangulation of digital points with integeronly arithmetic. It casts lattice point into a higher dimensional space and computes its convex hull. Facets pointing toward the bottom form the simplices of the Delaunay triangulation 
CDelaunayRationalKernel  Aim: a geometric kernel to compute the Delaunay triangulation of a range of floating points with integeronly arithmetic. Floating points are approximated with rational points with fixed precision (a given number of bits), which are cast in a higher dimensional space and lifted onto the "norm" paraboloid, as classically done when computing a Delaunay triangulation from a convex hull. All remaining computations are exact, as long as there is no overflow 
CDepthFirstVisitor  Aim: This class is useful to perform a depthfirst exploration of a graph given a starting point or set (called initial core) 
►CDicomReader  Aim: Import a 3D DICOM image from file series 
CAux  
CAux< ImageContainerByITKImage< Domain, OutPixelType >, Domain, OutPixelType, PixelType >  
CDigitalConvexity  Aim: A helper class to build polytopes from digital sets and to check digital kconvexity and full convexity 
CDigitalMetricAdapter  Aim: simple adapter class which adapts any models of concepts::CMetricSpace to a model of concepts::CDigitalMetricSpace 
CDigitalPlanePredicate  Aim: Representing digital planes, which are digitizations of Euclidean planes, as point predicates 
►CDigitalSetBoundary  Aim: A model of CDigitalSurfaceContainer which defines the digital surface as the boundary of a given digital set 
CTracker  
CDigitalSetByAssociativeContainer  Aim: A wrapper class around a STL associative container for storing sets of digital points within some given domain 
CDigitalSetBySTLSet  Aim: A container class for storing sets of digital points within some given domain 
CDigitalSetBySTLVector  Aim: Realizes the concept CDigitalSet by using the STL container std::vector 
CDigitalSetConverter  Aim: Utility class to convert between types of sets 
CDigitalSetDomain  Aim: Constructs a domain limited to the given digital set 
CDigitalSetFromMap  Aim: An adapter for viewing an associative image container like ImageContainerBySTLMap as a simple digital set. This class is merely based on an aliasing pointer on the image, which must exists elsewhere. 
CDigitalSetInserter  Aim: this output iterator class is designed to allow algorithms to insert points in the digital set. Using the assignment operator, even when dereferenced, causes the digital set to insert a point 
CDigitalSetSelector  Aim: Automatically defines an adequate digital set type according to the hints given by the user 
CDigitalShapesCSG  Aim: Constructive Solid Geometry (CSG) between models of CDigitalBoundedShape and CDigitalOrientedShape Use CSG operation (union, intersection, minus) from a shape of Type ShapeA with one (or more) shapes of Type ShapeB. Can combine differents operations. Limitations: Since we don't have a class derived by all shapes, operations can be done by only one type of shapes. Use CSG of CSG to go beyond this limitation 
►CDigitalSurface  Aim: Represents a set of n1cells in a nD space, together with adjacency relation between these cells. Therefore, a digital surface is a pure cubical complex (model of CCubicalComplex), made of kcells, 0 <= k < n. This complex is generally not a manifold (i.e. a kind of surface), except when it has the property of being wellcomposed 
CArc  
CEdge  
CFace  
CSurfelMap  
CVertexMap  
CDigitalSurface2DSlice  Aim: Represents a 2dimensional slice in a DigitalSurface. In a sense, it is a 4connected contour, open or not. To be valid, it must be connected to some digital surface and a starting surfel 
CDigitalSurfaceConvolver  
CDigitalSurfaceConvolver< TFunctor, TKernelFunctor, TKSpace, TDigitalKernel, 2 >  
CDigitalSurfaceConvolver< TFunctor, TKernelFunctor, TKSpace, TDigitalKernel, 3 >  
CDigitalSurfaceEmbedderWithNormalVectorEstimator  Aim: Combines a digital surface embedder with a normal vector estimator to get a model of CDigitalSurfaceEmbedder and CWithGradientMap. (also default constructible, copy constructible, assignable) 
CDigitalSurfaceEmbedderWithNormalVectorEstimatorGradientMap  
CDigitalSurfacePredicate  Aim: A point predicate which tells whether a point belongs to the set of pointels of a given digital surface or not 
CDigitalSurfaceRegularization  Aim: Implements Digital Surface Regularization as described in [31] 
CDigitalTopology  Aim: Represents a digital topology as a couple of adjacency relations 
CDigitalTopologyTraits  Aim: the traits classes for DigitalTopology types 
CDigitalTopologyTraits< MetricAdjacency< TSpace, 1 >, MetricAdjacency< TSpace, 2 >, 2 >  Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (4,8) 
CDigitalTopologyTraits< MetricAdjacency< TSpace, 1 >, MetricAdjacency< TSpace, 2 >, 3 >  Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (6,18) 
CDigitalTopologyTraits< MetricAdjacency< TSpace, 1 >, MetricAdjacency< TSpace, 3 >, 3 >  Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (6,26) 
CDigitalTopologyTraits< MetricAdjacency< TSpace, 2 >, MetricAdjacency< TSpace, 1 >, 2 >  Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (8,4) 
CDigitalTopologyTraits< MetricAdjacency< TSpace, 2 >, MetricAdjacency< TSpace, 1 >, 3 >  Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (18,6) 
CDigitalTopologyTraits< MetricAdjacency< TSpace, 3 >, MetricAdjacency< TSpace, 1 >, 3 >  Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (26,6) 
CDirichletConditions  Aim: A helper class to solve a system with Dirichlet boundary conditions 
►CDiscreteExteriorCalculus  Aim: DiscreteExteriorCalculus represents a calculus in the dec package. This is the main structure in the dec package. This is used to describe the space on which the dec is build and to compute various operators. Once operators or kforms are created, this structure should not be modified 
CProperty  Holds size 'primal_size', 'dual_size', 'index' and 'flipped' for each cell of the DEC object. To avoid inserting both positive and negative cells in a DEC object, only non signed cells are stored internally 
CDiscreteExteriorCalculusFactory  Aim: This class provides static members to create DEC structures from various other DGtal structures 
CDiscreteExteriorCalculusSolver  Aim: This wraps a linear algebra solver around a discrete exterior calculus 
CDisplay2DFactory  Factory for Display2D: 
►CDisplay3D  Aim: This semi abstract class defines the stream mechanism to display 3d primitive (like BallVector, DigitalSetBySTLSet, Object ...). The class Viewer3D and Board3DTo2D implement two different ways to display 3D objects. The first one (Viewer3D), permits an interactive visualisation (based on OpenGL ) and the second one (Board3dto2d) provides 3D visualisation from 2D vectorial display (based on the CAIRO library) 
CBallD3D  
CClippingPlaneD3D  
CCommonD3D  
CCubeD3D  
CLineD3D  
CPolygonD3D  
CQuadD3D  
CSelectCallbackFctStore  
CTriangleD3D  
CDisplay3DFactory  Factory for GPL Display3D: 
►CDistanceBreadthFirstVisitor  Aim: This class is useful to perform an exploration of a graph given a starting point or set (called initial core) and a distance criterion 
CNode  
CDistanceFromDCAEstimator  
CDistanceFunctorFromPoint  
CDistanceTransformation  Aim: Implementation of the linear in time distance transformation for separable metrics 
►CDomainAdjacency  Aim: Given a domain and an adjacency, limits the given adjacency to the specified domain for all adjacency and neighborhood computations 
CVertexMap  
CDrawableWithBoard2D  
CDrawableWithBoard3DTo2D  
CDrawableWithDisplay3D  
CDrawWithBoard3DTo2DModifier  Base class specifying the methods for classes which intend to modify a Viewer3D stream 
CDrawWithBoardModifier  
CDrawWithDisplay3DModifier  Base class specifying the methods for classes which intend to modify a Viewer3D stream 
CDrawWithViewer3DModifier  Base class specifying the methods for classes which intend to modify a Viewer3D stream 
►CDSLSubsegment  Aim: Given a Digital Straight line and two endpoints A and B on this line, compute the minimal characteristics of the digital subsegment [AB] in logarithmic time. Two algorithms are implemented: one is based on the local computation of lower and upper convex hulls, the other is based on a dual transformation and uses the Farey fan. Implementation requires that the DSL lies in the first octant (0 <= a <= b) 
CRayC  
CDSSLengthEstimator  Aim: a model of CGlobalCurveEstimator that segments the digital curve into DSS and computes the length of the resulting (not uniquely defined) polygon 
CDSSLengthLessEqualFilter  
CDSSMuteFilter  
CDummyObject  
CDynamicBidirectionalSegmentComputer  
CDynamicSegmentComputer  
CEhrhartPolynomial  Aim: This class implements the class Ehrhart Polynomial which is related to lattice point enumeration in bounded lattice polytopes 
CEigenDecomposition  Aim: This class provides methods to compute the eigen decomposition of a matrix. Its objective is to replace a specialized matrix library when none are available 
CEigenLinearAlgebraBackend  Aim: Provide linear algebra backend using Eigen dense and sparse matrix as well as dense vector. 6 linear solvers available: 
CEllipse2D  Aim: Model of the concept StarShaped represents any ellipse in the plane 
CEllipticHelix  Aim: Implement a parametric curve â€“ elliptic helix 
CEstimatorCache  Aim: this class adapts any local surface estimator to cache the estimated values in a associative container (Surfel <> estimated value) 
CEuclideanShapesCSG  Aim: Constructive Solid Geometry (CSG) between models of CEuclideanBoundedShape and CEuclideanOrientedShape Use CSG operation (union, intersection, minus) from a shape of Type ShapeA with one (or more) shapes of Type ShapeB. Can combine differents operations. Limitations: Since we don't have a class derived by all shapes, operations can be done by only one type of shapes. Use CSG of CSG to go beyond this limitation 
CExactPredicateLpPowerSeparableMetric  Aim: implements weighted separable l_p metrics with exact predicates 
CExactPredicateLpPowerSeparableMetric< TSpace, 2, TPromoted >  
CExactPredicateLpSeparableMetric  Aim: implements separable l_p metrics with exact predicates 
CExactPredicateLpSeparableMetric< TSpace, 2, TRawValue >  
CExpander  Aim: This class is useful to visit an object by adjacencies, layer by layer 
►CExplicitDigitalSurface  Aim: A model of CDigitalSurfaceContainer which defines the digital surface as connected surfels. The shape is determined by a predicate telling whether a given surfel belongs or not to the shape boundary. Compute once the boundary of the surface with a tracking 
CTracker  
CFiltered2x2DetComputer  Aim: Class that provides a way of computing the sign of the determinant of a 2x2 matrix from its four coefficients, ie 
CFlower2D  Aim: Model of the concept StarShaped represents any flower with kpetals in the plane 
CFMM  Aim: Fast Marching Method (FMM) for nd distance transforms 
CForwardCategory  
CForwardSegmentComputer  
CFP  Aim: Computes the faithful polygon (FP) of a range of 4/8connected 2D Points 
CFPLengthEstimator  Aim: a model of CGlobalCurveEstimator that computes the length of a digital curve using its FP (faithful polygon) 
►CFrechetShortcut  Aim: Online computation Computation of the longest shortcut according to the FrÃ©chet distance for a given error. See related article: Sivignon, I., (2011). A NearLinear Time Guaranteed Algorithm for Digital Curve Simplification under the FrÃ©chet Distance. DGCI 2011. Retrieved from http://link.springer.com/chapter/10.1007/9783642198670_28 
►CBackpath  
Cocculter_attributes  
CCone  
CTools  
►CFreemanChain  
CCodesRange  Aim: model of CRange that provides services to (circularly)iterate over the letters of the freeman chain 
CConstIterator  
CFrontInsertionSequenceToStackAdapter  Aim: This class implements a dynamic adapter to an instance of a model of front insertion sequence in order to get a stack interface. This class is a model of CStack 
CFunctorOnCells  Aim: Convert a functor on Digital Point to a Functor on Khalimsky Cell 
CGaussDigitizer  Aim: A class for computing the Gauss digitization of some Euclidean shape, i.e. its intersection with some \( h_1 Z \times h_2 Z \times \cdots \times h_n Z \). Note that the real point (0,...,0) is mapped onto the digital point (0,...,0) 
CGenericReader  Aim: Provide a mechanism to load with the bestloader according to an image (2D or 3D) filename (by parsing the extension) 
CGenericReader< TContainer, 2, DGtal::uint32_t >  
CGenericReader< TContainer, 2, TValue >  
CGenericReader< TContainer, 3, DGtal::uint32_t >  
CGenericReader< TContainer, 3, DGtal::uint64_t >  
CGenericReader< TContainer, 3, TValue >  
CGenericWriter  Aim: Provide a mechanism to save image (2D or 3D) into file with the best saver loader according to an filename (by parsing the extension) 
CGenericWriter< TContainer, 2, DGtal::Color, TFunctor >  
CGenericWriter< TContainer, 2, TValue, TFunctor >  
CGenericWriter< TContainer, 2, unsigned char, TFunctor >  
CGenericWriter< TContainer, 3, DGtal::uint64_t, TFunctor >  
CGenericWriter< TContainer, 3, TValue, TFunctor >  
CGenericWriter< TContainer, 3, unsigned char, TFunctor >  
CGeodesicsInHeat  This class implements [41] on polygonal surfaces (using Discrete differential calculus on polygonal surfaces) 
CGradientColorMap  Aim: This class template may be used to (linearly) convert scalar values in a given range into a color in a gradient defined by two or more colors 
►CGraphVisitorRange  Aim: Transforms a graph visitor into a single pass input range 
CGenericConstIterator  
CNodeAccessor  
CVertexAccessor  
CGrayscaleColorMap  Aim: This class template may be used to (linearly) convert scalar values in a given range into gray levels 
►CGreedySegmentation  Aim: Computes the greedy segmentation of a range given by a pair of ConstIterators. The last element of a given segment is the first one one of the next segment 
CSegmentComputerIterator  Aim: Specific iterator to visit all the segments of a greedy segmentation 
CGridCurve  Aim: describes, in a cellular space of dimension n, a closed or open sequence of signed dcells (or dscells), d being either equal to 1 or (n1) 
CH5DSpecializations  Aim: implements HDF5 reading and writing for specialized type T 
CH5DSpecializations< TImageFactory, DGtal::int32_t >  Aim: implements HDF5 reading and writing for specialized type DGtal::int32_t 
CH5DSpecializations< TImageFactory, DGtal::int64_t >  Aim: implements HDF5 reading and writing for specialized type DGtal::int64_t 
CH5DSpecializations< TImageFactory, DGtal::uint8_t >  Aim: implements HDF5 reading and writing for specialized type DGtal::uint8_t 
CH5DSpecializations< TImageFactory, double >  Aim: implements HDF5 reading and writing for specialized type double 
►CHalfEdgeDataStructure  Aim: This class represents an halfedge data structure, which is a structure for representing the topology of a combinatorial 2dimensional surface or an embedding of a planar graph in the plane. It does not store any geometry. As a minimal example, these lines of code build two triangles connected by the edge {1,2} 
CEdge  
CHalfEdge  
CTriangle  Represents an unoriented triangle as three vertices 
CHDF5Reader  Aim: Import a HDF5 file 
CHDF5Writer  Aim: Export an Image with the HDF5 format 
CHistogram  Aim: Represents a typical histogram in statistics, which is a discrete estimate of the probability distribution of a continuous variable 
CHueShadeColorMap  Aim: This class template may be used to (linearly) convert scalar values in a given range into a color in a cyclic hue shade colormap, maybe aka rainbow color map. This color map is suitable, for example, to colorize distance functions. By default, only one hue cycle is used 
►CHyperRectDomain  Aim: Parallelepidec region of a digital space, model of a 'CDomain' 
CConstSubRange  Aim: range through some subdomain of all the points in the domain. Defines a constructor taking a domain in parameter plus some additional parameters to specify the subdomain, begin and end methods returning ConstIterator, and rbegin and rend methods returning ConstReverseIterator 
CHyperRectDomain_Iterator  Iterator for HyperRectDomain 
CHyperRectDomain_ReverseIterator  Reverse iterator for HyperRectDomain 
CHyperRectDomain_subIterator  
CImage  Aim: implements association bewteen points lying in a digital domain and values 
CImageAdapter  Aim: implements an image adapter with a given domain (i.e. a subdomain) and 3 functors : g for domain, f for accessing point values and f1 for writing point values 
CImageCache  Aim: implements an images cache with 'read and write' policies 
CImageCacheReadPolicyFIFO  Aim: implements a 'FIFO' read policy cache 
CImageCacheReadPolicyLAST  Aim: implements a 'LAST' read policy cache 
CImageCacheWritePolicyWB  Aim: implements a 'WB (Writeback or Writebehind)' write policy cache 
CImageCacheWritePolicyWT  Aim: implements a 'WT (Writethrough)' write policy cache 
CImageContainerByITKImage  Aim: implements a model of CImageContainer using a ITK Image 
CImageContainerBySTLMap  
►CImageContainerBySTLVector  
CSpanIterator  
CImageFactoryFromHDF5  Aim: implements a factory from an HDF5 file 
CImageFactoryFromImage  Aim: implements a factory to produce images from a "bigger/original" one according to a given domain 
CImageFromSet  Aim: Define utilities to convert a digital set into an image 
CImageLinearCellEmbedder  Aim: a cellular embedder for images. (default constructible, copy constructible, assignable). Model of CCellEmbedder 
CImageSelector  Aim: Automatically defines an adequate image type according to the hints given by the user. 
CImageToConstantFunctor  
CImplicitBall  Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball in nD. 
►CImplicitDigitalSurface  Aim: A model of CDigitalSurfaceContainer which defines the digital surface as the boundary of an implicitly define shape. Compute once the boundary of the surface with a tracking 
CTracker  
CImplicitFunctionDiff1LinearCellEmbedder  Aim: a cellular embedder for implicit functions, (default constructible, copy constructible, assignable). Model of CCellEmbedder and CWithGradientMap 
CImplicitFunctionDiff1LinearCellEmbedderGradientMap  Forward declaration 
CImplicitFunctionLinearCellEmbedder  Aim: a cellular embedder for implicit functions, (default constructible, copy constructible, assignable). Model of CCellEmbedder 
CImplicitHyperCube  Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create an hypercube in nD. 
CImplicitNorm1Ball  Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball for the L_1 norm in nD 
CImplicitPolynomial3Shape  Aim: model of CEuclideanOrientedShape concepts to create a shape from a polynomial 
CImplicitRoundedHyperCube  Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a rounded hypercube in nD. 
►CIndexedDigitalSurface  Aim: Represents a digital surface with the topology of its dual surface. Its aim is to mimick the standard DigitalSurface, but to optimize its traversal and topology services. The idea is simply to number all its vertices (ie surfels), arcs, and faces and to store its topology with an halfedge data structure. It is essentially a PolygonalSurface but with services specific to DigitalSurface, like a tracker, a DigitalSurfaceContainer, etc. In theory, it can replace a DigitalSurface in many algorithms, and is more efficient if you need to do a lot of traversal on it (like many kring operations) 
CIndexedPropertyMap  
CVertexMap  
►CIndexedListWithBlocks  Aim: Represents a mixed list/array structure which is useful in some context. It is essentially a list of blocks 
CAnyBlock  
CBlockPointer  Forward declaration 
CConstIterator  
CFirstBlock  
CIterator  
CValueOrBlockPointer  Used in blocks to finish it or to point to the next block 
CInexactPredicateLpSeparableMetric  Aim: implements separable l_p metrics with approximated predicates 
CInfiniteNumberException  
CInGeneralizedDiskOfGivenRadius  Aim: This class implements an orientation functor that provides a way to determine the position of a given point with respect to the unique circle passing by the same two given points and whose radius and orientation is given 
CInHalfPlaneBy2x2DetComputer  Aim: Class that implements an orientation functor, ie. it provides a way to compute the orientation of three given 2d points. More precisely, it returns: 
CInHalfPlaneBySimple3x3Matrix  Aim: Class that implements an orientation functor, ie. it provides a way to compute the orientation of three given 2d points. More precisely, it returns: 
CInputException  
CInputIteratorWithRankOnSequence  Aim: Useful to create an iterator that returns a pair (value,rank) when visiting a sequence. The sequence is smartly copied within the iterator. Hence, the given sequence need not to persist during the visit. Since it is only an input sequence, it is not necessary to give a valid sequence when creating the end() iterator 
CIntegerComputer  Aim: This class gathers several types and methods to make computation with integers 
CIntegerConverter  — INTEGER/POINT CONVERSION SERVICES — 
CIntegerConverter< dim, DGtal::BigInteger >  
CIntegerConverter< dim, DGtal::int32_t >  
CIntegerConverter< dim, DGtal::int64_t >  
CIntegerSequenceIterator  Aim: It is a simple class that mimics a (non mutable) iterator over integers. You can increment it, decrement it, displace it, compare it, etc. It is useful if you have a collection of consecutive integers, and you wish to create an iterator over it. It is used in the class TriangulatedSurface for example, since vertices are numbers from 0 to nbVertices  1 
CIntegralIntervals  Aim: 
CIntegralInvariantCovarianceEstimator  Aim: This class implement an Integral Invariant estimator which computes for each surfel the covariance matrix of the intersection of the shape with a ball of given radius centered on the surfel 
CIntegralInvariantVolumeEstimator  Aim: This class implement an Integral Invariant estimator which computes for each surfel the volume of the intersection of the shape with a ball of given radius centered on the surfel 
►CIntersectionTargetTrait  Aim: A class for intersection target used for voxelization 
CEdge  Internal Edge structure 
CIntersectionTarget  Internal intersection target structure 
CIntersectionTarget< Space, 26, 1 >  
CIntersectionTarget< Space, 6, 1 >  
CIOException  
CIsAPointVector  Type trait to check if a given type is a PointVector 
CIsAPointVector< PointVector< dim, TEuclideanRing, TContainer > >  Specialization of IsAPointVector for a PointVector 
CIsArithmeticConversionValid  Helper to determine if an arithmetic operation between two given types has a valid result type (ie is valid) 
CIsArithmeticConversionValid< T, U, typename std::conditional< false, ArithmeticConversionType< T, U >, void >::type >  Specialization when arithmetic operation between the two given type is valid 
CIsAssociativeContainer  
CIsCirculator  Aim: Checks whether type IC is a circular or a classical iterator. Static value set to 'true' for a circulator, 'false' otherwise. 
CIsContainer  
CIsMultipleAssociativeContainer  
CIsOrderedAssociativeContainer  
CIsPairAssociativeContainer  
CIsSequenceContainer  
CIsSimpleAssociativeContainer  
CIsUniqueAssociativeContainer  
CIsUnorderedAssociativeContainer  
CIteratorAdapter  This class adapts any lvalue iterator so that operator* returns a member on the element pointed to by the iterator, instead the element itself 
CIteratorCirculatorTraits  Aim: Provides nested types for both iterators and circulators: Type, Category, Value, Difference, Pointer and Reference 
CIteratorCirculatorTraits< T * >  
CIteratorCirculatorTraits< T const * >  
CIteratorCirculatorType  Aim: Provides the type of IC as a nested type: either IteratorType or CirculatorType 
CIteratorCompletion  Aim: Class that uses CRTP to add reverse iterators and ranges to a derived class 
CIteratorCompletionTraits  Aim: Traits that must be specialized for each IteratorCompletion derived class 
►CIteratorCompletionTraits< ArrayImageAdapter< TArrayIterator, TDomain > >  [IteratorCompletionTraits] 
CDistanceFunctor  
CIteratorType  
►CITKDicomReader  Aim: Import a 2D/3D DICOM Image from file series 
CAux  
CAux< ImageContainerByITKImage< Domain, Value >, Domain, OrigValue, TFunctor, Value >  
CITKIOTrait  Aim: Provide type trait for ITK reader and ITK writer 
CITKIOTrait< bool >  
►CITKReader  Aim: Import a 2D/3D Image using the ITK formats 
CAux  
CAux< ImageContainerByITKImage< Domain, Value >, Domain, OrigValue, TFunctor, Value >  
CITKWriter  Export a 2D/3D Image using the ITK formats 
CITKWriter< ImageContainerByITKImage< TDomain, TValue >, TFunctor >  
CIVector  
CIVector< T, TAlloc, true >  
CKanungoNoise  Aim: From a point predicate (model of concepts::CPointPredicate), this class constructs another point predicate as a noisy version of the input one 
CKForm  Aim: KForm represents discrete kforms in the dec package 
CKhalimskyCell  Represents an (unsigned) cell in a cellular grid space by its Khalimsky coordinates 
CKhalimskyPreCell  Represents an unsigned cell in an unbounded cellular grid space by its Khalimsky coordinates 
►CKhalimskyPreSpaceND  Aim: This class is a model of CPreCellularGridSpaceND. It represents the cubical grid as a cell complex, whose cells are defined as an array of integers. The topology of the cells is defined by the parity of the coordinates (even: closed, odd: open) 
CAnyCellCollection  
CCellMap  
CSCellMap  
CSurfelMap  
►CKhalimskySpaceND  Aim: This class is a model of CCellularGridSpaceND. It represents the cubical grid as a cell complex, whose cells are defined as an array of integers. The topology of the cells is defined by the parity of the coordinates (even: closed, odd: open) 
CCellMap  
CSCellMap  
CSurfelMap  
CKhalimskySpaceNDHelper  Internal class of KhalimskySpaceND that provides some optimizations depending on the space type 
CKnot_3_1  Aim: Implement a parametrized knot 3, 1 
CKnot_3_2  Aim: Implement a parametrized knot 3, 2 
CKnot_4_1  Aim: Implement a parametrized knot 4, 1 
CKnot_4_3  Aim: Implement a parametrized knot 4, 3 
CKnot_5_1  Aim: Implement a parametrized knot 5, 1 
CKnot_5_2  Aim: Implement a parametrized knot 5, 2 
CKnot_6_2  Aim: Implement a parametrized knot 6, 2 
CKnot_7_4  Aim: Implement a parametrized knot 7, 4 
CL1LengthEstimator  Aim: a simple model of CGlobalCurveEstimator that compute the length of a curve using the l_1 metric (just add 1/h for every step) 
CL1LocalDistance  Aim: Class for the computation of the L1distance at some point p, from the available distance values of some points lying in the 1neighborhood of p (ie. points at a L1distance to p equal to 1) 
CL2FirstOrderLocalDistance  Aim: Class for the computation of the Euclidean distance at some point p, from the available distance values of some points lying in the 1neighborhood of p (ie. points at a L1distance to p equal to 1) 
CL2FirstOrderLocalDistanceFromCells  Aim: Class for the computation of the Euclidean distance at some point p, from the available distance values in the neighborhood of p. Contrary to L2FirstOrderLocalDistance, the distance values are not available from the points adjacent to p but instead from the (d1)cells lying between p and these points. 
CL2SecondOrderLocalDistance  Aim: Class for the computation of the Euclidean distance at some point p, from the available distance values of some points lying in the neighborhood of p, such that only one of their coordinate differ from the coordinates of p by at most two 
►CLabelledMap  Aim: Represents a map label > data, where the label is an integer between 0 and a constant L1. It is based on a binary coding of labels and a mixed list/array structure. The assumption is that the number of used labels is much less than L. The objective is to minimize the memory usage 
C__AnyBlock  
C__FirstBlock  
CBlockConstIterator  
CBlockIterator  
CBlockPointer  Forward declaration 
CConstIterator  
CDataOrBlockPointer  Used in first block to finish it or to point to the next block 
CKeyCompare  Key comparator class. Always natural ordering 
CValueCompare  Value comparator class. Always natural ordering between keys 
►CLabels  Aim: Stores a set of labels in {O..L1} as a sequence of bits 
CConstEnumerator  
CLagrangeInterpolation  Aim: This class implements Lagrange basis functions and Lagrange interpolation 
CLambdaMST2D  Aim: Simplify creation of Lambda MST tangent estimator 
CLambdaMST2DEstimator  
CLambdaMST3D  Aim: Simplify creation of Lambda MST tangent estimator 
CLambdaMST3DBy2D  Aim: Simplify creation of Lambda MST tangent estimator 
CLambdaMST3DBy2DEstimator  
CLambdaMST3DEstimator  
CLatticePolytope2D  Aim: Represents a 2D polytope, i.e. a convex polygon, in the twodimensional digital plane. The list of points must follow the clockwise ordering 
CLatticeSetByIntervals  Aim: 
CLemniscate2D  Aim: Model of the concept StarShaped represents a lemniscate 
►CLighterSternBrocot  Aim: The SternBrocot tree is the tree of irreducible fractions. This class allows to construct it progressively and to navigate within fractions in O(1) time for most operations. It is well known that the structure of this tree is a coding of the continued fraction representation of fractions 
CFraction  This fraction is a model of CPositiveIrreducibleFraction 
CNode  
►CLightExplicitDigitalSurface  Aim: A model of CDigitalSurfaceContainer which defines the digital surface as connected surfels. The shape is determined by a predicate telling whether a given surfel belongs or not to the shape boundary. The whole boundary is not precomputed nor stored. You may use an iterator to visit it 
CTracker  
CVertexMap  
►CLightImplicitDigitalSurface  Aim: A model of CDigitalSurfaceContainer which defines the digital surface as the boundary of an implicitly define shape. The whole boundary is not precomputed nor stored. You may use an iterator to visit it 
CTracker  
CVertexMap  
►CLightSternBrocot  Aim: The SternBrocot tree is the tree of irreducible fractions. This class allows to construct it progressively and to navigate within fractions in O(1) time for most operations. It is well known that the structure of this tree is a coding of the continued fraction representation of fractions 
CFraction  This fraction is a model of CPositiveIrreducibleFraction 
CNode  
CLinearAlgebra  Aim: A utility class that contains methods to perform integral linear algebra 
CLinearizer  Aim: Linearization and delinearization interface for domains 
CLinearizer< HyperRectDomain< TSpace >, TStorageOrder >  Aim: Linearization and delinearization interface for HyperRectDomain 
CLinearOperator  Aim: LinearOperator represents discrete linear operator between discrete kforms in the DEC package 
CLInfLocalDistance  Aim: Class for the computation of the LInfdistance at some point p, from the available distance values of some points lying in the 1neighborhood of p (ie. points at a L1distance to p equal to 1) 
CLocalEstimatorFromSurfelFunctorAdapter  Aim: this class adapts any local functor on digital surface element to define a local estimator. This class is model of CDigitalSurfaceLocalEstimator 
CLOG2  
CLOG2< 1 >  
CLOG2< 2 >  
►CLongvolReader  Aim: implements methods to read a "Longvol" file format (with DGtal::uint64_t value type) 
CHeaderField  
CLongvolWriter  Aim: Export a 3D Image using the Longvol formats (volumetric image with DGtal::uint64_t value type) 
CLpMetric  Aim: implements l_p metrics 
CMapAssociativeCategory  
CMaximalSegmentSliceEstimation  Aim: 
CMeaningfulScaleAnalysis  Aim: This class implements different methods used to define the meaningful scale analysis as proposed in [65] . In particular, it uses the Profile class to represent a multiscale profile and to compute a meaningful scale. It also permits to get a noise estimation from the given profile 
CMeasure  Aim: Implements a simple measure computation (in the Lesbegue sens) of a set. In dimension 2, it corresponds to the area of the set, to the volume in dimension 3,.. 
CMeasureOfStraightLines  The aim of this class is to compute the measure in the Lebesgues sense of the set of straight lines associated to domains defined as polygons in the (a,b)parameter space. This parameter space maps the line $axy+b=0$ to the point $(a,b)$ 
CMelkmanConvexHull  Aim: This class implements the online algorithm of Melkman for the computation of the convex hull of a simple polygonal line (without selfintersection) [Melkman, 1987: [87]] 
CMemoryException  
►CMesh  Aim: This class is defined to represent a surface mesh through a set of vertices and faces. By using the default constructor, the mesh does not store any color information (it can be changed by setting the default constructor parameter saveFaceColor to 'true') 
CCompPoints  
CMeshHelpers  Aim: Static class that provides builder and converters between meshes 
CMeshReader  Aim: Defined to import OFF and OFS surface mesh. It allows to import a Mesh object and takes into accouts the optional color faces 
CMeshVoxelizer  Aim: A class for computing the digitization of a triangle or a Mesh 
CMeshWriter  Aim: Export a Mesh (Mesh object) in different format as OFF and OBJ) 
►CMetricAdjacency  Aim: Describes digital adjacencies in digital spaces that are defined with the 1norm and the infinitynorm 
CVertexMap  
CMLPLengthEstimator  Aim: a model of CGlobalCurveEstimator that computes the length of a digital curve using its MLP (given by the FP) 
CModuloComputer  Implements basic functions on modular arithmetic 
CMorton  Aim: Implements the binary Morton code construction in nD 
CMostCenteredMaximalSegmentEstimator  Aim: A model of CLocalCurveGeometricEstimator that assigns to each element of a (sub)range a quantity estimated from the most centered maximal segment passing through this element 
CMPolynomial  Aim: Represents a multivariate polynomial, i.e. an element of \( K[X_0, ..., X_{n1}] \), where K is some ring or field 
CMPolynomial< 0, TRing, TAlloc >  Aim: Specialization of MPolynomial for degree 0 
CMPolynomialDerivativeComputer  
CMPolynomialDerivativeComputer< 0, 0, Ring, Alloc >  
CMPolynomialDerivativeComputer< 0, n, Ring, Alloc >  
CMPolynomialDerivativeComputer< N, 0, Ring, Alloc >  
CMPolynomialEvaluator  
CMPolynomialEvaluator< 1, TRing, TAlloc, TX >  
►CMPolynomialEvaluatorImpl  
CEvalFun  
CEvalFun2  
►CMPolynomialEvaluatorImpl< 1, TRing, TOwner, TAlloc, TX >  
CEvalFun  
CMPolynomialGrammar  
►CMPolynomialReader  Aim: This class converts a string polynomial expression in a multivariate polynomial 
CExprNodeMaker  
CMultimapAssociativeCategory  
CMultipleAssociativeCategory  
CMultisetAssociativeCategory  
CMultiStatistics  Aim: This class stores a set of sample values for several variables and can then compute different statistics, like sample mean, sample variance, sample unbiased variance, etc 
CNaive3DDSSComputer  Aim: Dynamic recognition of a 3ddigital straight segment (DSS) 
CNaiveDSL  Aim: This class is an alias of ArithmeticalDSS for naive DSL. It represents a naive digital straight line (DSL), ie. the set of digital points \( (x,y) \in \mathbb{Z}^2 \) such that \( \mu \leq ax  by < \mu + \omega \) with \( a,b,\mu,\omega \in \mathbb{Z} \), \( \gcd(a,b) = 1 \) and \( \omega = \max(a,b) \). Note that any DSL such that \( \omega = \max(a,b) \) is simply 8connected 
CNaiveDSS8  Aim: This class represents a standard digital straight segment (DSS), ie. the sequence of simply 8connected digital points contained in a naive digital straight line (DSL) between two points of it. This class is an alias of ArithmeticalDSS 
►CNaiveParametricCurveDigitizer3D  Aim: Digitization of 3D parametric curves. This method produces, for good parameters step and k_next, a 26connected digital curves obtained from a digitization process of 3D parametric curves 
CKConstIter  A structure used for making iterations over digital curve with respect to K_NEXT 
CKIter  A structure used for making iterations over digital curve with respect to K_NEXT 
CNegate  
CNegate< TagFalse >  
CNegate< TagTrue >  
CNeighborhoodConvexityAnalyzer  Aim: A class that models a \( (2k+1)^d \) neighborhood and that provides services to analyse the convexity properties of a digital set within this neighborhood 
CNGon2D  Aim: Model of the concept StarShaped represents any regular kgon in the plane 
CNormalCycleComputer  Aim: Utility class to compute curvatures measures induced by (1) the normal cycle induced by a SurfaceMesh, (2) the standard LipschitzKilling invariant forms of area and curvatures 
CNormalCycleFormula  Aim: A helper class that provides static methods to compute normal cycle formulas of curvatures 
CNormalFromDCAEstimator  
CNormalVectorEstimatorLinearCellEmbedder  Aim: model of cellular embedder for normal vector estimators on digital surface, (default constructible, copy constructible, assignable) 
CNotContainerCategory  
CNumberTraits  Aim: The traits class for all models of Cinteger 
CNumberTraitsImpl  Aim: The traits class for all models of Cinteger (implementation) 
CNumberTraitsImpl< DGtal::BigInteger, Enable >  Specialization of NumberTraitsImpl for DGtal::BigInteger 
CNumberTraitsImpl< T, typename std::enable_if< std::is_floating_point< T >::value >::type >  Specialization of NumberTraitsImpl for fundamental floatingpoint types 
CNumberTraitsImpl< T, typename std::enable_if< std::is_integral< T >::value >::type >  Specialization of NumberTraitsImpl for fundamental integer types 
►CObject  Aim: An object (or digital object) represents a set in some digital space associated with a digital topology 
CEdge  
CVertexMap  
►COneBalancedWordComputer  Aim: 
CCodeHandler  
CCodeHandler< TIterator, BidirectionalCategory >  
CCodeHandler< TIterator, RandomAccessCategory >  
CConstPointIterator  
COneItemOutputIterator  Aim: model of output iterator, ie incrementable and writable iterator, which only stores in a variable the last assigned item 
COpInSTLContainers  
COpInSTLContainers< Container, std::reverse_iterator< typename Container::iterator > >  
COppositeDuality  
COppositeDuality< DUAL >  
COppositeDuality< PRIMAL >  
COrderedAlphabet  Aim: Describes an alphabet over an interval of (ascii) letters, where the lexicographic order can be changed (shifted, reversed, ...). Useful for the arithmetic minimum length polygon (AMLP) 
COrderedAssociativeCategory  
COrderedLinearRegression  Description of class 'OrderedLinearRegression' 
COutputIteratorAdapter  Aim: Adapts an output iterator i with a unary functor f, both given at construction, so that the element pointed to by i is updated with a given value through f 
COwningOrAliasingPtr  Aim: This class describes a smart pointer that is, given the constructor called by the user, either an alias pointer on existing data or an owning pointer on a copy 
CPairAssociativeCategory  
CParallelStrip  Aim: A parallel strip in the space is the intersection of two parallel halfplanes such that each halfplane includes the other 
CParameters  
CParameterValue  
CParametricShapeArcLengthFunctor  Aim: implements a functor that estimates the arc length of a paramtric curve 
CParametricShapeCurvatureFunctor  Aim: implements a functor that computes the curvature at a given point of a parametric shape 
CParametricShapeTangentFunctor  Aim: implements a functor that computes the tangent vector at a given point of a parametric shape 
CParDirCollapse  Aim: Implements thinning algorithms in cubical complexes. The implementation supports any model of cubical complex, for instance a DGtal::CubicalComplex< KhalimskySpaceND< 3, int > >. Three approaches are provided. The first—ParDirCollapse—bases on directional collapse of free pairs of faces. Second—CollapseSurface—is an extension of ParDirCollapse such that faces of dimension one lower than the dimension of the complex are kept. The last approach —CollapseIsthmus—is also an extension of ParDirCollapse such that faces of dimension one lower than the complex are preserved when they do not contain free faces of dimension two lower than the complex. Paper: Chaussard, J. and Couprie, M., Surface Thinning in 3D Cubical Complexes, Combinatorial Image Analysis, (2009) 
CPattern  Aim: This class represents a pattern, i.e. the path between two consecutive upper leaning points on a digital straight line 
CPGMReader  Aim: Import a 2D or 3D using the Netpbm formats (ASCII mode) 
CPGMWriter  Aim: Export a 2D and a 3D Image using the Netpbm PGM formats (ASCII mode) 
►CPlaneProbingDigitalSurfaceLocalEstimator  Aim: Adapt a planeprobing estimator on a digital surface to estimate normal vectors 
CProbingFrame  
CPlaneProbingHNeighborhood  Aim: Represent a way to probe the Hneighborhood 
►CPlaneProbingNeighborhood  Aim: A base virtual class that represents a way to probe a neighborhood, used in the plane probing based estimators, see DGtal::PlaneProbingTetrahedronEstimator or DGtal::PlaneProbingParallelepipedEstimator 
CUpdateOperation  
►CPlaneProbingParallelepipedEstimator  Aim: 
CNotAbovePredicate  
CPlaneProbingR1Neighborhood  Aim: Represent a way to probe the Rneighborhood, with the R1 optimization, see [103] for details 
CPlaneProbingRNeighborhood  Aim: Represent a way to probe the Rneighborhood 
CPlaneProbingTetrahedronEstimator  Aim: A class that locally estimates a normal on a digital set using only a predicate "does a point x belong to the digital set or not?" 
CPointListReader  Aim: Implements method to read a set of points represented in each line of a file 
CPointVector  Aim: Implements basic operations that will be used in Point and Vector classes 
CPolygonalCalculus  Implements differential operators on polygonal surfaces from [45] 
►CPolygonalSurface  Aim: Represents a polygon mesh, i.e. a 2dimensional combinatorial surface whose faces are (topologically at least) simple polygons. The topology is stored with a halfedge data structure. This object stored the positions of vertices in space. If you need further data attached to the surface, you may use property maps (see PolygonalSurface::makeVertexMap ) 
CIndexedPropertyMap  
CVertexMap  
CPOW  
CPOW< X, 0 >  
CPOW< X, 1 >  
CPowerMap  Aim: Implementation of the linear in time Power map construction 
CPPMReader  Aim: Import a 2D or 3D using the Netpbm formats (ASCII mode) 
CPPMWriter  Aim: Export a 2D and a 3D Image using the Netpbm PPM formats (ASCII mode) 
CPreCellDirectionIterator  This class is useful for looping on all "interesting" coordinates of a precell 
CPredicateFromOrientationFunctor2  Aim: Small adapter to models of COrientationFunctor2. It is a model of concepts::CPointPredicate. It is also a ternary predicate on points, useful for basic geometric tasks such as convex hull computation 
CPreimage2D  Aim: Computes the preimage of the 2D Euclidean shapes crossing a sequence of n straigth segments in O(n), with the algorithm of O'Rourke (1981) 
CProfile  Aim: This class can be used to represent a profile (PX, PY) defined from an input set of samples (Xi, Yi). For all sample (Xk, Yk) having the same value Xk, the associated value PY is computed (by default) by the mean of the values Yk. Note that other definitions can be used (MAX, MIN or MEDIAN). Internally each sample abscissa is an instance of DGtal::Statistic 
Cpromote_trait  
Cpromote_trait< int32_t, int64_t >  
CQuantifiedColorMap  Aim: A modifier class that quantifies any colormap into a given number of colors. It is particularly useful when rendering colored objects, since for instance blender is very slow to load many different materials 
►CQuickHull  Aim: Implements the quickhull algorithm by Barber et al. [9], a famous arbitrary dimensional convex hull computation algorithm. It relies on dedicated geometric kernels for computing and comparing facet geometries 
CFacet  
CRandomAccessCategory  
CRandomColorMap  Aim: access to random color from a gradientColorMap 
CRawReader  Aim: Raw binary import of an Image 
CRawWriter  Aim: Raw binary export of an Image 
CRayIntersectionPredicate  This class implements various intersection predicates between a ray and a triangle, a quad or a surfel in dimension 3 
CRealFFT< HyperRectDomain< TSpace >, T >  
CReducedMedialAxis  Aim: Implementation of the separable medial axis extraction 
CRegularBinner  Aim: Represents an elementary functor that partitions quantities into regular intervals, given a range [min,max] range and a number nb of intervals (each interval is called a bin) 
CRegularPointEmbedder  Aim: A simple point embedder where grid steps are given for each axis. Note that the real point (0,...,0) is mapped onto the digital point (0,...,0) 
CReverseDistanceTransformation  Aim: Implementation of the linear in time reverse distance transformation for separable metrics 
CReverseIterator  This class adapts any bidirectional iterator so that operator++ calls operator and vice versa 
CRosenProffittLocalLengthEstimator  Aim: RosenProffitt Length Estimator 
CRowMajorStorage  Tag (empty structure) specifying a rowmajor storage order 
►CSaturatedSegmentation  Aim: Computes the saturated segmentation, that is the whole set of maximal segments within a range given by a pair of ConstIterators (maximal segments are segments that cannot be included in greater segments) 
CSegmentComputerIterator  Aim: Specific iterator to visit all the maximal segments of a saturated segmentation 
CSegmentComputerTraits  Aim: Provides the category of the segment computer {ForwardSegmentComputer,BidirectionalSegmentComputer, DynamicSegmentComputer, DynamicBidirectionalSegmentComputer} 
CSeparableMetricAdapter  Aim: Adapts any model of CMetric to construct a separable metric (model of CSeparableMetric) 
CSequenceCategory  
CSetAssociativeCategory  
CSetFromImage  Aim: Define utilities to convert a digital set into an image 
CSetMode  Modifier class in a Board2D stream. Useful to choose your own mode for a given class. Realizes the concept CDrawableWithBoard2D 
CSetMode3D  Modifier class in a Display3D stream. Useful to choose your own mode for a given class. Realizes the concept CDrawableWithDisplay3D 
CSetName3D  
►CSetOfSurfels  Aim: A model of CDigitalSurfaceContainer which defines the digital surface as connected surfels. The shape is determined by the set of surfels that composed the surface. The set of surfels is stored in this container 
CTracker  
CSetSelectCallback3D  
CSetValueIterator  Aim: implements an output iterator, which is able to write values in an underlying image, by calling its setValue method 
CShapes  Aim: A utility class for constructing different shapes (balls, diamonds, and others) 
►CShortcuts  Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface with few lines of code. The drawback is that you use specific types or objects, which could lead to faster code or more compact data structures 
CCellReader  
CCellWriter  
CSCellReader  
CSCellWriter  
CValueReader  
CValueWriter  
CShortcutsGeometry  Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface in a few lines. The drawback is that you use specific types or objects, which could lead to faster code or more compact data structures 
CShroudsRegularization  Aim: Implements the Shrouds Regularization algorithm of Nielson et al [92] 
CSignal  Aim: Represents a discrete signal, periodic or not. The signal can be passed by value since it is only cloned when modified 
CSignalData  
CSignedKhalimskyCell  Represents a signed cell in a cellular grid space by its Khalimsky coordinates and a boolean value 
CSignedKhalimskyPreCell  Represents a signed cell in an unbounded cellular grid space by its Khalimsky coordinates and a boolean value 
CSimple2x2DetComputer  Aim: Small class useful to compute the determinant of a 2x2 matrix from its four coefficients, ie. \( \begin{vmatrix} a & x \\ b & y \end{vmatrix} \) 
CSimpleAssociativeCategory  
CSimpleConstRange  Aim: model of CConstRange that adapts any range of elements bounded by two iterators [itb, ite) and provides services to (circularly)iterate over it (in a readonly manner) 
CSimpleDistanceColorMap  Aim: simple blue to red colormap for distance information for instance 
CSimpleIncremental2x2DetComputer  Aim: Small class useful to compute, in an incremental way, the determinant of a 2x2 matrix from its four coefficients, ie. \( \begin{vmatrix} a & x \\ b & y \end{vmatrix} \) 
CSimpleLinearRegression  Description of class 'SimpleLinearRegression' 
CSimpleMatrix  Aim: implements basic MxN Matrix services (M,N>=1) 
CSimpleMatrixSpecializations  Aim: Implement internal matrix services for specialized matrix size 
CSimpleMatrixSpecializations< TMatrix, 1, 1 >  Aim: 
CSimpleMatrixSpecializations< TMatrix, 2, 2 >  Aim: 
CSimpleMatrixSpecializations< TMatrix, 3, 3 >  Aim: 
CSimpleRandomAccessConstRangeFromPoint  Aim: model of CConstBidirectionalRangeFromPoint that adapts any range of elements bounded by two iterators [itb, ite) and provides services to (circularly)iterate over it (in a readonly manner) 
CSimpleRandomAccessRangeFromPoint  Aim: model of CBidirectionalRangeFromPoint that adapts any range of elements bounded by two iterators [itb, ite) and provides services to (circularly)iterate over it (in a readonly manner) 
►CSpaceND  
CSubcospace  Define the type of a sub coSpace 
CSubspace  Define the type of a subspace 
CSpatialCubicalSubdivision  Aim: This class is a data structure that subdivides a rectangular domains into cubical domains of size \( r^n \) in order to store points into different bins (each cubical domain is a bin, characterized by one coordinate). This data structure may be used for proximity queries, generally to get the points at distance r from a given point 
CSpeedExtrapolator  Aim: Class for the computation of the a speed value at some point p, from the available distance values and speed values of some points lying in the 1neighborhood of p (ie. points at a L1distance to p equal to 1) in order to extrapolate a speed field in the normal direction to the interface 
CSphericalAccumulator  Aim: implements an accumulator (as histograms for 1D scalars) adapted to spherical point samples 
CSphericalTriangle  Aim: Represent a triangle drawn onto a sphere of radius 1 
CSplitter  
CStabbingCircleComputer  Aim: Online recognition of a digital circular arcs (DCA) defined as a sequence of connected grid edges such that there is at least one (Euclidean) circle that separates the centers of the two incident pixels of each grid edge 
CStabbingLineComputer  Aim: Online recognition of a digital straight segment (DSS) defined as a sequence of connected grid edges such that there is at least one straight line that separates the centers of the two incident pixels of each grid edge 
CStandardDSL  Aim: This class is an alias of ArithmeticalDSS for standard DSL. It represents a standard digital straight line (DSL), ie. the set of digital points \( (x,y) \in \mathbb{Z}^2 \) such that \( \mu \leq ax  by < \mu + \omega \) with \( a,b,\mu,\omega \in \mathbb{Z} \), \( \gcd(a,b) = 1 \) and \( \omega = a + b \). Note that any DSL such that \( \omega = a + b \) is simply 4connected 
►CStandardDSLQ0  Aim: Represents a digital straight line with slope in the first quadrant (Q0: x >= 0, y >= 0 ) 
CConstIterator  
CStandardDSS4  Aim: This class represents a standard digital straight segment (DSS), ie. the sequence of simply 4connected digital points contained in a standard digital straight line (DSL) between two points of it. This class is an alias of ArithmeticalDSS 
CStandardDSS6Computer  Aim: Dynamic recognition of a 3ddigital straight segment (DSS) 
CStarShaped2D  
CStarShaped3D  
CStatistic  Aim: This class processes a set of sample values for one variable and can then compute different statistics, like sample mean, sample variance, sample unbiased variance, etc. It is minimalistic for space efficiency. For multiple variables, sample storage and others, see Statistics class 
CSTBReader  Aim: Image reader using the stb_image.h header only code 
CSTBWriter  Aim: Image Writer using the stb_image.h header only code 
►CStdMapRebinder  
CRebinder  
►CSternBrocot  Aim: The SternBrocot tree is the tree of irreducible fractions. This class allows to construct it progressively and to navigate within fractions in O(1) time for most operations. It is well known that the structure of this tree is a coding of the continued fraction representation of fractions 
CFraction  This fraction is a model of CPositiveIrreducibleFraction 
CNode  
CSTLMapToVertexMapAdapter  Aim: This class adapts any map of the STL to match with the CVertexMap concept 
CStraightLineFrom2Points  Aim: Represents a straight line uniquely defined by two 2D points and that is able to return for any given 2D point its signed distance to itself 
CStyle2DFactory  
►CSurfaceMesh  Aim: Represents an embedded mesh as faces and a list of vertices. Vertices may be shared among faces but no specific topology is required. However, you also have methods to navigate between neighbor vertices, faces, etc. The mesh can be equipped with normals at faces and/or vertices 
CVertexMap  
CSurfaceMeshHelper  Aim: An helper class for building classical meshes 
CSurfaceMeshMeasure  Aim: stores an arbitrary measure on a SurfaceMesh object. The measure can be spread onto its vertices, edges, or faces. This class is notably used by CorrectedNormalCurrentComputer and NormalCycleComputer to store the curvature measures, which may be located on different cells. The measure can be scalar or any other summable type (see template parameter TValue) 
CSurfaceMeshReader  Aim: An helper class for reading mesh files (Wavefront OBJ at this point) and creating a SurfaceMesh 
CSurfaceMeshWriter  Aim: An helper class for writing mesh file formats (Waverfront OBJ at this point) and creating a SurfaceMesh 
CSurfaces  Aim: A utility class for constructing surfaces (i.e. set of (n1)cells) 
CSurfelAdjacency  Aim: Represent adjacencies between surfel elements, telling if it follows an interior to exterior ordering or exterior to interior ordering. It allows tracking of boundaries and of surfaces 
CSurfelNeighborhood  Aim: This helper class is useful to compute the neighboring surfels of a given surfel, especially over a digital surface or over an object boundary. Two signed surfels are incident if they share a common n2 cell. This class uses a SurfelAdjacency so as to determine adjacent surfels (either looking for them from interior to exterior or inversely) 
►CSymmetricConvexExpander  Aim: SymmetricConvexExpander computes symmetric fully convex subsets of a given digital set 
CNodeComparator  
CTableReader  Aim: Implements method to read a set of numbers represented in each line of a file 
CTagFalse  
CTagTrue  
CTagUnknown  
►CTangencyComputer  Aim: A class that computes tangency to a given digital set. It provides services to compute all the cotangent points to a given point, or to compute shortest paths 
►CShortestPaths  
CComparator  
CTangentAngleFromDSSEstimator  
CTangentFromBinomialConvolverFunctor  Aim: This class is a functor for getting the tangent vector of a binomial convolver 
CTangentFromDCAEstimator  
►CTangentFromDSS2DFunctor  
CValue  
CTangentFromDSS3DBy2DFunctor  
►CTangentFromDSS3DFunctor  
CValue  
CTangentFromDSSEstimator  
CTangentVectorFromDSSEstimator  
CTickedColorMap  Aim: This class adapts any colormap to add "ticks" in the colormap colors 
►CTiledImage  Aim: implements a tiled image from a "bigger/original" one from an ImageFactory 
CTiledIterator  
CTiledImageBidirectionalConstRangeFromPoint  Aim: model of CConstBidirectionalRangeFromPoint that adapts a TiledImage range of elements bounded by two iterators [itb, ite) and provides services to (circularly)iterate over it (in a readonly manner) 
CTiledImageBidirectionalRangeFromPoint  Aim: model of CBidirectionalRangeFromPoint that adapts a TiledImage range of elements bounded by two iterators [itb, ite) and provides services to (circularly)iterate over it 
CTimeStampMemoizer  Aim: A generic class to store a given maximum number of pairs (key, value). The class tends to memorize pairs which are accessed more frequently than others. It is thus a memoizer, which is used to memorize the result of costly computations. The memoization principle is simple: a timestamp is attached to a pair (key,value). Each time a query is made, if the item was memoized, the result is returned while the timestamp of the item is updated. User can also add or update a value in the memoizer, which updates also its timestamp. After adding a pair (key,value), if the maximal number of items is reached, at least the oldest half (or a fraction) of the items are deleted, leaving space for storing new pairs (key,value) 
CToDGtalCategory  Aim: Provides the DGtal category matching C {ForwardCategory,BidirectionalCategory,RandomAccessCategory} 
CToDGtalCategory< boost::bidirectional_traversal_tag >  
CToDGtalCategory< boost::forward_traversal_tag >  
CToDGtalCategory< boost::iterators::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::bidirectional_traversal_tag > >  
CToDGtalCategory< boost::iterators::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::forward_traversal_tag > >  
CToDGtalCategory< boost::iterators::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::random_access_traversal_tag > >  
CToDGtalCategory< boost::random_access_traversal_tag >  
CToDGtalCategory< std::bidirectional_iterator_tag >  
CToDGtalCategory< std::forward_iterator_tag >  
CToDGtalCategory< std::random_access_iterator_tag >  
CTrace  Implementation of basic methods to trace out messages with indentation levels 
CTraceWriter  Virtual Class to implement trace writers 
CTraceWriterFile  
CTraceWriterTerm  Implements trace prefix for color terminals 
CTransformedPrism  Class to modify the position and scale to construct better illustration mode 
CTranslate2DDomain  Class to modify the data of an given image and also the possibility to translate it (optional) 
►CTriangulatedSurface  Aim: Represents a triangulated surface. The topology is stored with a halfedge data structure. This object stored the positions of vertices in space. If you need further data attached to the surface, you may use property maps (see TriangulatedSurface::makeVertexMap ) 
CIndexedPropertyMap  
CVertexMap  
CTrueDigitalSurfaceLocalEstimator  Aim: An estimator on digital surfaces that returns the reference local geometric quantity. This is used for comparing estimators 
CTrueGlobalEstimatorOnPoints  Aim: Computes the true quantity associated to a parametric shape or to a subrange associated to a parametric shape 
CTrueLocalEstimatorOnPoints  Aim: Computes the true quantity to each element of a range associated to a parametric shape 
CTwoStepLocalLengthEstimator  Aim: a simple model of CGlobalCurveEstimator that compute the length of a curve using the l_1 metric (just add 1/h for every step) 
►CUmbrellaComputer  Aim: Useful for computing umbrellas on 'DigitalSurface's, ie set of n1 cells around a n3 cell 
CState  
CUniqueAssociativeCategory  
CUnorderedAssociativeCategory  
CUnorderedMapAssociativeCategory  
CUnorderedMultimapAssociativeCategory  
CUnorderedMultisetAssociativeCategory  
CUnorderedSetAssociativeCategory  
►CUnorderedSetByBlock  
Cconst_iterator  Read iterator on set elements. Model of ForwardIterator 
Citerator  Readwrite iterator on set elements. Model of ForwardIterator 
CUpdate2DDomainPosition  Class to modify the position and orientation of an 2D domain 
CUpdateImage3DEmbedding  Class to modify the 3d embedding of the image (useful to display not only 2D slice images). The embdding can be explicitly given from the 3D position of the four bounding points 
CUpdateImageData  Class to modify the data of an given image and also the possibility to translate it (optional) 
CUpdateImagePosition  Class to modify the position and orientation of an textured 2D image 
CUpdateLastImagePosition  Class to modify the position and orientation of an textured 2D image 
CVCMDigitalSurfaceLocalEstimator  Aim: This class adapts a VoronoiCovarianceMeasureOnDigitalSurface to be a model of CDigitalSurfaceLocalEstimator. It uses the Voronoi Covariance Measure to estimate geometric quantities. The type TVCMGeometricFunctor specifies which is the estimated quantity. For instance, VCMGeometricFunctors::VCMNormalVectorFunctor returns the estimated VCM surface outward normal for given surfels 
CVectorField  Aim: VectorField represents a discrete vector field in the dec package. Vector field values are attached to 0cells with the same duality as the vector field 
CVectorsInHeat  This class implements [111] on polygonal surfaces (using Discrete differential calculus on polygonal surfaces) 
►CViewer3D  
CCompFarthestPolygonFromCamera  
CCompFarthestSurfelFromCamera  
CCompFarthestTriangleFromCamera  
CCompFarthestVoxelFromCamera  
CExtension  
CGLTextureImage  
CImage2DDomainD3D  
CTextureImage  
CViewer3DFactory  Factory for GPL Viewer3D: 
►CVolReader  Aim: implements methods to read a "Vol" file format 
CHeaderField  
CVolWriter  Aim: Export a 3D Image using the Vol formats 
►CVoronoiCovarianceMeasure  Aim: This class precomputes the Voronoi Covariance Measure of a set of points. It can compute the covariance measure of an arbitrary function with given support 
CCharacteristicSetPredicate  
►CVoronoiCovarianceMeasureOnDigitalSurface  Aim: This class specializes the Voronoi covariance measure for digital surfaces. It adds notably the embedding of surface elements, the diagonalisation of the VCM, and the orientation of the first VCM eigenvector toward the interior of the surface 
CEigenStructure  Structure to hold a diagonalized matrix 
CNormals  Structure to hold the normals for each surfel (the VCM one and the trivial one) 
CVoronoiMap  Aim: Implementation of the linear in time Voronoi map construction 
CVoronoiMapComplete  Aim: Implementation of the linear in time Voronoi map construction 
CVoxelComplex  This class represents a voxel complex living in some Khalimsky space. Voxel complexes are derived from 
CWarning_promote_trait_not_specialized_for_this_case  
CWindingNumbersShape  Aim: model of a CEuclideanOrientedShape from an implicit function from an oriented point cloud. The implicit function is given by the generalized winding number of the oriented point cloud [10] . We use the libIGL implementation 
CXe_kComputer  
CXe_kComputer< 0, Ring, Alloc >  
►NLibBoard  
NFonts  
CArc  An arc 
CArrow  A line between two points with an arrow at one extremity 
►CBoard  Class for EPS, FIG or SVG drawings 
CState  
CCircle  A circle 
CDot  A line between two points 
CEllipse  An ellipse 
CGouraudTriangle  A triangle with shaded filling according to colors given for each vertex 
CGroup  A group of shapes. A group is basically a ShapeList except that when rendered in either an SVG of a FIG file, it is a true compound element 
CImage  Used to draw image in figure 
CLine  A line between two points 
CMessageStream  
CPath  A path, according to Postscript and SVG definition 
CPoint  Struct representing a 2D point 
CPolyline  A polygonal line described by a series of 2D points 
CQuadraticBezierCurve  A quadratic Bezier curve having 3 control points. NB. It is also a parabola arc 
CRect  Struct representing a rectangle on the plane 
CRectangle  A rectangle 
CShape  Abstract structure for a 2D shape 
CShapeList  A group of shapes 
CText  A piece of text 
CTransform  Base class for transforms 
CTransformCairo  Structure representing a scaling and translation suitable for an Cairo output 
CTransformEPS  Structure representing a scaling and translation suitable for an EPS output 
CTransformFIG  Structure representing a scaling and translation suitable for an XFig output 
CTransformSVG  Structure representing a scaling and translation suitable for an SVG output 
CTransformTikZ  Structure representing a scaling and translation suitable for an TikZ output 
CTriangle  A triangle. Basically a Polyline with a convenient constructor 
►Nstd  STL namespace 
Chash< DGtal::BigInteger >  
Chash< DGtal::KhalimskyCell< dim, TInteger > >  Extend std namespace to define a std::hash function on DGtal::KhalimskyCell 
Chash< DGtal::PointVector< dim, EuclideanRing, Container > >  
Chash< DGtal::SignedKhalimskyCell< dim, TInteger > >  Extend std namespace to define a std::hash function on DGtal::SignedKhalimskyCell 