DGtal  0.9.2
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567]
 CDGtal::LabelledMap< TData, L, TWord, N, M >::__AnyBlock
 CDGtal::LabelledMap< TData, L, TWord, N, M >::__FirstBlock
 Cboost::AdaptableBinaryFunction< Func, First, Second >Go to http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html
 Cboost::AdaptableBinaryPredicate< Func, First, Second >Go to http://www.sgi.com/tech/stl/AdaptableBinaryPredicate.html
 Cboost::AdaptableGenerator< Func, Return >Go to http://www.sgi.com/tech/stl/AdaptableGenerator.html
 Cboost::AdaptablePredicate< Func, Arg >Go to http://www.sgi.com/tech/stl/AdaptablePredicate.html
 Cboost::AdaptableUnaryFunction< Func, Return, Arg >Go to http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html
 Cadjacency_graph_tag
 Cboost::AdjacencyGraphConcept< G >Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/AdjacencyGraph.html
 CDGtal::Alias< T >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)
 CDGtal::AlphaThickSegmentComputer< TInputPoint, TConstIterator >Aim: This class is devoted to the recognition of alpha thick segments as described in [31] . 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
 CDGtal::functors::AndBoolFct2
 CDGtal::AngleComputer
 CDGtal::AngleLinearMinimizerAim: Used to minimize the angle variation between different angles while taking into accounts min and max constraints. Example (
 CDGtal::IndexedListWithBlocks< TValue, N, M >::AnyBlock
 CDGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc
 CDGtal::ArithDSSIterator< TInteger, connectivity >Aim: An iterator on the points of a Digital Straight Segment. Template parameters are the integer type and the connectivity of the DSS (8-connectivity as default value)
 CDGtal::ArithmeticalDSL< TCoordinate, TInteger, adjacency >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 8-connected (resp. 4-connected)
 CDGtal::ArithmeticalDSL< Coordinate, Integer, adjacency >
 CDGtal::ArithmeticalDSL< TCoordinate, TInteger, 4 >
 CDGtal::ArithmeticalDSL< TCoordinate, TInteger, 8 >
 CDGtal::ArithmeticalDSLKernel< TCoordinate, adjacency >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:
 CDGtal::ArithmeticalDSLKernel< TCoordinate, 4 >
 CDGtal::ArithmeticalDSS< TCoordinate, TInteger, adjacency >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
 CDGtal::ArithmeticalDSS< Coordinate, Integer, adjacency >
 CDGtal::ArithmeticalDSS< TCoordinate, TInteger, 4 >
 CDGtal::ArithmeticalDSS< TCoordinate, TInteger, 8 >
 CDGtal::ArithmeticalDSSComputer< TIterator, TInteger, adjacency >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
 CDGtal::ArithmeticalDSSComputer< IteratorAdapter, TInteger, connectivity >
 CDGtal::ArithmeticalDSSComputer< TIterator, TInteger, 4 >
 CDGtal::ArithmeticalDSSFactory< TCoordinate, TInteger, adjacency >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)
 Cboost::Assignable< T >Go to http://www.sgi.com/tech/stl/Assignable.html
 Cboost::Assignable< I >
 Cboost::Assignable< X >
 Cboost::AssociativeContainer< C >Go to http://www.sgi.com/tech/stl/AssociativeContainer.html
 CDGtal::AvnaimEtAl2x2DetSignComputer< TInteger >Aim: Class that provides a way of computing the sign of the determinant of a 2x2 matrix from its four coefficients, ie
 Cboost::BackInsertionSequence< C >Go to http://www.sgi.com/tech/stl/BackInsertionSequence.html
 CDGtal::BackInsertionSequenceToStackAdapter< TSequence >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
 CDGtal::FrechetShortcut< TIterator, TInteger >::Backpath
 CDGtal::functors::BallConstantFunction< TScalar >
 CDGtal::functors::BallConstantPointFunction< TPoint, TScalar >
 CDGtal::functors::BasicDomainSubSampler< TDomain, TInteger, TValue >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
 Cbidirectional_iterator_archetype
 Cboost::BidirectionalIterator< T >Go to http://www.sgi.com/tech/stl/BidirectionalIterator.html
 CDGtal::BidirectionalSegmentComputer
 Cboost_concepts::BidirectionalTraversalConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/BidirectionalTraversal.html
 Cbinary_function
 Cboost::BinaryFunction< Func, Return, First, Second >Go to http://www.sgi.com/tech/stl/BinaryFunction.html
 CDGtal::functors::BinaryPointPredicate< TPointPredicate1, TPointPredicate2, TBinaryFunctor >Aim: The predicate returns true when the given binary functor returns true for the two PointPredicates given at construction
 CDGtal::functors::BinaryPointPredicate< TPointPredicate1, TPointPredicate2, AndBoolFct2 >
 CDGtal::functors::BinaryPointPredicate< TPointPredicate1, TPointPredicate2, OrBoolFct2 >
 Cboost::BinaryPredicate< Func, First, Second >Go to http://www.sgi.com/tech/stl/BinaryPredicate.html
 CDGtal::BinomialConvolver< TConstIteratorOnPoints, TValue >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
 CDGtal::BinomialConvolverEstimator< TBinomialConvolver, TBinomialConvolverFunctor >Aim: This class encapsulates a BinomialConvolver and a functor on BinomialConvolver so as to be a model of CCurveLocalGeometricEstimator
 CDGtal::Bits
 CDGtal::LabelledMap< TData, L, TWord, N, M >::BlockConstIterator
 CDGtal::LabelledMap< TData, L, TWord, N, M >::BlockIterator
 CDGtal::IndexedListWithBlocks< TValue, N, M >::BlockPointerForward declaration
 CDGtal::LabelledMap< TData, L, TWord, N, M >::BlockPointerForward declaration
 CDGtal::functors::BlueChannel
 CDGtal::concepts::Board3DTo2D< S, KS >Aim: The concept CDrawableWithBoard3DTo2D specifies what are the classes that admit an export with Board3DTo2D
 CDGtal::functors::BoundaryPredicate< TKSpace, TImage >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
 CDGtal::BreadthFirstVisitor< TGraph, TMarkSet >Aim: This class is useful to perform a breadth-first exploration of a graph given a starting point or set (called initial core)
 CDGtal::CanonicCellEmbedder< TKSpace >Aim: A trivial embedder for signed and unsigned cell, which corresponds to the canonic injection of cell centroids into Rn
 CDGtal::CanonicDigitalSurfaceEmbedder< TDigitalSurface >Aim: A trivial embedder for digital surfaces, which corresponds to the canonic injection of cell centroids into Rn
 CDGtal::CanonicEmbedder< TSpace >Aim: A trivial embedder for digital points, which corresponds to the canonic injection of Zn into Rn
 CDGtal::CanonicSCellEmbedder< TKSpace >Aim: A trivial embedder for signed cell, which corresponds to the canonic injection of cell centroids into Rn
 CDGtal::CanonicSCellEmbedder< KSpace >
 CDGtal::functors::Cast< TOutput >Aim: Define a simple functor using the static cast operator
 CDGtal::concepts::CBackInsertable< T >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
 CDGtal::concepts::CCellFunctor< T >Aim: Defines a functor on cells
 CDGtal::concepts::CColorMap< CMap >Aim: Defines the concept describing a color map. A color map converts a value within a given range into an RGB triple
 CDGtal::concepts::CConstSinglePassRange< T >Aim: Defines the concept describing a const single pass range
 CDGtal::concepts::CDigitalBoundedShape< TShape >Aim: designs the concept of bounded shapes in DGtal (shape for which upper and lower bounding bounds are available)
 CDGtal::concepts::CDigitalOrientedShape< T >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
 CDGtal::concepts::CDigitalSetArchetype< TDomain >Aim: The archetype of a container class for storing sets of digital points within some given domain
 CDGtal::concepts::CDomainArchetype< TSpace >Aim: The archetype of a class that represents a digital domain, i.e. a non mutable subset of points of the given digital space
 CDGtal::concepts::CDrawableWithBoard2D< T >Aim: The concept CDrawableWithBoard2D specifies what are the classes that admit an export with Board2D
 CDGtal::concepts::CDrawableWithDisplay3D< T, Sp, KSp >
 CDGtal::concepts::CDrawableWithDisplay3D< T, S, KS >
 CDGtal::KhalimskyPreSpaceND< dim, TInteger >::CellMap< Value >
 CDGtal::KhalimskySpaceND< dim, TInteger >::CellMap< Value >
 CDGtal::concepts::CEuclideanBoundedShape< TShape >
 CDGtal::concepts::CEuclideanOrientedShape< T >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
 CDGtal::experimental::ChamferNorm2D< TSpace >Aim: implements a model of CSeparableMetric for Chamfer and path based norms
 CDGtal::VoronoiCovarianceMeasure< TSpace, TSeparableMetric >::CharacteristicSetPredicate
 CDGtal::concepts::ConceptUtils::CheckFalse< T >
 CDGtal::concepts::ConceptUtils::CheckTag< T >
 CDGtal::concepts::ConceptUtils::CheckTrue< T >
 CDGtal::concepts::ConceptUtils::CheckTrue< TagTrue >
 CDGtal::concepts::ConceptUtils::CheckTrueOrFalse< T >
 CDGtal::concepts::ConceptUtils::CheckUnknown< T >
 CDGtal::concepts::ConceptUtils::CheckUnknown< TagUnknown >
 CDGtal::ChordGenericNaivePlaneComputer< TSpace, TInputPoint, TInternalScalar >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
 CDGtal::ChordGenericStandardPlaneComputer< TSpace, TInputPoint, TInternalScalar >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)\)
 CDGtal::ChordNaivePlaneComputer< TSpace, TInputPoint, TInternalScalar >Aim: A class that contains the chord-based algorithm for recognizing pieces of digital planes of given axis width [ Gerard, Debled-Rennesson, Zimmermann, 2005 ]. When the width is 1, it corresponds to naive planes. The axis is specified at initialization of the object
 CDGtal::ChordNaivePlaneComputer< Space, InputPoint, InternalScalar >
 CDGtal::concepts::CImageCacheReadPolicy< T >Aim: Defines the concept describing a cache read policy
 CDGtal::concepts::CImageCacheWritePolicy< T >Aim: Defines the concept describing a cache write policy
 CDGtal::concepts::CImageFactory< T >Aim: Defines the concept describing an image factory
 CDGtal::concepts::CImplicitFunction< T >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
 CDGtal::CircleFrom2Points< TPoint >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
 CDGtal::CircleFrom3Points< TPoint >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
 CDGtal::CircleFrom3Points< Point >
 CDGtal::Circulator< TIterator >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 pre-increment operator does:
 CDGtal::CirculatorType
 CDGtal::concepts::CLinearAlgebra< V, M >Aim: Check right multiplication between matrix and vector and internal matrix multiplication. Matrix and vector scalar types should be the same
 CDGtal::concepts::CLocalEstimatorFromSurfelFunctor< T >Aim: this concept describes functors on digtal surface surfel which can be used to define local estimator using the adapter LocalEstimatorFromSurfelFunctorAdapter
 CDGtal::Clock
 CDGtal::Clone< T >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 speed-up can be achieve through this mechanism
 CDGtal::ClosedIntegerHalfPlane< TSpace >Aim: A half-space specified by a vector N and a constant c. The half-space is the set \( \{ P \in Z^2, N.P \le c \} \)
 CDGtal::concepts::CNormalVectorEstimator< T >Aim: Represents the concept of estimator of normal vector along digital surfaces
 CDGtal::COBAGenericNaivePlaneComputer< TSpace, TInternalInteger >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
 CDGtal::COBAGenericStandardPlaneComputer< TSpace, TInternalInteger >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)\)
 CDGtal::COBANaivePlaneComputer< TSpace, TInternalInteger >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
 CDGtal::COBANaivePlaneComputer< Space, InternalInteger >
 CDGtal::COBANaivePlaneComputer< Z3, InternalInteger >
 CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< TIterator, iterator_type >
 CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< ConstIterator >
 CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< TIterator, BidirectionalCategory >
 CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< TIterator, RandomAccessCategory >
 CDGtal::FreemanChain< TInteger >::CodesRangeAim: model of CRange that provides services to (circularly)iterate over the letters of the freeman chain
 Cboost::Collection< C >Go to http://www.sgi.com/tech/stl/Collection.html
 CDGtal::ColMajorStorageTag (empty structure) specifying a col-major storage order
 CDGtal::ColorStructure representing an RGB triple with alpha component
 CDGtal::ColorBrightnessColorMap< PValue, PDefaultColor >Aim: This class template may be used to (linearly) convert scalar values in a given range into a color with given lightness
 CDGtal::functors::ColorRGBEncoder< TValue >
 CDGtal::Display3D< Space, KSpace >::CommonD3D
 CDGtal::detail::ComparatorAdapter< Container, associative, ordered, pair >
 CDGtal::detail::ComparatorAdapter< Container, true, false, false >Unordered set-like adapter
 CDGtal::detail::ComparatorAdapter< Container, true, false, true >Unordered map-like adapter
 CDGtal::detail::ComparatorAdapter< Container, true, true, false >Set-like adapter
 CDGtal::detail::ComparatorAdapter< Container, true, true, true >Map-like adapter
 CDGtal::CompareLocalEstimators< TFirstEsimator, TSecondEstimator >Aim: Functor to compare two local geometric estimators
 CDGtal::Viewer3D< Space, KSpace >::CompFarthestPolygonFromCamera
 CDGtal::Viewer3D< Space, KSpace >::CompFarthestSurfelFromCamera
 CDGtal::Viewer3D< Space, KSpace >::CompFarthestTriangleFromCamera
 CDGtal::Viewer3D< Space, KSpace >::CompFarthestVoxelFromCamera
 CDGtal::functors::Composer< TFunctor1, TFunctor2, ReturnType >Aim: Define a new Functor from the composition of two other functors
 CDGtal::Mesh< TPoint >::CompPoints
 CDGtal::FrechetShortcut< TIterator, TInteger >::Cone
 Cboost::Const_BinaryPredicate< Func, First, Second >Go to http://www.boost.org/libs/concept_check/reference.htm
 CDGtal::ConstAlias< T >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)
 CDGtal::deprecated::ConstantConvolutionWeights< TDistance >Aim: implement a trivial constant convolution kernel which returns 1 to each distance
 CDGtal::functors::ConstantPointPredicate< TPoint, boolCst >Aim: The predicate that returns always the same value boolCst
 CDGtal::functors::ConstantPointPredicate< TPoint, false >
 CDGtal::functors::ConstantPointPredicate< TPoint, true >
 CDGtal::Labels< L, TWord >::ConstEnumerator
 CDGtal::ConstImageAdapter< TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV >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
 CDGtal::StandardDSLQ0< TFraction >::ConstIterator
 CDGtal::IndexedListWithBlocks< TValue, N, M >::ConstIterator
 CDGtal::LabelledMap< TData, L, TWord, N, M >::ConstIterator
 CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::ConstPointIterator
 CDGtal::ConstRangeAdapter< TIterator, TFunctor, TReturnType >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 read-only manner)
 CDGtal::ConstRangeFromPointAdapter< TRange, TFunctor, TReturnType >Aim: model of CConstBidirectionalRangeFromPoint that adapts any bidirectional range and provides services to iterate over it (in a read-only manner)
 CDGtal::HyperRectDomain< TSpace >::ConstSubRangeAim: 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
 Cboost::Container< C >Go to http://www.sgi.com/tech/stl/Container.html
 CDGtal::ContainerCategory
 CDGtal::ContainerTraits< TContainer >Defines default container traits for arbitrary types
 CDGtal::ContainerTraits< boost::unordered_map< Value, T, Hash, Pred, Alloc > >Defines container traits for boost::unordered_map<>
 CDGtal::ContainerTraits< boost::unordered_multimap< Value, T, Hash, Pred, Alloc > >Defines container traits for boost::unordered_multimap<>
 CDGtal::ContainerTraits< boost::unordered_multiset< Value, Hash, Pred, Alloc > >Defines container traits for boost::unordered_multiset<>
 CDGtal::ContainerTraits< boost::unordered_set< Value, Hash, Pred, Alloc > >Defines container traits for boost::unordered_set<>
 CDGtal::ContainerTraits< CubicalComplex< TKSpace, TCellContainer > >
 CDGtal::ContainerTraits< std::array< T, N > >Defines container traits for std::array<>
 CDGtal::ContainerTraits< std::deque< T, Alloc > >Defines container traits for std::deque<>
 CDGtal::ContainerTraits< std::forward_list< T, Alloc > >Defines container traits for std::forward_list<>
 CDGtal::ContainerTraits< std::list< T, Alloc > >Defines container traits for std::list<>
 CDGtal::ContainerTraits< std::map< Key, T, Compare, Alloc > >Defines container traits for std::map<>
 CDGtal::ContainerTraits< std::multimap< Key, T, Compare, Alloc > >Defines container traits for std::multimap<>
 CDGtal::ContainerTraits< std::multiset< T, Compare, Alloc > >Defines container traits for std::multiset<>
 CDGtal::ContainerTraits< std::set< T, Compare, Alloc > >Defines container traits for std::set<>
 CDGtal::ContainerTraits< std::unordered_map< Key, T, Hash, Pred, Alloc > >Defines container traits for std::unordered_map<>
 CDGtal::ContainerTraits< std::unordered_multimap< Key, T, Hash, Pred, Alloc > >Defines container traits for std::unordered_multimap<>
 CDGtal::ContainerTraits< std::unordered_multiset< Key, Hash, Pred, Alloc > >Defines container traits for std::unordered_multiset<>
 CDGtal::ContainerTraits< std::unordered_set< Key, Hash, Pred, Alloc > >Defines container traits for std::unordered_set<>
 CDGtal::ContainerTraits< std::vector< T, Alloc > >Defines container traits for std::vector<>
 CDGtal::ContourHelperAim: a helper class to process sequences of points
 Cboost::Convertible< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::CopyConstructible< T >Go to http://www.sgi.com/tech/stl/CopyConstructible.html
 CDGtal::CountedConstPtrOrConstPtr< T >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
 CDGtal::CountedConstPtrOrConstPtr< ConvolutionFunctor >
 CDGtal::CountedConstPtrOrConstPtr< DGtal::DigitalSurface >
 CDGtal::CountedConstPtrOrConstPtr< DGtal::VoronoiCovarianceMeasureOnDigitalSurface >
 CDGtal::CountedConstPtrOrConstPtr< DummyTbl >
 CDGtal::CountedConstPtrOrConstPtr< KSpace >
 CDGtal::CountedConstPtrOrConstPtr< Metric >
 CDGtal::CountedConstPtrOrConstPtr< PointPredicate >
 CDGtal::CountedConstPtrOrConstPtr< Shape >
 CDGtal::CountedConstPtrOrConstPtr< ShapeA >
 CDGtal::CountedConstPtrOrConstPtr< VCMOnDigitalSurface >
 CDGtal::CountedPtr< T >Aim: Smart pointer based on reference counts
 CDGtal::CountedPtr< A1 >
 CDGtal::CountedPtr< AdjacentVertexContainer >
 CDGtal::CountedPtr< const Domain >
 CDGtal::CountedPtr< DGtal::DigitalSurfaceConvolver >
 CDGtal::CountedPtr< DGtal::DrawableWithBoard2D >
 CDGtal::CountedPtr< DGtal::DrawableWithDisplay3D >
 CDGtal::CountedPtr< DGtal::FunctorOnCells >
 CDGtal::CountedPtr< DGtal::functors::PointFunctorFromPointPredicateAndDomain >
 CDGtal::CountedPtr< DGtal::GaussDigitizer >
 CDGtal::CountedPtr< DGtal::ImplicitBall >
 CDGtal::CountedPtr< DGtal::SignalData< TValue > >
 CDGtal::CountedPtr< DGtal::SignalData< Value > >
 CDGtal::CountedPtr< DigitalSet >
 CDGtal::CountedPtr< DigitalSurfaceContainer >
 CDGtal::CountedPtr< DigitalTopology >
 CDGtal::CountedPtr< Domain >
 CDGtal::CountedPtr< DrawableWithBoard2D >
 CDGtal::CountedPtr< DrawableWithDisplay3D >
 CDGtal::CountedPtr< DummyTbl >
 CDGtal::CountedPtr< GeometricFunctor >
 CDGtal::CountedPtr< GraphVisitor >
 CDGtal::CountedPtr< HyperRectDomain< Space > >
 CDGtal::CountedPtr< OutEdgeContainer >
 CDGtal::CountedPtr< OutputImage >
 CDGtal::CountedPtr< Point >
 CDGtal::CountedPtr< Preimage >
 CDGtal::CountedPtr< Sequence >
 CDGtal::CountedPtr< ShapePointFunctor >
 CDGtal::CountedPtr< StabbingLineComputer< ConstIterator > >
 CDGtal::CountedPtr< TImageContainer >
 CDGtal::CountedPtrOrPtr< T >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
 CDGtal::CountedPtrOrPtr< boost::dynamic_bitset<> >
 CDGtal::CountedPtrOrPtr< DummyTbl >
 CDGtal::CountedPtrOrPtr< std::unordered_map< Point, unsigned int > >
 CDGtal::CountedPtr< T >::Counter
 CDGtal::deprecated::IntegralInvariantNormalVectorEstimator< TKSpace, TPointPredicate >::CovarianceMatrix2NormalDirectionFunctor
 CDGtal::CowPtr< T >Aim: Copy on write shared pointer
 CDGtal::CowPtr< A1 >
 CDGtal::CowPtr< const Domain >
 CDGtal::CowPtr< DGtal::SignalData< TValue > >
 CDGtal::CowPtr< DGtal::SignalData< Value > >
 CDGtal::CowPtr< DigitalSet >
 CDGtal::CowPtr< DigitalTopology >
 CDGtal::CowPtr< Domain >
 CDGtal::CowPtr< DummyTbl >
 CDGtal::CowPtr< GeometricFunctor >
 CDGtal::CowPtr< Point >
 CDGtal::CowPtr< Preimage >
 CDGtal::CowPtr< StabbingLineComputer< ConstIterator > >
 CDGtal::CowPtr< TImageContainer >
 CDGtal::concepts::CSpace< T >Aim: Defines the concept describing a digital space, ie a cartesian product of integer lines
 CDGtal::CubicalCellData
 CDGtal::CubicalComplex< TKSpace, TCellContainer >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
 CDGtal::concepts::CUndirectedSimpleLocalGraph< T >Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices
 CDGtal::concepts::CUndirectedSimpleLocalGraph< Adj >
 CDGtal::CurvatureFromBinomialConvolverFunctor< TBinomialConvolver, TReal >Aim: This class is a functor for getting the curvature of a binomial convolver
 CDGtal::detail::CurvatureFromDCA< isCCW >
 CDGtal::detail::CurvatureFromDCA< false >
 CDGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, Functor >
 CDGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, detail::CurvatureFromDSSLength >
 CDGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, detail::CurvatureFromDSSLengthAndWidth >
 CDGtal::detail::CurvatureFromDSSLength
 CDGtal::detail::CurvatureFromDSSLengthAndWidth
 CDGtal::concepts::CVertexPredicateArchetype< TVertex >Aim: Defines a an archetype for concept CVertexPredicate
 CDGtal::concepts::CVertexPredicateArchetype< Vertex >
 CDGtal::concepts::CWithGradientMap< T >Aim: Such object provides a gradient map that associates to each argument some real vector
 CDGtal::LabelledMap< TData, L, TWord, N, M >::DataOrBlockPointerUsed in first block to finish it or to point to the next block
 CDGtal::CubicalComplex< TKSpace, TCellContainer >::DefaultCellMapIteratorPriority
 CDGtal::DefaultConstImageRange< TImage >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 read-only as well as a write-only manner)
 Cboost::DefaultConstructible< T >Go to http://www.sgi.com/tech/stl/DefaultConstructible.html
 Cboost::DefaultConstructible< S >
 CDGtal::DefaultImageRange< TImage >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 read-only as well as a write-only manner)
 CDGtal::DepthFirstVisitor< TGraph, TMarkSet >Aim: This class is useful to perform a depth-first exploration of a graph given a starting point or set (called initial core)
 Cstd::deque< T >STL class
 CDerivativeTester< Calculus, order >
 CDerivativeTester< Calculus,-1 >
 CDGtal::DicomReader< TImageContainer, TFunctor >Aim: Import a 3D DICOM image from file series
 CDGtal::DigitalMetricAdapter< TMetric, TInteger >Aim: simple adapter class which adapts any models of concepts::CMetricSpace to a model of concepts::CDigitalMetricSpace
 CDGtal::DigitalSetBoundary< TKSpace, TDigitalSet >Aim: A model of CDigitalSurfaceContainer which defines the digital surface as the boundary of a given digital set
 CDGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >Aim: A wrapper class around a STL associative container for storing sets of digital points within some given domain
 CDGtal::DigitalSetBySTLSet< TDomain, TCompare >Aim: A container class for storing sets of digital points within some given domain
 CDGtal::DigitalSetBySTLVector< TDomain >Aim: Realizes the concept CDigitalSet by using the STL container std::vector
 CDGtal::DigitalSetConverter< OutputDigitalSet >Aim: Utility class to convert between types of sets
 CDGtal::DigitalSetDomain< TDigitalSet >Aim: Constructs a domain limited to the given digital set
 CDGtal::DigitalSetDomain< DigitalSet >
 CDGtal::DigitalSetFromMap< TMapImage >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
 CDGtal::DigitalSetSelector< Domain, Preferences >Aim: Automatically defines an adequate digital set type according to the hints given by the user
 CDGtal::DigitalShapesCSG< ShapeA, ShapeB >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
 CDGtal::deprecated::DigitalShapesIntersection< ShapeA, ShapeB >Aim: Intersection between two models of CDigitalBoundedShape and CDigitalOrientedShape
 CDGtal::deprecated::DigitalShapesMinus< ShapeA, ShapeB >Aim: Minus between two models of CDigitalBoundedShape and CDigitalOrientedShape
 CDGtal::deprecated::DigitalShapesUnion< ShapeA, ShapeB >Aim: Union between two models of CDigitalBoundedShape and CDigitalOrientedShape
 CDGtal::DigitalSurface< TDigitalSurfaceContainer >Aim: Represents a set of n-1-cells 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 k-cells, 0 <= k < n. This complex is generally not a manifold (i.e. a kind of surface), except when it has the property of being well-composed
 CDGtal::DigitalSurface2DSlice< TDigitalSurfaceTracker >Aim: Represents a 2-dimensional slice in a DigitalSurface. In a sense, it is a 4-connected contour, open or not. To be valid, it must be connected to some digital surface and a starting surfel
 CDGtal::DigitalSurfaceConvolver< TFunctor, TKernelFunctor, TKSpace, TDigitalKernel, dimension >
 CDGtal::DigitalSurfaceConvolver< TFunctor, TKernelFunctor, TKSpace, TDigitalKernel, 2 >
 CDGtal::DigitalSurfaceConvolver< TFunctor, TKernelFunctor, TKSpace, TDigitalKernel, 3 >
 CDGtal::DigitalSurfaceEmbedderWithNormalVectorEstimator< TDigitalSurfaceEmbedder, TNormalVectorEstimator >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)
 CDGtal::DigitalSurfaceEmbedderWithNormalVectorEstimatorGradientMap< TDigitalSurfaceEmbedder, TNormalVectorEstimator >
 CDGtal::DigitalTopology< TForegroundAdjacency, TBackgroundAdjacency >Aim: Represents a digital topology as a couple of adjacency relations
 CDGtal::DigitalTopologyTraits< TForegroundAdjacency, TBackgroundAdjacency, dim >Aim: the traits classes for DigitalTopology types
 CDGtal::DigitalTopologyTraits< MetricAdjacency< TSpace, 1 >, MetricAdjacency< TSpace, 2 >, 2 >Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (4,8)
 CDGtal::DigitalTopologyTraits< MetricAdjacency< TSpace, 1 >, MetricAdjacency< TSpace, 2 >, 3 >Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (6,18)
 CDGtal::DigitalTopologyTraits< MetricAdjacency< TSpace, 1 >, MetricAdjacency< TSpace, 3 >, 3 >Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (6,26)
 CDGtal::DigitalTopologyTraits< MetricAdjacency< TSpace, 2 >, MetricAdjacency< TSpace, 1 >, 2 >Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (8,4)
 CDGtal::DigitalTopologyTraits< MetricAdjacency< TSpace, 2 >, MetricAdjacency< TSpace, 1 >, 3 >Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (18,6)
 CDGtal::DigitalTopologyTraits< MetricAdjacency< TSpace, 3 >, MetricAdjacency< TSpace, 1 >, 3 >Aim: Specialization of the traits classes for DigitalTopology types for any 2D Space, for topology (26,6)
 CDGtal::DiscreteExteriorCalculus< dimEmbedded, dimAmbient, TLinearAlgebraBackend, TInteger >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
 CDGtal::DiscreteExteriorCalculusFactory< TLinearAlgebraBackend, TInteger >Aim: This class provides static members to create DEC structures from various other DGtal structures
 CDGtal::DiscreteExteriorCalculusSolver< TCalculus, TLinearAlgebraSolver, order_in, duality_in, order_out, duality_out >Aim: This wraps a linear algebra solver around a discrete exterior calculus
 CDGtal::Display2DFactoryFactory for Display2D:
 CDGtal::concepts::Display3D< S, KS >Aim: The concept CDrawableWithDisplay3D specifies what are the classes that admit an export with Display3D
 CDGtal::Display3D< Space, KSpace >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)
 CDGtal::Display3D< DGtal::SpaceND, KSpace >
 CDGtal::Display3D< S, KS >
 CDGtal::Display3D< Sp, KSp >
 CDGtal::Display3DFactory< TSpace, TKSpace >Factory for GPL Display3D:
 CDGtal::DistanceBreadthFirstVisitor< TGraph, TVertexFunctor, TMarkSet >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
 CDGtal::detail::DistanceFromDCA
 CDGtal::IteratorCompletionTraits< ArrayImageAdapter< TArrayIterator, TDomain > >::DistanceFunctor
 CDGtal::DistanceFunctorFromPoint< TImage >
 CDGtal::DomainAdjacency< TDomain, TAdjacency >Aim: Given a domain and an adjacency, limits the given adjacency to the specified domain for all adjacency and neighborhood computations
 CDGtal::DomainAdjacency< ObjectDomain, ForegroundAdjacency >
 CDGtal::deprecated::DomainMetricAdjacency< Domain, maxNorm1, dimension >Aim: Describes digital adjacencies in a digital domain that are defined with the 1-norm and the infinity-norm
 CDGtal::functors::DomainPredicate< TDomain >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
 CDGtal::functors::DomainPredicate< Domain >
 CDGtal::DrawableWithBoard2D
 CDGtal::DrawableWithBoard3DTo2D
 CDGtal::DrawableWithDisplay3D
 CDGtal::DrawWithBoardModifier
 CDGtal::DrawWithDisplay3DModifierBase class specifying the methods for classes which intend to modify a Viewer3D stream
 CDGtal::DSLSubsegment< TInteger, TNumber >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)
 CDGtal::detail::DSSDecorator< TDSS >Aim: Abstract DSSDecorator for ArithmeticalDSSComputer. Has 2 virtual methods returning the first and last leaning point:
 CDGtal::DSSLengthEstimator< TConstIterator >Aim: a model of CGlobalCurveEstimator that segments the digital curve into DSS and computes the length of the resulting (not uniquely defined) polygon
 CDGtal::functors::DummyEstimatorFromSurfels< TSurfel, TSCellEmbedder >
 CDGtal::DynamicBidirectionalSegmentComputer
 CDGtal::DynamicSegmentComputer
 CDGtal::DigitalSurface< TDigitalSurfaceContainer >::Edge
 CDGtal::Object< TDigitalTopology, TDigitalSet >::Edge
 Cedge_list_graph_tag
 Cboost::EdgeListGraphConcept< G >Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/EdgeListGraph.html
 CDGtal::EigenDecomposition< TN, TComponent, TMatrix >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
 CDGtal::EigenLinearAlgebraBackendAim: Provide linear algebra backend using Eigen dense and sparse matrix as well as dense vector. 6 linear solvers available:
 CDGtal::VoronoiCovarianceMeasureOnDigitalSurface< TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction >::EigenStructureStructure to hold a diagonalized matrix
 CDGtal::functors::ElementaryConvolutionNormalVectorEstimator< TSurfel, TEmbedder >Aim: Estimates normal vector by convolution of elementary normal vector to adjacent surfel
 Cboost::EqualityComparable< T >Go to http://www.sgi.com/tech/stl/EqualityComparable.html
 CDGtal::functors::EqualPointPredicate< TPoint >Aim: The predicate returns true when the point given as argument equals the reference point given at construction
 CDGtal::detail::EqualPredicateFromLessThanComparator< LessThan, T >
 CDGtal::EstimatorCache< TEstimator, TContainer >Aim: this class adapts any local surface estimator to cache the estimated values in a associative container (Surfel <-> estimated value)
 CDGtal::detail::EuclideanDivisionHelper< TNumber >Aim: Small stucture that provides a static method returning the Euclidean division of two integers
 CDGtal::detail::EuclideanDivisionHelper< double >
 CDGtal::detail::EuclideanDivisionHelper< float >
 CDGtal::detail::EuclideanDivisionHelper< long double >
 CDGtal::EuclideanShapesCSG< ShapeA, ShapeB >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
 CDGtal::deprecated::EuclideanShapesIntersection< ShapeA, ShapeB >Aim: Intersection between two models of CEuclideanBoundedShape and CEuclideanOrientedShape
 CDGtal::deprecated::EuclideanShapesMinus< ShapeA, ShapeB >Aim: Minus between two models of CEuclideanBoundedShape and CEuclideanOrientedShape
 CDGtal::deprecated::EuclideanShapesUnion< ShapeA, ShapeB >Aim: Union between two models of CEuclideanBoundedShape and CEuclideanOrientedShape
 CDGtal::MPolynomialEvaluatorImpl< 1, TRing, TOwner, TAlloc, TX >::EvalFun
 CDGtal::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX >::EvalFun< XX, Fun >
 CDGtal::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX >::EvalFun2
 CDGtal::ExactPredicateLpPowerSeparableMetric< TSpace, p, TPromoted >Aim: implements weighted separable l_p metrics with exact predicates
 CDGtal::ExactPredicateLpPowerSeparableMetric< TSpace, 2, TPromoted >
 Cstd::exceptionSTL class
 CDGtal::Expander< TObject >Aim: This class is useful to visit an object by adjacencies, layer by layer
 CDGtal::ExplicitDigitalSurface< TKSpace, TSurfelPredicate >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
 CDGtal::DigitalSurface< TDigitalSurfaceContainer >::Face
 CDGtal::functors::FalseBoolFct0
 CDGtal::detail::FFTWComplexCast< TFFTW >Facility to cast to the complex type used by fftw
 CDGtal::detail::FFTWWrapper< Real >Wrapper to fftw functions depending on value type
 CDGtal::detail::FFTWWrapper< double >
 CDGtal::detail::FFTWWrapper< float >
 CDGtal::detail::FFTWWrapper< long double >
 CDGtal::Filtered2x2DetComputer< TDetComputer >Aim: Class that provides a way of computing the sign of the determinant of a 2x2 matrix from its four coefficients, ie
 CDGtal::IndexedListWithBlocks< TValue, N, M >::FirstBlock
 CDGtal::functors::FlipDomainAxis< TDomain >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, MaxY-y, z)
 CDGtal::FMM< TImage, TSet, TPointPredicate, TPointFunctor >Aim: Fast Marching Method (FMM) for nd distance transforms
 Cforward_iterator_archetype
 CDGtal::ForwardCategory
 Cboost::ForwardContainer< C >Go to http://www.sgi.com/tech/stl/ForwardContainer.html
 Cboost::ForwardContainer< T >
 Cboost::ForwardIterator< T >Go to http://www.sgi.com/tech/stl/ForwardIterator.html
 CDGtal::ForwardSegmentComputer
 Cboost_concepts::ForwardTraversalConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/ForwardTraversal.html
 CDGtal::FP< TIterator, TInteger, connectivity >Aim: Computes the faithful polygon (FP) of a range of 4/8-connected 2D Points
 CDGtal::FPLengthEstimator< TConstIterator >Aim: a model of CGlobalCurveEstimator that computes the length of a digital curve using its FP (faithful polygon)
 CDGtal::LighterSternBrocot< TInteger, TQuotient, TMap >::FractionThis fraction is a model of CPositiveIrreducibleFraction
 CDGtal::LightSternBrocot< TInteger, TQuotient, TMap >::FractionThis fraction is a model of CPositiveIrreducibleFraction
 CDGtal::SternBrocot< TInteger, TQuotient >::FractionThis fraction is a model of CPositiveIrreducibleFraction
 CDGtal::FrechetShortcut< TIterator, TInteger >Aim: On-line computation Computation of the longest shortcut according to the Fréchet distance for a given error. See related article: Sivignon, I., (2011). A Near-Linear Time Guaranteed Algorithm for Digital Curve Simplification under the Fréchet Distance. DGCI 2011. Retrieved from http://link.springer.com/chapter/10.1007/978-3-642-19867-0_28
 CDGtal::FrechetShortcut< ConstIterator, Integer >
 CDGtal::FreemanChain< TInteger >
 CDGtal::FreemanChain< int >
 CDGtal::functors::FrontierPredicate< TKSpace, TImage >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
 Cboost::FrontInsertionSequence< C >Go to http://www.sgi.com/tech/stl/FrontInsertionSequence.html
 CDGtal::FrontInsertionSequenceToStackAdapter< TSequence >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
 CDGtal::FunctorOnCells< TFunctorOnPoints, TKSpace >Aim: Convert a functor on Digital Point to a Functor on Khalimsky Cell
 CDGtal::GaussDigitizer< TSpace, TEuclideanShape >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)
 CDGtal::GaussDigitizer< Space, MyEuclideanShape >
 CDGtal::deprecated::GaussianConvolutionWeights< TDistance >Aim: implement a Gaussian centered convolution kernel
 CDGtal::functors::GaussianKernelAim: defines a functor on double numbers which corresponds to a Gaussian convolution kernel. This functor acts from [0,1] to [0,1]
 Cboost::Generator< Func, Return >Go to http://www.sgi.com/tech/stl/Generator.html
 CDGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >
 CDGtal::GenericReader< TContainer, Tdim, TValue >Aim: Provide a mechanism to load with the bestloader according to an image (2D or 3D) filename (by parsing the extension)
 CDGtal::GenericReader< TContainer, 2, DGtal::uint32_t >
 CDGtal::GenericReader< TContainer, 2, TValue >
 CDGtal::GenericReader< TContainer, 3, DGtal::uint32_t >
 CDGtal::GenericReader< TContainer, 3, DGtal::uint64_t >
 CDGtal::GenericReader< TContainer, 3, TValue >
 CDGtal::GenericWriter< TContainer, Tdim, TValue, TFunctor >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)
 CDGtal::GenericWriter< TContainer, 2, TValue, HueShadeColorMap< TValue > >
 CDGtal::GenericWriter< TContainer, 2, TValue, TFunctor >
 CDGtal::GenericWriter< TContainer, 2, unsigned char, TFunctor >
 CDGtal::GenericWriter< TContainer, 3, DGtal::uint64_t, TFunctor >
 CDGtal::GenericWriter< TContainer, 3, TValue, TFunctor >
 CDGtal::GenericWriter< TContainer, 3, unsigned char, TFunctor >
 CDGtal::Viewer3D< Space, KSpace >::GLTextureImage
 CDGtal::GradientColorMap< PValue, PDefaultPreset, PDefaultFirstColor, PDefaultLastColor >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
 CDGtal::GradientColorMap< unsigned char, DGtal::CMAP_COOL >
 CDGtal::GradientColorMap< unsigned char, DGtal::CMAP_HOT >
 CDGtal::GradientColorMap< unsigned int >
 Cgrammar
 Cboost::graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >
 Cboost::graph_traits< DGtal::Object< TDigitalTopology, TDigitalSet > >
 Cboost::GraphConcept< G >Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/Graph.html
 CDGtal::GraphVisitorRange< TGraphVisitor >Aim: Transforms a graph visitor into a single pass input range
 CDGtal::GrayscaleColorMap< PValue >Aim: This class template may be used to (linearly) convert scalar values in a given range into gray levels
 CDGtal::GreedySegmentation< TSegmentComputer >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
 CDGtal::functors::GreenChannel
 CDGtal::GridCurve< TKSpace >Aim: describes, in a cellular space of dimension n, a closed or open sequence of signed d-cells (or d-scells), d being either equal to 1 or (n-1)
 CDGtal::H5DSpecializations< TImageFactory, T >Aim: implements HDF5 reading and writing for specialized type T
 CDGtal::H5DSpecializations< TImageFactory, DGtal::int32_t >Aim: implements HDF5 reading and writing for specialized type DGtal::int32_t
 CDGtal::H5DSpecializations< TImageFactory, DGtal::int64_t >Aim: implements HDF5 reading and writing for specialized type DGtal::int64_t
 CDGtal::H5DSpecializations< TImageFactory, DGtal::uint8_t >Aim: implements HDF5 reading and writing for specialized type DGtal::uint8_t
 CDGtal::H5DSpecializations< TImageFactory, double >Aim: implements HDF5 reading and writing for specialized type double
 Cstd::hash< DGtal::BigInteger >
 Cstd::hash< DGtal::KhalimskyCell< dim, TInteger > >
 Cboost::hash< DGtal::KhalimskyCell< dim, TInteger > >
 Cstd::hash< DGtal::PointVector< dim, EuclideanRing, Container > >
 Cstd::hash< DGtal::SignedKhalimskyCell< dim, TInteger > >
 Cboost::hash< DGtal::SignedKhalimskyCell< dim, TInteger > >
 CDGtal::detail::HasNestedTypeCategory< T >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
 CDGtal::detail::HasNestedTypeType< IC >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
 CDGtal::functors::HatFunction< TScalar >
 CDGtal::functors::HatPointFunction< TPoint, TScalar >
 CDGtal::HDF5Reader< TImageContainer, TFunctor >Aim: Import a HDF5 file
 CDGtal::HDF5Writer< TImage, TFunctor >Aim: Export an Image with the HDF5 format
 CDGtal::LongvolReader< TImageContainer, TFunctor >::HeaderField
 CDGtal::VolReader< TImageContainer, TFunctor >::HeaderField
 CDGtal::Histogram< TQuantity, TBinner >Aim: Represents a typical histogram in statistics, which is a discrete estimate of the probability distribution of a continuous variable
 CHodgeTester< Calculus, order >
 CHodgeTester< Calculus,-1 >
 CDGtal::HueShadeColorMap< PValue, DefaultCycles >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
 CDGtal::HueShadeColorMap< unsigned char >
 CDGtal::HyperRectDomain< TSpace >Aim: Parallelepidec region of a digital space, model of a 'CDomain'
 CDGtal::HyperRectDomain< Space >
 CDGtal::HyperRectDomain_Iterator< TPoint >
 CDGtal::HyperRectDomain_subIterator< TPoint >
 CDGtal::functors::IdentityAim: Define a simple default functor that just returns its argument
 CDGtal::functors::IdentityBoolFct1
 CDGtal::functors::IICurvatureFunctor< TSpace >Aim: A functor Real -> Real that returns the 2d curvature by transforming the given volume. This functor is valid only in 2D space
 CDGtal::functors::IIFirstPrincipalCurvature3DFunctor< TSpace, TMatrix >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
 CDGtal::functors::IIFirstPrincipalDirectionFunctor< TSpace, TMatrix >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
 CDGtal::functors::IIGaussianCurvature3DFunctor< TSpace, TMatrix >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
 CDGtal::functors::IIMeanCurvature3DFunctor< TSpace >Aim: A functor Real -> Real that returns the 3d mean curvature by transforming the given volume. This functor is valid only in 3D space
 CDGtal::functors::IINormalDirectionFunctor< TSpace, TMatrix >Aim: A functor Matrix -> RealVector that returns the normal direction by diagonalizing the given covariance matrix
 CDGtal::functors::IIPrincipalCurvatures3DFunctor< TSpace, TMatrix >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
 CDGtal::functors::IIPrincipalDirectionsFunctor< TSpace, TMatrix >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
 CDGtal::functors::IISecondPrincipalCurvature3DFunctor< TSpace, TMatrix >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
 CDGtal::functors::IISecondPrincipalDirectionFunctor< TSpace, TMatrix >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
 CDGtal::functors::IITangentDirectionFunctor< TSpace, TMatrix >Aim: A functor Matrix -> RealVector that returns the tangent direction by diagonalizing the given covariance matrix. This functor is valid only in 2D space
 CDGtal::Image< TImageContainer >Aim: implements association bewteen points lying in a digital domain and values
 CDGtal::Viewer3D< Space, KSpace >::Image2DDomainD3D
 CDGtal::ImageAdapter< TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV, TFunctorVm1 >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 f-1 for writing point values
 CDGtal::ImageCache< TImageContainer, TImageFactory, TReadPolicy, TWritePolicy >Aim: implements an images cache with 'read and write' policies
 CDGtal::ImageCacheReadPolicyFIFO< TImageContainer, TImageFactory >Aim: implements a 'FIFO' read policy cache
 CDGtal::ImageCacheReadPolicyLAST< TImageContainer, TImageFactory >Aim: implements a 'LAST' read policy cache
 CDGtal::ImageCacheWritePolicyWB< TImageContainer, TImageFactory >Aim: implements a 'WB (Write-back or Write-behind)' write policy cache
 CDGtal::ImageCacheWritePolicyWT< TImageContainer, TImageFactory >Aim: implements a 'WT (Write-through)' write policy cache
 CDGtal::experimental::ImageContainerByHashTree< TDomain, TValue, THashKey >Model of CImageContainer implementing the association key<->Value using a hash tree. This class provides a built-in iterator
 CDGtal::ImageContainerByITKImage< TDomain, TValue >Aim: implements a model of CImageContainer using a ITK Image
 CDGtal::ImageFactoryFromHDF5< TImageContainer >Aim: implements a factory from an HDF5 file
 CDGtal::ImageFactoryFromImage< TImageContainer >Aim: implements a factory to produce images from a "bigger/original" one according to a given domain
 CDGtal::ImageFromSet< TImage >Aim: Define utilities to convert a digital set into an image
 CDGtal::ImageLinearCellEmbedder< TKSpace, TImage, TEmbedder >Aim: a cellular embedder for images. (default constructible, copy constructible, assignable). Model of CCellEmbedder
 CDGtal::ImageSelector< Domain, Value, Preferences >Aim: Automatically defines an adequate image type according to the hints given by the user
 CDGtal::ImageSelector< Domain, unsigned char >
 CDGtal::ImageToConstantFunctor< Image, PointPredicate, TValue >
 CDGtal::ImplicitBall< TSpace >Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball in nD.
 CDGtal::ImplicitDigitalSurface< TKSpace, TPointPredicate >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
 CDGtal::ImplicitFunctionDiff1LinearCellEmbedder< TKSpace, TImplicitFunctionDiff1, TEmbedder >Aim: a cellular embedder for implicit functions, (default constructible, copy constructible, assignable). Model of CCellEmbedder and CWithGradientMap
 CDGtal::ImplicitFunctionLinearCellEmbedder< TKSpace, TImplicitFunction, TEmbedder >Aim: a cellular embedder for implicit functions, (default constructible, copy constructible, assignable). Model of CCellEmbedder
 CDGtal::ImplicitHyperCube< TSpace >Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create an hypercube in nD.
 CDGtal::ImplicitNorm1Ball< TSpace >Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball for the L_1 norm in nD
 CDGtal::ImplicitPolynomial3Shape< TSpace >Aim: model of CEuclideanOrientedShape concepts to create a shape from a polynomial
 CDGtal::ImplicitRoundedHyperCube< TSpace >Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a rounded hypercube in nD.
 CDGtal::functors::ImpliesBoolFct2
 Cincidence_graph_tag
 Cboost::IncidenceGraphConcept< G >Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/IncidenceGraph.html
 Cboost_concepts::IncrementableIteratorConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/IncrementableIterator.html
 CDGtal::IndexedListWithBlocks< TValue, N, M >Aim: Represents a mixed list/array structure which is useful in some context. It is essentially a list of blocks
 CDGtal::InGeneralizedDiskOfGivenRadius< TPoint, TDetComputer >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
 CDGtal::InHalfPlaneBy2x2DetComputer< TPoint, TDetComputer >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:
 CDGtal::InHalfPlaneBySimple3x3Matrix< TPoint, TInteger >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:
 CDGtal::InHalfPlaneBySimple3x3Matrix< Point, double >
 Cinput_iterator_archetype
 Cboost::InputIterator< T >Go to http://www.sgi.com/tech/stl/InputIterator.html
 CDGtal::InputIteratorWithRankOnSequence< TSequence, TRank >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
 Cboost::Integer< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 CDGtal::IntegerComputer< TInteger >Aim: This class gathers several types and methods to make computation with integers
 CDGtal::IntegerComputer< Integer >
 CDGtal::IntegralInvariantCovarianceEstimator< TKSpace, TPointPredicate, TCovarianceMatrixFunctor >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
 CDGtal::deprecated::IntegralInvariantNormalVectorEstimator< TKSpace, TPointPredicate >Aim: This class implement an Integral Invariant normal vector estimator
 CDGtal::IntegralInvariantVolumeEstimator< TKSpace, TPointPredicate, TVolumeFunctor >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
 Cboost_concepts::InteroperableIteratorConcept< Iterator, ConstIterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/InteroperableIterator.html
 CDGtal::functors::IntervalForegroundPredicate< Image >Aim: Define a simple Foreground predicate thresholding image values between two constant values (the first one being excluded)
 Cboost::is_integral< T >Go to http://www.boost.org/doc/libs/1_52_0/libs/type_traits/doc/html/index.html
 Cboost::is_unsigned< T >Go to http://www.boost.org/doc/libs/1_52_0/libs/type_traits/doc/html/index.html
 CDGtal::IsAssociativeContainer< T >
 CDGtal::detail::IsAssociativeContainerFromCategory< TCategory >
 CDGtal::detail::IsCirculator< IC, flagHasNestedTypeCalledType >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
 CDGtal::IsCirculator< IC >Aim: Checks whether type IC is a circular or a classical iterator. Static value set to 'true' for a circulator, 'false' otherwise
 CDGtal::detail::IsCirculator< IC, true >
 CDGtal::detail::IsCirculatorFromType< IC, ICType >Aim: In order to check whether type IC is a circular or a classical iterator, the nested type called 'Type' is read
 CDGtal::detail::IsCirculatorFromType< IC, CirculatorType >
 CDGtal::IsContainer< T >
 CDGtal::detail::IsContainerFromCategory< TCategory >
 CDGtal::functors::IsLowerPointPredicate< TPoint >Aim: The predicate returns true when the point is below (or equal) the given upper bound
 CDGtal::IsMultipleAssociativeContainer< T >
 CDGtal::detail::IsMultipleAssociativeContainerFromCategory< TCategory >
 CDGtal::IsOrderedAssociativeContainer< T >
 CDGtal::detail::IsOrderedAssociativeContainerFromCategory< TCategory >
 CDGtal::IsPairAssociativeContainer< T >
 CDGtal::detail::IsPairAssociativeContainerFromCategory< TCategory >
 CDGtal::IsSequenceContainer< T >
 CDGtal::detail::IsSequenceContainerFromCategory< TCategory >
 CDGtal::IsSimpleAssociativeContainer< T >
 CDGtal::detail::IsSimpleAssociativeContainerFromCategory< TCategory >
 CDGtal::IsUniqueAssociativeContainer< T >
 CDGtal::detail::IsUniqueAssociativeContainerFromCategory< TCategory >
 CDGtal::IsUnorderedAssociativeContainer< T >
 CDGtal::detail::IsUnorderedAssociativeContainerFromCategory< TCategory >
 CDGtal::functors::IsUpperPointPredicate< TPoint >Aim: The predicate returns true when the point is above (or equal) the given lower bound
 CDGtal::functors::IsWithinPointPredicate< TPoint >Aim: The predicate returns true when the point is within the given bounds
 CDGtal::functors::IsWithinPointPredicate< Point >
 CDGtal::experimental::ImageContainerByHashTree< TDomain, TValue, THashKey >::IteratorBuilt-in iterator on an HashTree. This iterator visits all node in the tree
 Citerator
 CDGtal::IndexedListWithBlocks< TValue, N, M >::Iterator
 Citerator_adaptor
 Citerator_facade
 Citerator_facade
 CDGtal::IteratorCirculatorTraits< IC >Aim: Provides nested types for both iterators and circulators: Type, Category, Value, Difference, Pointer and Reference
 CDGtal::IteratorCirculatorTraits< T * >
 CDGtal::IteratorCirculatorTraits< T const * >
 CDGtal::IteratorCirculatorType< IC >Aim: Provides the type of IC as a nested type: either IteratorType or CirculatorType
 CDGtal::detail::IteratorCirculatorTypeImpl< b >Aim: Defines the Iterator or Circulator type as a nested type according to the value of b
 CDGtal::detail::IteratorCirculatorTypeImpl< true >
 CDGtal::IteratorCompletion< TDerived >Aim: Class that uses CRTP to add reverse iterators and ranges to a derived class
 CDGtal::IteratorCompletion< ArrayImageAdapter< TArrayIterator, HyperRectDomain< TSpace > > >
 CDGtal::IteratorCompletion< MyImage< T, N > >
 CDGtal::IteratorCompletionTraits< TDerived >Aim: Traits that must be specialized for each IteratorCompletion derived class
 CDGtal::IteratorCompletionTraits< ArrayImageAdapter< TArrayIterator, TDomain > >[IteratorCompletionTraits]
 CDGtal::IteratorType
 CDGtal::ITKIOTrait< Value >Aim: Provide type trait for ITK reader and ITK writer
 CDGtal::ITKIOTrait< bool >
 CDGtal::ITKReader< TImage, TFunctor >Aim: Import a 2D/3D Image using the ITK formats
 CDGtal::ITKWriter< TImage, TFunctor >Export a 2D/3D Image using the ITK formats
 CDGtal::IVector< T, TAlloc, usePointers >
 CDGtal::IVector< T, TAlloc, true >
 CDGtal::KanungoNoise< TPointPredicate, TDomain, TDigitalSetContainer >Aim: From a point predicate (model of concepts::CPointPredicate), this class constructs another point predicate as a noisy version of the input one
 CDGtal::detail::KeyComparatorForPairKeyData< KeyComparator, PairKeyData >
 CDGtal::LabelledMap< TData, L, TWord, N, M >::KeyCompareKey comparator class. Always natural ordering
 CDGtal::KForm< TCalculus, order, duality >Aim: KForm represents discrete kforms in the dec package
 CDGtal::KhalimskyCell< dim, TInteger >Represents an (unsigned) cell in a cellular grid space by its Khalimsky coordinates
 CDGtal::KhalimskyCell< dim, Integer >
 CDGtal::KhalimskyPreCell< dim, TInteger >
 CDGtal::KhalimskyPreCell< dim, Integer >
 CDGtal::KhalimskyPreSpaceND< dim, TInteger >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)
 CDGtal::KhalimskySpaceNDHelper< TKhalimskySpace >
 CDGtal::KhalimskySpaceNDHelper< KhalimskySpaceND< dim, TInteger > >
 CDGtal::L1LengthEstimator< TConstIterator >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)
 CDGtal::L1LocalDistance< TImage, TSet >Aim: Class for the computation of the L1-distance at some point p, from the available distance values of some points lying in the 1-neighborhood of p (ie. points at a L1-distance to p equal to 1)
 CDGtal::L2FirstOrderLocalDistance< TImage, TSet >Aim: Class for the computation of the Euclidean distance at some point p, from the available distance values of some points lying in the 1-neighborhood of p (ie. points at a L1-distance to p equal to 1)
 CDGtal::L2FirstOrderLocalDistanceFromCells< TKSpace, TMap, isIndirect >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 (d-1)-cells lying between p and these points
 CDGtal::L2SecondOrderLocalDistance< TImage, TSet >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
 CDGtal::LabelledMap< TData, L, TWord, N, M >Aim: Represents a map label -> data, where the label is an integer between 0 and a constant L-1. 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
 CDGtal::LabelledMap< Value, L, TWord, N, M >
 CDGtal::detail::LabelledMapMemFunctor
 CDGtal::Labels< L, TWord >Aim: Stores a set of labels in {O..L-1} as a sequence of bits
 CDGtal::Labels< L, Word >
 CDGtal::LambdaMST2DEstimator< TSpace, TSegmentation, Functor >
 CDGtal::LambdaMST2DEstimator< Z2i::Space, DSSSegmentationComputer, TangentFromDSS2DFunctor< DSSSegmentationComputer::SegmentComputer, LambdaFunction > >
 CDGtal::LambdaMST3DEstimator< TSpace, TSegmentation, Functor >
 CDGtal::LambdaMST3DEstimator< Z3i::Space, DSSSegmentationComputer, TangentFromDSS3DFunctor< DSSSegmentationComputer::SegmentComputer, LambdaFunction > >
 CDGtal::functors::LargeTruncationFunctor< Integer >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| \)
 CDGtal::LatticePolytope2D< TSpace, TSequence >Aim: Represents a 2D polytope, i.e. a convex polygon, in the two-dimensional digital plane. The list of points must follow the clockwise ordering
 CDGtal::LatticePolytope2D< InternalSpace2 >
 CDGtal::experimental::ChamferNorm2D< TSpace >::LessOrEqThanAngular
 CDGtal::experimental::ChamferNorm2D< TSpace >::LessThanAngular
 Cboost::LessThanComparable< T >Go to http://www.sgi.com/tech/stl/LessThanComparable.html
 CDGtal::LighterSternBrocot< TInteger, TQuotient, TMap >Aim: The Stern-Brocot 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
 CDGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >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
 CDGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >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
 CDGtal::LightSternBrocot< TInteger, TQuotient, TMap >Aim: The Stern-Brocot 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
 CDGtal::LinearAlgebra< Space >Aim: A utility class that contains methods to perform integral linear algebra
 CDGtal::Linearizer< TDomain, TStorageOrder >Aim: Linearization and de-linearization interface for domains
 CDGtal::Linearizer< HyperRectDomain< TSpace >, TStorageOrder >Aim: Linearization and de-linearization interface for HyperRectDomain
 CDGtal::functors::LinearLeastSquareFittingNormalVectorEstimator< TSurfel, TEmbedder >Aim: Estimates normal vector using CGAL linear least squares plane fitting
 CDGtal::LinearOperator< TCalculus, order_in, duality_in, order_out, duality_out >Aim: LinearOperator represents discrete linear operator between discrete kforms in the DEC package
 CDGtal::LInfLocalDistance< TImage, TSet >Aim: Class for the computation of the LInf-distance at some point p, from the available distance values of some points lying in the 1-neighborhood of p (ie. points at a L1-distance to p equal to 1)
 CDGtal::deprecated::LocalConvolutionNormalVectorEstimator< TDigitalSurface, TKernelFunctor >Aim: Computes the normal vector at a surface element by convolution of elementary normal vector to adjacent surfel
 CDGtal::LocalEstimatorFromSurfelFunctorAdapter< TDigitalSurfaceContainer, TMetric, TFunctorOnSurfel, TConvolutionFunctor >Aim: this class adapts any local functor on digital surface element to define a local estimator. This class is model of CDigitalSurfaceLocalEstimator
 CDGtal::LOG2< X >
 CDGtal::LOG2< 1 >
 CDGtal::LOG2< 2 >
 CDGtal::LongvolReader< TImageContainer, TFunctor >Aim: implements methods to read a "Longvol" file format (with DGtal::uint64_t value type)
 CDGtal::LongvolWriter< TImage, TFunctor >Aim: Export a 3D Image using the Longvol formats (volumetric image with DGtal::uint64_t value type)
 Cboost_concepts::LvalueIteratorConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/LvalueIteratorConcept.html
 CDGtal::MagickReader< TImageContainer, TFunctor >Aim: implements methods to read a 2D image using the ImageMagick library
 Cstd::map< K, T >STL class
 CDGtal::functors::MeanChannels
 CDGtal::MeaningfulScaleAnalysis< TProfile >Aim: This class implements different methods used to define the meaningful scale analysis as proposed in [38] . In particular, it uses the Profile class to represent a multi-scale profile and to compute a meaningful scale. It also permits to get a noise estimation from the given profile
 CDGtal::Measure< TSet >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,..
 CDGtal::MeasureOfStraightLinesThe 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 $ax-y+b=0$ to the point $(a,b)$
 CDGtal::MelkmanConvexHull< TPoint, TOrientationFunctor >Aim: This class implements the on-line algorithm of Melkman for the computation of the convex hull of a simple polygonal line (without self-intersection) [Melkman, 1987: [46]]
 CDGtal::MelkmanConvexHull< InputPoint, DGtal::InHalfPlaneBySimple3x3Matrix >
 CDGtal::Mesh< TPoint >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')
 CDGtal::MeshReader< TPoint >Aim: Defined to import OFF and OFS surface mesh. It allows to import a Mesh object and takes into accouts the optional color faces
 CDGtal::MeshWriter< TPoint >Aim: Export a Mesh (Mesh object) in different format as OFF and OBJ)
 CLibBoard::MessageStream
 CDGtal::MetricAdjacency< TSpace, maxNorm1, dimension >Aim: Describes digital adjacencies in digital spaces that are defined with the 1-norm and the infinity-norm
 CDGtal::MLPLengthEstimator< TConstIterator >Aim: a model of CGlobalCurveEstimator that computes the length of a digital curve using its MLP (given by the FP)
 CDGtal::ModuloComputer< TInteger >Implements basic functions on modular arithmetic
 CDGtal::functors::MongeJetFittingGaussianCurvatureEstimator< TSurfel, TEmbedder >Aim: Estimates Gaussian curvature using CGAL Jet Fitting and Monge Form
 CDGtal::functors::MongeJetFittingMeanCurvatureEstimator< TSurfel, TEmbedder >Aim: Estimates Mean curvature using CGAL Jet Fitting and Monge Form
 CDGtal::functors::MongeJetFittingNormalVectorEstimator< TSurfel, TEmbedder >Aim: Estimates normal vector using CGAL Jet Fitting and Monge Form
 CDGtal::functors::MongeJetFittingPrincipalCurvaturesEstimator< TSurfel, TEmbedder >Aim: Estimates Gaussian curvature using CGAL Jet Fitting and Monge Form
 CDGtal::detail::monomial_node
 CDGtal::Morton< THashKey, TPoint >Aim: Implements the binary Morton code construction in nD
 CDGtal::Morton< HashKey, DGtal::PointVector >
 CDGtal::MostCenteredMaximalSegmentEstimator< SegmentComputer, SCEstimator >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
 CDGtal::MPolynomial< n, TRing, TAlloc >Aim: Represents a multivariate polynomial, i.e. an element of \( K[X_0, ..., X_{n-1}] \), where K is some ring or field
 CDGtal::MPolynomial< 0, TRing, TAlloc >Aim: Specialization of MPolynomial for degree 0
 CDGtal::MPolynomial< 3, Ring >
 CDGtal::MPolynomial< n, Ring, Alloc >
 CDGtal::MPolynomialDerivativeComputer< N, n, Ring, Alloc >
 CDGtal::MPolynomialDerivativeComputer< 0, 0, Ring, Alloc >
 CDGtal::MPolynomialDerivativeComputer< 0, n, Ring, Alloc >
 CDGtal::MPolynomialDerivativeComputer< N, 0, Ring, Alloc >
 CDGtal::MPolynomialEvaluator< n, TRing, TAlloc, TX >
 CDGtal::MPolynomialEvaluator< 1, TRing, TAlloc, TX >
 CDGtal::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX >
 CDGtal::MPolynomialEvaluatorImpl< 1, Ring, Owner, Alloc, X >
 CDGtal::MPolynomialEvaluatorImpl< 1, TRing, TOwner, TAlloc, TX >
 CDGtal::MPolynomialEvaluatorImpl< n, Ring, Owner, Alloc, X >
 CDGtal::MPolynomialReader< n, TRing, TAlloc, TIterator >Aim: This class converts a string polynomial expression in a multivariate polynomial
 Cboost::MultiPassInputIterator< G >Go to http://www.boost.org/doc/libs/1_52_0/libs/utility/MultiPassInputIterator.html
 Cboost::MultipleAssociativeContainer< C >Go to http://www.sgi.com/tech/stl/MultipleAssociativeContainer.html
 CDGtal::MultiStatisticsAim: 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
 Cmutable_bidirectional_iterator_archetype
 Cboost::Mutable_BidirectionalIterator< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::Mutable_Container< C >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::Mutable_ForwardContainer< C >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::Mutable_ForwardIterator< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::Mutable_RandomAccessContainer< C >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::Mutable_RandomAccessIterator< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 Cboost::Mutable_ReversibleContainer< C >Go to http://www.boost.org/libs/concept_check/reference.htm
 CDGtal::Naive3DDSSComputer< TIterator, TInteger, connectivity >Aim: Dynamic recognition of a 3d-digital straight segment (DSS)
 CDGtal::Negate< T >
 CDGtal::Negate< TagFalse >
 CDGtal::Negate< TagTrue >
 CDGtal::LighterSternBrocot< TInteger, TQuotient, TMap >::Node
 CDGtal::SternBrocot< TInteger, TQuotient >::Node
 CDGtal::experimental::ImageContainerByHashTree< TDomain, TValue, THashKey >::Node
 CDGtal::LightSternBrocot< TInteger, TQuotient, TMap >::Node
 CDGtal::GraphVisitorRange< TGraphVisitor >::NodeAccessor
 CDGtal::detail::NormalizedTangentVectorFromDSS
 CDGtal::VoronoiCovarianceMeasureOnDigitalSurface< TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction >::NormalsStructure to hold the normals for each surfel (the VCM one and the trivial one)
 CDGtal::NormalVectorEstimatorLinearCellEmbedder< TDigitalSurface, TNormalVectorEstimator, TEmbedder >Aim: model of cellular embedder for normal vector estimators on digital surface, (default constructible, copy constructible, assignable)
 CDGtal::detail::NormalVectorFromDCA
 CDGtal::functors::NotBoolFct1
 CDGtal::NotContainerCategory
 CDGtal::functors::NotPointPredicate< TPointPredicate >Aim: The predicate returns true when the point predicate given at construction return false. Thus inverse a predicate: NOT operator
 CDGtal::functors::NotPointPredicate< InCoreDomainPredicate >
 CDGtal::NumberTraits< T >Aim: The traits class for all models of Cinteger
 CDGtal::NumberTraits< double >
 CDGtal::NumberTraits< float >
 CDGtal::NumberTraits< int16_t >
 CDGtal::NumberTraits< int32_t >
 CDGtal::NumberTraits< int64_t >
 CDGtal::NumberTraits< int8_t >
 CDGtal::NumberTraits< Integer >
 CDGtal::NumberTraits< long double >
 CDGtal::NumberTraits< TInteger >
 CDGtal::NumberTraits< uint16_t >
 CDGtal::NumberTraits< uint32_t >
 CDGtal::NumberTraits< uint64_t >
 CDGtal::NumberTraits< uint8_t >
 CDGtal::Object< TDigitalTopology, TDigitalSet >Aim: An object (or digital object) represents a set in some digital space associated with a digital topology
 CDGtal::Object< FixtureDigitalTopology, FixtureDigitalSet >
 CDGtal::FrechetShortcut< TIterator, TInteger >::Backpath::occulter_attributes
 CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >Aim:
 CDGtal::OpInSTLContainers< Container, Iterator >Aim: Implementation of an adapter for erase and insert methods of STL containers so that they not only work for the iterator type, but also for the reverse_iterator type
 CDGtal::OpInSTLContainers< Container, std::reverse_iterator< typename Container::iterator > >
 CDGtal::OppositeDuality< duality_orig >
 CDGtal::OppositeDuality< DUAL >
 CDGtal::OppositeDuality< PRIMAL >
 CDGtal::functors::OrBoolFct2
 CDGtal::OrderedAlphabetAim: 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)
 CDGtal::OrderedLinearRegressionDescription of class 'OrderedLinearRegression'
 Cboost::OutputIterator< T >Go to http://www.sgi.com/tech/stl/OutputIterator.html
 CDGtal::OwningOrAliasingPtr< T >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
 Cpair
 CDGtal::functors::Pair1st< ReturnType >Aim: Define a simple functor that returns the first member of a pair
 CDGtal::functors::Pair1st< Point >
 CDGtal::functors::Pair1stMutator< ReturnType >Aim: Define a simple unary functor that returns a reference on the first member of a pair in order to update it
 CDGtal::functors::Pair2nd< ReturnType >Aim: Define a simple functor that returns the second member of a pair
 CDGtal::functors::Pair2ndMutator< ReturnType >Aim: Define a simple unary functor that returns a reference on the first member of a pair in order to update it
 Cboost::PairAssociativeContainer< C >Go to http://www.sgi.com/tech/stl/PairAssociativeContainer.html
 CDGtal::ParallelStrip< TSpace, muIncluded, muPlusNuIncluded >Aim: A parallel strip in the space is the intersection of two parallel half-planes such that each half-plane includes the other
 CDGtal::ParametricShapeArcLengthFunctor< TParametricShape >Aim: implements a functor that estimates the arc length of a paramtric curve
 CDGtal::ParametricShapeCurvatureFunctor< TParametricShape >Aim: implements a functor that computes the curvature at a given point of a parametric shape
 CDGtal::ParametricShapeTangentFunctor< TParametricShape >Aim: implements a functor that computes the tangent vector at a given point of a parametric shape
 CDGtal::functors::SphereFittingEstimator< TSurfel, TEmbedder, TNormalVectorEstimatorCache >::PatatePoint
 CLibBoard::PathA path, according to Postscript and SVG definition
 CDGtal::Pattern< TFraction >Aim: This class represents a pattern, i.e. the path between two consecutive upper leaning points on a digital straight line
 CDGtal::Pattern< Fraction >
 CDGtal::PGMReader< TImageContainer, TFunctor >Aim: Import a 2D or 3D using the Netpbm formats (ASCII mode)
 CDGtal::PGMWriter< TImage, TFunctor >Aim: Export a 2D and a 3D Image using the Netpbm PGM formats (ASCII mode)
 CLibBoard::PointStruct representing a 2D point
 CDGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >Aim: Functor that embeds a 2D point into a 3D space from two axis vectors and an origin point given in the 3D space
 CDGtal::functors::Point2ShapePredicate< TSurface, isUpward, isClosed >Aim: Predicate returning 'true' iff a given point is in the 'interior' of a given shape, 'false' otherwise
 CDGtal::functors::Point2ShapePredicateComparator< T, b1, b2 >Aim: A small struct with an operator that compares two values according to two bool template parameters
 CDGtal::functors::Point2ShapePredicateComparator< T, false, false >Aim: A small struct with an operator that compares two values (<)
 CDGtal::functors::Point2ShapePredicateComparator< T, false, true >Aim: A small struct with an operator that compares two values (<=)
 CDGtal::functors::Point2ShapePredicateComparator< T, true, false >Aim: A small struct with an operator that compares two values (>)
 CDGtal::functors::Point2ShapePredicateComparator< T, true, true >Aim: A small struct with an operator that compares two values (>=)
 CDGtal::functors::PointFunctorFromPointPredicateAndDomain< TPointPredicate, TDomain, TValue >Create a point functor from a point predicate and a domain
 CDGtal::functors::PointFunctorPredicate< TPointFunctor, TPredicate >Aim: The predicate returns true when the predicate returns true for the value assigned to a given point in the point functor
 CDGtal::PointListReader< TPoint >Aim: Implements method to read a set of points represented in each line of a file
 CDGtal::detail::PointValueCompare< T >Aim: Small binary predicate to order candidates points according to their (absolute) distance value
 CDGtal::PointVector< dim, TEuclideanRing, TContainer >Aim: Implements basic operations that will be used in Point and Vector classes
 CDGtal::PointVector< 2, double >
 CDGtal::PointVector< 2, Integer >
 CDGtal::PointVector< 3, double >
 CDGtal::PointVector< 3, InternalInteger >
 CDGtal::PointVector< 3, InternalScalar >
 CDGtal::PointVector< dim, Integer >
 CDGtal::PointVector< Space::dimension, Real >
 CDGtal::functors::PolarPointComparatorBy2x2DetComputer< TPoint, TDetComputer >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 counter-clockwise orientation)
 CDGtal::detail::PosDepScaleDepSCEstimator< TSegmentComputer, Functor, ReturnType >
 CDGtal::detail::PosDepScaleDepSCEstimator< DCAComputer, detail::DistanceFromDCA >
 CDGtal::detail::PosDepScaleIndepSCEstimator< TSegmentComputer, Functor, ReturnType >
 CDGtal::detail::PosDepScaleIndepSCEstimator< DCAComputer, detail::NormalVectorFromDCA >
 CDGtal::detail::PosDepScaleIndepSCEstimator< DCAComputer, detail::TangentVectorFromDCA >
 CDGtal::detail::PosIndepScaleDepSCEstimator< TSegmentComputer, Functor, ReturnType >
 CDGtal::detail::PosIndepScaleDepSCEstimator< DCAComputer, detail::CurvatureFromDCA< isCCW > >
 CDGtal::detail::PosIndepScaleIndepSCEstimator< TSegmentComputer, Functor, ReturnType >
 CDGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::NormalizedTangentVectorFromDSS >
 CDGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::TangentAngleFromDSS >
 CDGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::TangentVectorFromDSS< DSSComputer > >
 CDGtal::functors::PositionFunctorFrom2DPoint< Vector, TPosition >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
 CDGtal::POW< X, exponent >
 CDGtal::POW< X, 0 >
 CDGtal::POW< X, 1 >
 CDGtal::detail::power_node
 CDGtal::PowerMap< TWeightImage, TPowerSeparableMetric, TImageContainer >Aim: Implementation of the linear in time Power map construction
 CDGtal::PowerMap< TWeightImage, TPSeparableMetric, TImageContainer >
 CDGtal::PPMReader< TImageContainer, TFunctor >Aim: Import a 2D or 3D using the Netpbm formats (ASCII mode)
 CDGtal::PPMWriter< TImage, TFunctor >Aim: Export a 2D and a 3D Image using the Netpbm PPM formats (ASCII mode)
 CDGtal::PreCellDirectionIterator< dim, TInteger >This class is useful for looping on all "interesting" coordinates of a pre-cell. For instance, surfels in Z3 have two interesting coordinates (the ones spanned by the surfel)
 CDGtal::functors::PredicateCombiner< TPredicate1, TPredicate2, TBinaryFunctor >Aim: The predicate returns true when the given binary functor returns true for the two Predicates given at construction
 CDGtal::functors::PredicateCombiner< Tlow, Tup, AndBoolFct2 >
 CDGtal::PredicateFromOrientationFunctor2< TOrientationFunctor, acceptNeg, acceptZero >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
 CDGtal::PredicateFromOrientationFunctor2< Functor, false, false >
 CDGtal::PredicateFromOrientationFunctor2< Functor, true, false >
 CDGtal::Preimage2D< Shape >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)
 CDGtal::Profile< TValueFunctor, TValue >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
 CDGtal::functors::Projector< S >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, ..., j-1) by default - that are copied from P to Q
 CDGtal::functors::Projector< SpaceND< 2, Coordinate > >
 CDGtal::promote_trait< A, B >
 CDGtal::promote_trait< int32_t, int64_t >
 CDGtal::DiscreteExteriorCalculus< dimEmbedded, dimAmbient, TLinearAlgebraBackend, TInteger >::PropertyHolds 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
 CQGLViewer
 CDGtal::functors::SphereFittingEstimator< TSurfel, TEmbedder, TNormalVectorEstimatorCache >::QuantityQuantity type: a 3-sphere (model of CQuantity)
 Cboost::RandomAccessContainer< C >Go to http://www.sgi.com/tech/stl/RandomAccessContainer.html
 Cboost::RandomAccessIterator< T >Go to http://www.sgi.com/tech/stl/RandomAccessIterator.html
 Cboost_concepts::RandomAccessTraversalConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/RandomAccessTraversal.html
 CDGtal::RandomColorMapAim: access to random color from a gradientColorMap
 CDGtal::RawReader< TImageContainer, TFunctor >Aim: Raw binary import of an Image
 CDGtal::RawWriter< TImage, TFunctor >Aim: Raw binary export of an Image
 CDGtal::DSLSubsegment< TInteger, TNumber >::RayC
 CDGtal::RayIntersectionPredicate< TPoint >This class implements various intersection predicates between a ray and a triangle, a quad or a surfel in dimension 3
 Cboost_concepts::ReadableIteratorConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/ReadableIterator.html
 CDGtal::RealFFT< HyperRectDomain< TSpace >, T >
 CDGtal::StdMapRebinder::Rebinder< Key, Value >
 CLibBoard::RectStruct representing a rectangle on the plane
 CDGtal::functors::RedChannel
 CDGtal::ReducedMedialAxis< TPowerMap, TImageContainer >Aim: Implementation of the separable medial axis extraction
 CDGtal::RegularBinner< TQuantity >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)
 CDGtal::RegularPointEmbedder< TSpace >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)
 CDGtal::RegularPointEmbedder< Space >
 CDGtal::functors::Rescaling< TInputType, TOutputType >Aim: Functor allowing to rescale a value. Values of the initial scale [initMin,initMax] are rescaled to the new scale [newMin,newMax]
 Cboost::ReversibleContainer< C >Go to http://www.sgi.com/tech/stl/ReversibleContainer.html
 CDGtal::RowMajorStorageTag (empty structure) specifying a row-major storage order
 CDGtal::concepts::ConceptUtils::SameType< T1, T2 >
 CDGtal::concepts::ConceptUtils::SameType< T, T >
 CDGtal::SaturatedSegmentation< TSegmentComputer >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)
 CDGtal::KhalimskyPreSpaceND< dim, TInteger >::SCellMap< Value >
 CDGtal::KhalimskySpaceND< dim, TInteger >::SCellMap< Value >
 CDGtal::functors::SCellToArrow< KSpace >Aim: transforms a signed cell into an arrow, ie. a pair point-vector
 CDGtal::functors::SCellToCode< KSpace >Aim: transforms a 2d signed cell, basically a linel, into a code (0,1,2 or 3),
 CDGtal::functors::SCellToIncidentPoints< KSpace >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
 CDGtal::functors::SCellToInnerPoint< KSpace >Aim: transforms a signed cell c into a point corresponding to the signed cell of greater dimension that is indirectly incident to c
 CDGtal::functors::deprecated::SCellToMidPoint< KSpace >Aim: transforms a scell into a real point (the coordinates are divided by 2)
 CDGtal::functors::SCellToOuterPoint< KSpace >Aim: transforms a signed cell c into a point corresponding to the signed cell of greater dimension that is directly incident to c
 CDGtal::functors::SCellToPoint< KSpace >Aim: transforms a scell into a point
 CDGtal::GreedySegmentation< TSegmentComputer >::SegmentComputerIteratorAim: Specific iterator to visit all the segments of a greedy segmentation
 CDGtal::SaturatedSegmentation< TSegmentComputer >::SegmentComputerIteratorAim: Specific iterator to visit all the maximal segments of a saturated segmentation
 CDGtal::SegmentComputerTraits< SC >Aim: Provides the category of the segment computer {ForwardSegmentComputer,BidirectionalSegmentComputer, DynamicSegmentComputer, DynamicBidirectionalSegmentComputer}
 CDGtal::Display3D< Space, KSpace >::SelectCallbackFctStore
 CDGtal::SeparableMetricAdapter< TMetric >Aim: Adapts any model of CMetric to construct a separable metric (model of CSeparableMetric)
 Cboost::Sequence< C >Go to http://www.sgi.com/tech/stl/Sequence.html
 CDGtal::SetFromImage< TSet >Aim: Define utilities to convert a digital set into an image
 CDGtal::detail::SetFunctionsImpl< Container, associative, ordered >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
 CDGtal::detail::SetFunctionsImpl< Container, false, true >
 CDGtal::detail::SetFunctionsImpl< Container, true, false >
 CDGtal::detail::SetFunctionsImpl< Container, true, true >
 CDGtal::SetOfSurfels< TKSpace, TSurfelSet >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
 CDGtal::deprecated::SetPredicate< TDigitalSet >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
 Cboost::SGIAssignable< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 CLibBoard::ShapeAbstract structure for a 2D shape
 CDGtal::functors::ShapeGeometricFunctors::ShapeMeanCurvatureFunctor< TShape >Aim: A functor RealPoint -> Quantity that returns the mean curvature at given point
 CDGtal::functors::ShapeGeometricFunctors::ShapeNormalVectorFunctor< TShape >Aim: A functor RealPoint -> Quantity that returns the normal vector at given point
 CDGtal::functors::ShapeGeometricFunctors::ShapePositionFunctor< TShape >Aim: A functor RealPoint -> Quantity that returns the position of the point itself
 CDGtal::Shapes< TDomain >Aim: A utility class for constructing different shapes (balls, diamonds, and others)
 CDGtal::Signal< TValue >Aim: Represents a discrete signal, periodic or not. The signal can be passed by value since it is only cloned when modified
 CDGtal::Signal< Value >
 CDGtal::SignalData< TValue >
 Cboost::SignedInteger< T >Go to http://www.sgi.com/tech/stl/SignedInteger.html
 CDGtal::SignedKhalimskyCell< dim, TInteger >Represents a signed cell in a cellular grid space by its Khalimsky coordinates and a boolean value
 CDGtal::SignedKhalimskyPreCell< dim, TInteger >
 CDGtal::SignedKhalimskyPreCell< dim, Integer >
 CDGtal::Simple2x2DetComputer< TArgumentInteger, TResultInteger >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} \)
 CDGtal::Simple2x2DetComputer< Integer >
 Cboost::SimpleAssociativeContainer< C >Go to http://www.sgi.com/tech/stl/SimpleAssociativeContainer.html
 CDGtal::SimpleConstRange< TConstIterator >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 read-only manner)
 CDGtal::SimpleIncremental2x2DetComputer< TArgumentInteger, TResultInteger >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} \)
 CDGtal::SimpleLinearRegressionDescription of class 'SimpleLinearRegression'
 CDGtal::SimpleMatrix< TComponent, TM, TN >Aim: implements basic MxN Matrix services (M,N>=1)
 CDGtal::SimpleMatrix< double, 3, 3 >
 CDGtal::SimpleMatrix< Integer, 3, 3 >
 CDGtal::SimpleMatrixSpecializations< TMatrix, TM, TN >Aim: Implement internal matrix services for specialized matrix size
 CDGtal::SimpleMatrixSpecializations< TMatrix, 1, 1 >Aim:
 CDGtal::SimpleMatrixSpecializations< TMatrix, 2, 2 >Aim:
 CDGtal::SimpleMatrixSpecializations< TMatrix, 3, 3 >Aim:
 CDGtal::SimpleRandomAccessConstRangeFromPoint< TConstIterator, DistanceFunctor >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 read-only manner)
 CDGtal::SimpleRandomAccessRangeFromPoint< TConstIterator, TIterator, DistanceFunctor >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 read-only manner)
 CDGtal::functors::SimpleThresholdForegroundPredicate< Image >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
 Cboost_concepts::SinglePassIteratorConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/SinglePassIterator.html
 CDGtal::functors::SliceRotator2D< TDomain3D, TInteger >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())
 Cboost::SortedAssociativeContainer< C >Go to http://www.sgi.com/tech/stl/SortedAssociativeContainer.html
 CDGtal::SpaceND< dim, TInteger >Aim: SpaceND is a utility class that defines the fundamental structure of a Digital Space in ND
 CDGtal::SpaceND< 2, Integer >
 CDGtal::ImageContainerBySTLVector< TDomain, TValue >::SpanIterator
 CDGtal::SpatialCubicalSubdivision< TSpace >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
 CDGtal::SpeedExtrapolator< TDistanceImage, TSet, TSpeedFunctor >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 1-neighborhood of p (ie. points at a L1-distance to p equal to 1) in order to extrapolate a speed field in the normal direction to the interface
 CDGtal::functors::SphereFittingEstimator< TSurfel, TEmbedder, TNormalVectorEstimatorCache >Aim: Use Patate library to perform a local sphere fitting
 CDGtal::SphericalAccumulator< TVector >Aim: implements an accumulator (as histograms for 1D scalars) adapted to spherical point samples
 CDGtal::SphericalAccumulator< RealPoint >
 CDGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >Aim: This functor estimates normal vector for a collection of surfels using spherical accumulator based Hough voting
 CDGtal::StabbingCircleComputer< TConstIterator >Aim: On-line 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
 CDGtal::StabbingLineComputer< TConstIterator >Aim: On-line 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
 CDGtal::StandardDSLQ0< TFraction >Aim: Represents a digital straight line with slope in the first quadrant (Q0: x >= 0, y >= 0 )
 CDGtal::StandardDSS6Computer< TIterator, TInteger, connectivity >Aim: Dynamic recognition of a 3d-digital straight segment (DSS)
 CDGtal::StarShaped2D< TSpace >
 CDGtal::StarShaped3D< TSpace >
 CLibBoard::Board::State
 CDGtal::ChordNaivePlaneComputer< TSpace, TInputPoint, TInternalScalar >::State
 CDGtal::AlphaThickSegmentComputer< TInputPoint, TConstIterator >::State
 CDGtal::UmbrellaComputer< TDigitalSurfaceTracker >::State
 CDGtal::COBANaivePlaneComputer< TSpace, TInternalInteger >::State
 Cstatic_object
 Cstatic_visitor
 CDGtal::Statistic< TQuantity >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
 CDGtal::Statistic< Value >
 CDGtal::StdMapRebinder
 CDGtal::SternBrocot< TInteger, TQuotient >Aim: The Stern-Brocot 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
 CDGtal::StraightLineFrom2Points< TPoint >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
 CDGtal::functors::StrictTruncationFunctor< Integer >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. i-1) 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
 CDGtal::Style2DFactory
 CDGtal::SpaceND< dim, TInteger >::Subcospace< codimension >Define the type of a sub co-Space
 CDGtal::SpaceND< dim, TInteger >::Subspace< subdimension >Define the type of a subspace
 CDGtal::Surfaces< TKSpace >Aim: A utility class for constructing surfaces (i.e. set of (n-1)-cells)
 CDGtal::SurfelAdjacency< dim >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
 CDGtal::SurfelAdjacency< KSpace::dimension >
 CDGtal::DigitalSurface< TDigitalSurfaceContainer >::SurfelMap< Value >
 CDGtal::KhalimskyPreSpaceND< dim, TInteger >::SurfelMap< Value >
 CDGtal::KhalimskySpaceND< dim, TInteger >::SurfelMap< Value >
 CDGtal::SurfelNeighborhood< TKSpace >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 n-2 cell. This class uses a SurfelAdjacency so as to determine adjacent surfels (either looking for them from interior to exterior or inversely)
 CDGtal::SurfelNeighborhood< KSpace >
 CDGtal::functors::SurfelSetPredicate< TSurfelSet, TSurfel >Aim: The predicate returning true iff the point is in the domain given at construction
 CDGtal::functors::SurfelSetPredicate< SurfelSet, Surfel >
 Cboost_concepts::SwappableIteratorConcept< Iterator >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/SwappableIterator.html
 CDGtal::TableReader< TQuantity >Aim: Implements method to read a set of numbers represented in each line of a file
 CDGtal::TagFalse
 CDGtal::TagTrue
 CDGtal::TagUnknown
 CDGtal::detail::TangentAngleFromDSS
 CDGtal::TangentFromBinomialConvolverFunctor< TBinomialConvolver, TRealPoint >Aim: This class is a functor for getting the tangent vector of a binomial convolver
 CDGtal::TangentFromDSS2DFunctor< DSS, LambdaFunction >
 CDGtal::TangentFromDSS3DFunctor< DSS, LambdaFunction >
 CDGtal::detail::TangentVectorFromDCA
 CDGtal::detail::TangentVectorFromDSS< DSS >
 CDGtal::Clone< T >::TempPtrInternal class that is used for a late deletion of an acquired pointer
 CDGtal::functors::TensorVotingFeatureExtraction< TSurfel, TEmbedder >Aim: Implements a functor to detect feature points from normal tensor voting strategy
 CDGtal::Viewer3D< Space, KSpace >::TextureImage
 CDGtal::TickedColorMap< TValue, TColorMap >Aim: This class adapts any colormap to add "ticks" in the colormap colors
 CDGtal::TiledImage< TImageContainer, TImageFactory, TImageCacheReadPolicy, TImageCacheWritePolicy >Aim: implements a tiled image from a "bigger/original" one from an ImageFactory
 CDGtal::TiledImageBidirectionalConstRangeFromPoint< TTiledImage >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 read-only manner)
 CDGtal::TiledImageBidirectionalRangeFromPoint< TTiledImage >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
 CTMap
 CDGtal::detail::toCoordinateImpl< TInput, TOutput >Aim: Define a simple functor that can cast a signed integer (possibly a DGtal::BigInteger) into another
 CDGtal::ToDGtalCategory< C >Aim: Provides the DGtal category matching C {ForwardCategory,BidirectionalCategory,RandomAccessCategory}
 CDGtal::ToDGtalCategory< boost::bidirectional_traversal_tag >
 CDGtal::ToDGtalCategory< boost::forward_traversal_tag >
 CDGtal::ToDGtalCategory< boost::iterators::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::bidirectional_traversal_tag > >
 CDGtal::ToDGtalCategory< boost::iterators::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::forward_traversal_tag > >
 CDGtal::ToDGtalCategory< boost::iterators::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::random_access_traversal_tag > >
 CDGtal::ToDGtalCategory< boost::random_access_traversal_tag >
 CDGtal::ToDGtalCategory< std::bidirectional_iterator_tag >
 CDGtal::ToDGtalCategory< std::forward_iterator_tag >
 CDGtal::ToDGtalCategory< std::random_access_iterator_tag >
 CDGtal::FrechetShortcut< TIterator, TInteger >::Tools
 CDGtal::detail::top_node
 CDGtal::TraceImplementation of basic methods to trace out messages with indentation levels
 CDGtal::TraceWriterVirtual Class to implement trace writers
 CDGtal::ExplicitDigitalSurface< TKSpace, TSurfelPredicate >::Tracker
 CDGtal::SetOfSurfels< TKSpace, TSurfelSet >::Tracker
 CDGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >::Tracker
 CDGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >::Tracker
 CDGtal::DigitalSetBoundary< TKSpace, TDigitalSet >::Tracker
 CDGtal::ImplicitDigitalSurface< TKSpace, TPointPredicate >::Tracker
 CLibBoard::TransformBase class for transforms
 CDGtal::ChordGenericStandardPlaneComputer< TSpace, TInputPoint, TInternalScalar >::Transform
 CDGtal::COBAGenericStandardPlaneComputer< TSpace, TInternalInteger >::Transform
 Ctransform_iterator
 CDGtal::functors::TrueBoolFct0
 CDGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >Aim: An estimator on digital surfaces that returns the reference local geometric quantity. This is used for comparing estimators
 CDGtal::TrueGlobalEstimatorOnPoints< TConstIteratorOnPoints, TParametricShape, TParametricShapeFunctor >Aim: Computes the true quantity to each element of a range associated to a parametric shape
 CDGtal::TrueLocalEstimatorOnPoints< TConstIteratorOnPoints, TParametricShape, TParametricShapeFunctor >Aim: Computes the true quantity to each element of a range associated to a parametric shape
 CDGtal::TwoStepLocalLengthEstimator< TConstIterator >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)
 CDGtal::UmbrellaComputer< TDigitalSurfaceTracker >Aim: Useful for computing umbrellas on 'DigitalSurface's, ie set of n-1 cells around a n-3 cell
 CDGtal::UmbrellaComputer< DigitalSurfaceTracker >
 Cunary_function
 Cboost::UnaryFunction< Func, Return, Arg >Go to http://www.sgi.com/tech/stl/UnaryFunction.html
 Cboost::UnaryPredicate< Func, Arg >Go to http://www.sgi.com/tech/stl/Predicate.html
 Cboost::UniqueAssociativeContainer< C >Go to http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
 Cboost::UnsignedInteger< T >Go to http://www.boost.org/libs/concept_check/reference.htm
 CDGtal::TangentFromDSS3DFunctor< DSS, LambdaFunction >::Value
 CDGtal::TangentFromDSS2DFunctor< DSS, LambdaFunction >::Value
 CDGtal::LabelledMap< TData, L, TWord, N, M >::ValueCompareValue comparator class. Always natural ordering between keys
 CDGtal::AngleLinearMinimizer::ValueInfo
 CDGtal::IndexedListWithBlocks< TValue, N, M >::ValueOrBlockPointerUsed in blocks to finish it or to point to the next block
 CDGtal::functors::VCMAbsoluteCurvatureFunctor< TVCMOnDigitalSurface >Aim: A functor Surfel -> Quantity that returns the absolute curvature at given surfel. This class has meaning only in 2D
 CDGtal::VCMDigitalSurfaceLocalEstimator< TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction, TVCMGeometricFunctor >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
 CDGtal::functors::VCMFirstPrincipalAbsoluteCurvatureFunctor< TVCMOnDigitalSurface >Aim: A functor Surfel -> Quantity that returns the first principal absolute curvature (greatest curvature) at given surfel. This class has meaning only in 3D
 CDGtal::functors::VCMMeanAbsoluteCurvatures3DFunctor< TVCMOnDigitalSurface >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
 CDGtal::functors::VCMNormalVectorFunctor< TVCMOnDigitalSurface >Aim: A functor Surfel -> Quantity that returns the outer normal vector at given surfel
 CDGtal::functors::VCMSecondPrincipalAbsoluteCurvatureFunctor< TVCMOnDigitalSurface >Aim: A functor Surfel -> Quantity that returns the second principal absolute curvature (smallest curvature) at given surfel. This class has meaning only in 3D
 Cstd::vector< T >STL class
 CDGtal::VectorField< TCalculus, duality >Aim: VectorField represents a discrete vector field in the dec package. Vector field values are attached to 0-cells with the same duality as the vector field
 Cvertex_list_graph_tag
 CDGtal::GraphVisitorRange< TGraphVisitor >::VertexAccessor
 Cboost::VertexListGraphConcept< G >Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/VertexListGraph.html
 CDGtal::Object< TDigitalTopology, TDigitalSet >::VertexMap< Value >
 CDGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >::VertexMap< Value >
 CDGtal::DomainAdjacency< TDomain, TAdjacency >::VertexMap< Value >
 CDGtal::DigitalSurface< TDigitalSurfaceContainer >::VertexMap< Value >
 CDGtal::concepts::CUndirectedSimpleLocalGraph< T >::VertexMap< Value >
 CDGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >::VertexMap< Value >
 CDGtal::MetricAdjacency< TSpace, maxNorm1, dimension >::VertexMap< Value >
 CDGtal::VolReader< TImageContainer, TFunctor >Aim: implements methods to read a "Vol" file format
 CDGtal::VolWriter< TImage, TFunctor >Aim: Export a 3D Image using the Vol formats
 CDGtal::VoronoiCovarianceMeasure< TSpace, TSeparableMetric >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
 CDGtal::VoronoiCovarianceMeasure< Space, Metric >
 CDGtal::VoronoiCovarianceMeasureOnDigitalSurface< TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction >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
 CDGtal::VoronoiMap< TSpace, TPointPredicate, TSeparableMetric, TImageContainer >Aim: Implementation of the linear in time Voronoi map construction
 CDGtal::Warning_promote_trait_not_specialized_for_this_case
 Cboost_concepts::WritableIteratorConcept< Iterator, ValueType >Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/WritableIterator.html
 CDGtal::Xe_kComputer< n, Ring, Alloc >
 CDGtal::Xe_kComputer< 0, Ring, Alloc >
 CDGtal::functors::XorBoolFct2