  DGtal::LabelledMap< TData, L, TWord, N, M >::__AnyBlock | |
| DGtal::LabelledMap< TData, L, TWord, N, M >::__FirstBlock | |
| DGtal::AbsFunctor< T > | |
 DGtal::Adapter< ArithmeticalDSS > | Aim: abstract adapter for ArithmeticalDSS. Has 2 virtual methods: |
 DGtal::Adapter4ConcavePart< ArithmeticalDSS > | Aim: adapter for ArithmeticalDSS used by FP in concave parts. Has 2 methods: |
 DGtal::Adapter4ConvexPart< ArithmeticalDSS > | Aim: adapter for ArithmeticalDSS used by FP in convex parts. Has 2 methods: |
| DGtal::AndBoolFct2 | |
| DGtal::AngleComputer | |
| DGtal::AngleLinearMinimizer | Aim: Used to minimize the angle variation between different angles while taking into accounts min and max constraints. Example ( |
| DGtal::AngleLinearMinimizerByAdaptiveStepGradientDescent | |
| DGtal::AngleLinearMinimizerByGradientDescent | |
| DGtal::AngleLinearMinimizerByRelaxation | |
| DGtal::IndexedListWithBlocks< TValue, N, M >::AnyBlock | |
| DGtal::KhalimskySpaceND< dim, TInteger >::AnyCellCollection< CellType > | |
| DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc | |
| DGtal::ArithmeticalDSS< TIterator, TInteger, connectivity > | Aim: Dynamic recognition of a digital straight segment (DSS) defined as the sequence of simply connected points (x,y) such that mu <= ax - by < mu + omega |
| DGtal::ArithmeticalDSS3d< TIterator, TInteger, connectivity > | Aim: Dynamic recognition of a 3d-digital straight segment (DSS) |
| ArrayLXY< Value, L, X, Y > | |
| ArrayXYOfLabelledMap< Value, L, X, Y, TWord, N, M > | |
| ArrayXYOfMap< Value, L, X, Y > | |
| Assignable | |
| DGtal::CPredicate< T, T::Surfel > | |
| DGtal::CSurfelPredicate< T > | Aim: Defines a predicate on a surfel |
| DGtal::CPredicate< T, T::Vertex > | |
| DGtal::CVertexPredicate< T > | Aim: Defines a predicate on a vertex |
| DGtal::CUnaryFunctor< T, T::Cell, T::RealPoint > | |
| DGtal::CCellEmbedder< T > | Aim: A cell embedder is a mapping from unsigned cells to Euclidean points. It adds inner types to functor |
| DGtal::CUnaryFunctor< T, T::Point, T::RealPoint > | |
| DGtal::CPointEmbedder< T > | Aim: A point embedder is a mapping from digital points to Euclidean points. It adds inner types to functor |
| DGtal::CUnaryFunctor< T, T::SCell, T::RealPoint > | |
 DGtal::CSCellEmbedder< T > | Aim: A cell embedder is a mapping from signed cells to Euclidean points. It adds inner types to functor |
 DGtal::CDigitalSurfaceEmbedder< T > | Aim: A digital surface embedder is a specialized mapping from signed cells to Euclidean points. It adds inner types to functor as well as a method to access the digital surface |
| DGtal::CCommutativeRing< T > | Aim: Defines the mathematical concept equivalent to a unitary commutative ring |
| DGtal::CEuclideanRing< T > | Aim: Defines the mathematical concept equivalent to a unitary commutative ring with a division operator |
| DGtal::CConvolutionWeights< T > | Aim: defines models of centered convolution kernel used for normal vector integration for instance |
| DGtal::CDigitalSet< T > | Aim: Represents a set of points within the given domain. This set of points is modifiable by the user |
| DGtal::CInteger< T > | Aim: The concept CInteger specifies what are the usual integer numbers, more precisely the ones that are representable on a computer |
| DGtal::CBoundedInteger< T > | Aim: The concept CBoundedInteger specifies what are the bounded integer numbers. Hence, it is a refinement of CInteger Concept ensuring that the numbers are bounded |
| DGtal::CSignedInteger< T > | Aim: Concept checking for Signed Integer |
| DGtal::CUnsignedInteger< T > | Aim: Concept checking for Unsigned Integer |
| DGtal::CLabel< T > | Aim: Define the concept of DGtal labels. Models of CLabel can be default-constructible, assignable and equality comparable |
| DGtal::CQuantity< T > | Aim: defines the concept of quantity in DGtal |
| DGtal::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| DGtal::CPredicate< T, TElement > | Aim: Defines a predicate function, ie. a functor mapping a domain into the set of booleans |
| DGtal::CSegment< T > | Aim: Defines the concept describing a segment, ie. a valid and not empty range |
| DGtal::CSegmentFactory< T > | Aim: Defines the concept describing a segment ie. a valid and not empty subrange, which can construct instances of its own type or of derived type |
| DGtal::CIncrementalSegmentComputer< T > | Aim: Defines the concept describing an incremental segment computer, ie. a model of CSegmentFactory that can, in addition, incrementally check whether or not an implicit predicate P is true. In other words, it can control its own extension from a range of one element (in the direction that is relative to the underlying iterator) so that an implicit predicate P remains true |
| DGtal::CForwardSegmentComputer< T > | Aim: Defines the concept describing a forward segment computer. Like any model of CIncrementalSegmentComputer, it can control its own extension (in the direction that is relative to the underlying iterator) so that an implicit predicate P remains true. However, contrary to models of CIncrementalSegmentComputer, it garantees that P is also true for any subrange of the whole segment at any time. This extra constraint is necessary to be able to incrementally check whether or not the segment is maximal |
| DGtal::CBidirectionalSegmentComputer< T > | Aim: Defines the concept describing a bidirectional segment computer, ie. a model of CSegment that can extend itself in the two possible directions |
| DGtal::CDynamicBidirectionalSegmentComputer< T > | Aim: Defines the concept describing a dynamic and bidirectional segment computer, ie. a model of CSegment that can extend and retract itself in either direction |
| DGtal::CDynamicSegmentComputer< T > | Aim: Defines the concept describing a dynamic segment computer, ie. a model of CSegment that can extend and retract itself (in the direction that is relative to the underlying iterator) |
| DGtal::CDynamicBidirectionalSegmentComputer< T > | Aim: Defines the concept describing a dynamic and bidirectional segment computer, ie. a model of CSegment that can extend and retract itself in either direction |
| DGtal::CSegmentComputerEstimator< T > | Aim: This concept is a refinement of CLocalGeometricEstimator devoted to the estimation of a geometric quantiy along a segment detected by a segment computer |
| DGtal::CUnaryFunctor< X, A, R > | Aim: Defines a unary functor, which associates arguments to results |
| DGtal::CVertexMap< T > | Aim: models of CVertexMap concept implement mapping between graph vertices and values |
| DGtal::FrechetShortcut< TIterator, TInteger >::Backpath | |
| BallFunctor< TPoint > | |
| BallPredicate< TPoint > | |
| DGtal::BidirectionalSegmentComputer | |
| DGtal::BinaryPointPredicate< TPointPredicate1, TPointPredicate2, TBinaryFunctor > | Aim: The predicate returns true when the given binary functor returns true for the two PointPredicates given at construction |
| DGtal::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 |
| DGtal::BinomialConvolverEstimator< TBinomialConvolver, TBinomialConvolverFunctor > | Aim: This class encapsulates a BinomialConvolver and a functor on BinomialConvolver so as to be a model of CLocalGeometricEstimator |
| DGtal::Bits | |
| DGtal::LabelledMap< TData, L, TWord, N, M >::BlockConstIterator | |
| DGtal::LabelledMap< TData, L, TWord, N, M >::BlockIterator | |
| DGtal::IndexedListWithBlocks< TValue, N, M >::BlockPointer | |
| DGtal::LabelledMap< TData, L, TWord, N, M >::BlockPointer | |
| DGtal::BasicColorToScalarFunctors::BlueChannel | |
| DGtal::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 |
| DGtal::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) |
| DGtal::CanonicCellEmbedder< TKSpace > | Aim: A trivial embedder for unsigned cell, which corresponds to the canonic injection of cell centroids into Rn |
| DGtal::CanonicDigitalSurfaceEmbedder< TDigitalSurface > | Aim: A trivial embedder for digital surfaces, which corresponds to the canonic injection of cell centroids into Rn |
| DGtal::CanonicEmbedder< TSpace > | Aim: A trivial embedder for digital points, which corresponds to the canonic injection of Zn into Rn |
| DGtal::CanonicSCellEmbedder< TKSpace > | Aim: A trivial embedder for signed cell, which corresponds to the canonic injection of cell centroids into Rn |
| DGtal::CastFunctor< TOutput > | Aim: Define a simple functor using the static cast operator |
| DGtal::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 |
| DGtal::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| DGtal::CBidirectionalIteratorArchetype< T > | An archetype of BidirectionalIterator |
| DGtal::CCellularGridSpaceND< T > | Aim: This concept describes a cellular grid space in nD. In these spaces obtained by cartesian product, cells have a cubic shape that depends on the dimension: 0-cells are points, 1-cells are unit segments, 2-cells are squares, 3-cells are cubes, and so on |
| DGtal::CColorMap< CMap > | Aim: Defines the concept describing a color map. A color map converts a value within a given range into an RGB triple |
| DGtal::CConstBidirectionalIteratorArchetype< T > | An archetype of ConstBidirectionalIterator |
| DGtal::CConstSinglePassRange< T > | Aim: Defines the concept describing a const range |
| DGtal::CConstSinglePassRangeFromPoint< T, Value > | |
| DGtal::CSinglePassOutputRangeFromPoint< T, Value > | Aim: refined concept of single pass range with a outputIterator() method from a point |
| DGtal::CConstBidirectionalRange< T > | |
| DGtal::CBidirectionalRange< T > | Aim: Defines the concept describing a bidirectional range |
| DGtal::CBidirectionalRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| DGtal::CConstBidirectionalRangeFromPoint< T > | Aim: refined concept of const bidirectional range with a begin() method from a point |
| DGtal::CBidirectionalRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| DGtal::CConstSinglePassRangeFromPoint< T > | Aim: refined concept of const single pass range with a begin() method from a point |
| DGtal::CSinglePassRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| DGtal::CDomain< T > | Aim: This concept represents a digital domain, i.e. a non mutable subset of points of the given digital space |
| DGtal::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| DGtal::CSinglePassRange< T > | Aim: Defines the concept describing a range |
| DGtal::CSinglePassRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| DGtal::CUndirectedSimpleGraph< T > | Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices |
| DGtal::CDigitalBoundedShape< TShape > | |
| DGtal::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 |
| DGtal::CDigitalSetArchetype< TDomain > | Aim: The archetype of a container class for storing sets of digital points within some given domain |
| DGtal::CDigitalSurfaceContainer< T > | Aim: |
| DGtal::CDigitalSurfaceTracker< T > | Aim: |
| DGtal::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 |
| DGtal::CDrawableWithBoard2D< T > | |
| DGtal::CDrawableWithDisplay3D< T > | |
| DGtal::CellDirectionIterator< dim, TInteger > | |
| DGtal::KhalimskySpaceND< dim, TInteger >::CellMap< Value > | |
| DGtal::CEuclideanBoundedShape< TShape > | |
| DGtal::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 |
| DGtal::CForwardIteratorArchetype< T > | An archetype of ForwardIterator |
| DGtal::CGlobalGeometricEstimator< T > | Aim: This concept describes an object that can process a range so as to return one estimated quantity for the whole range |
| DGtal::ConceptUtils::CheckFalse< T > | |
| DGtal::ConceptUtils::CheckTag< T > | |
| DGtal::ConceptUtils::CheckTrue< T > | |
| DGtal::ConceptUtils::CheckTrue< TagTrue > | |
| DGtal::ConceptUtils::CheckTrueOrFalse< T > | |
| DGtal::ConceptUtils::CheckUnknown< T > | |
| DGtal::ConceptUtils::CheckUnknown< TagUnknown > | |
| DGtal::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 |
| DGtal::CImplicitFunctionDiff1< T > | Aim: Describes a 1-differentiable function of the form f(x), where x is some real point in the given space, and f(x) is some value |
| DGtal::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 |
| DGtal::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 |
| DGtal::Circulator< TIterator > | Aim: Provides an adapter for STL iterators that can iterate through the underlying data structure as in a loop. The increment (resp. decrement if at least bidirectionnal) operator encapsulates the validity test and the assignement to the first (resp. last) iterator of a given range. For instance, the pre-increment operator does: |
| DGtal::CirculatorType | |
| DGtal::Display3D::clippingPlaneD3D | |
| DGtal::CLocalGeometricEstimator< T > | Aim: This concept describes an object that can process a range so as to return one estimated quantity for each element of the range (or a given subrange) |
| DGtal::CSegmentComputerEstimator< T > | Aim: This concept is a refinement of CLocalGeometricEstimator devoted to the estimation of a geometric quantiy along a segment detected by a segment computer |
| DGtal::Clock | |
| DGtal::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 \} \) |
| DGtal::CNormalVectorEstimator< T > | Aim: Represents the concept of estimator of normal vector along digital surfaces |
| DGtal::COBAGenericNaivePlane< 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 COBANaivePlane, the axis is not specified at initialization of the object. This class uses three instances of COBANaivePlane, one per axis |
| DGtal::COBANaivePlane< 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 |
| DGtal::CombinatorialDSS< TConstIterator, TInteger >::CodeHandler< TIterator, iterator_type > | |
| DGtal::CombinatorialDSS< TConstIterator, TInteger >::CodeHandler< TIterator, bidirectional_iterator_tag > | |
| DGtal::CombinatorialDSS< TConstIterator, TInteger >::CodeHandler< TIterator, random_access_iterator_tag > | |
| DGtal::FreemanChain< TInteger >::CodesRange | Aim: model of CRange that provides services to (circularly)iterate over the letters of the freeman chain |
| DGtal::Color | Structure representing an RGB triple |
| DGtal::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 |
| DGtal::CombinatorialDSS< TConstIterator, TInteger > | Aim: |
| DGtal::CompareLocalEstimators< TFirstEsimator, TSecondEstimator > | Aim: Functor to compare two local geometric estimators |
| DGtal::Viewer3D::compFarthestPolygonFromCamera | |
| DGtal::Viewer3D::compFarthestSurfelFromCamera | |
| DGtal::Viewer3D::compFarthestTriangleFromCamera | |
| DGtal::Viewer3D::compFarthestVoxelFromCamera | |
| DGtal::Composer< TFunctor1, TFunctor2, ReturnType > | Aim: Define a new Functor from the composition of two other functors |
| DGtal::FrechetShortcut< TIterator, TInteger >::Cone | |
| ConfigPointPredicate< Vector > | |
| DGtal::ConnectivityException | |
| DGtal::ConstantConvolutionWeights< TDistance > | Aim: implement a trivial constant convolution kernel which returns 1 to each distance |
| DGtal::ConstantPointPredicate< TPoint, boolCst > | Aim: The predicate that returns always the same value boolCst |
| DGtal::ConstantPointPredicate< TPoint, false > | |
| DGtal::FalsePointPredicate< TPoint > | Aim: The predicate that returns always false |
| DGtal::ConstantPointPredicate< TPoint, true > | |
| DGtal::TruePointPredicate< TPoint > | Aim: The predicate that returns always true |
| DGtal::Labels< L, TWord >::ConstEnumerator | |
| DGtal::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 |
| DGtal::IndexedListWithBlocks< TValue, N, M >::ConstIterator | |
| DGtal::LabelledMap< TData, L, TWord, N, M >::ConstIterator | |
| DGtal::StandardDSLQ0< TFraction >::ConstIterator | |
| DGtal::BreadthFirstVisitor< TGraph, TMarkSet >::ConstIterator< TAccessor > | |
| DGtal::DepthFirstVisitor< TGraph, TMarkSet >::ConstIterator< TAccessor > | |
| DGtal::FreemanChain< TInteger >::ConstIterator | |
| DGtal::ConstIteratorAdapter< TIterator, TLightFunctor, TReturnType > | This class adapts any iterator so that operator* returns another element than the one pointed to by the iterator |
| DGtal::CombinatorialDSS< TConstIterator, TInteger >::ConstPointIterator | |
| DGtal::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) |
| DGtal::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) |
| DGtal::HyperRectDomain< TSpace >::ConstSubRange | Aim: range through some subdomain of all the points in the domain. Defines a constructor taking a domain in parameter plus some additional parameters to specify the subdomain, begin and end methods returning ConstIterator, and rbegin and rend methods returning ConstReverseIterator |
| DGtal::ConstValueFunctor< TValue > | Aim: Define a simple functor that returns a constant value (0 by default) |
| DGtal::ContourHelper | Aim: a helper class to process sequences of points |
| DGtal::CountedPtr< T > | Aim: Smart pointer based on reference counts |
| DGtal::CountedPtr< T >::counter | |
| DGtal::CowPtr< T > | Aim: Copy on write shared pointer |
| DGtal::CPointFunctor< T > | Aim: Defines a functor on points |
| DGtal::CPointFunctor< I > | |
| DGtal::CTrivialConstImage< I > | |
| DGtal::CConstImage< I > | |
| DGtal::CImage< I > | |
| DGtal::CTrivialImage< I > | |
| DGtal::CImage< I > | |
| DGtal::CPointPredicate< T > | Aim: Defines a predicate on a point |
| DGtal::CSeparableMetric< T > | |
| DGtal::CSinglePassOutputRange< T, Value > | Aim: refined concept of single pass range which require that an output iterator exists |
| DGtal::CBidirectionalOutputRange< T, Value > | Aim: refined concept of bidirectional range which require that a reverse output iterator exists |
| DGtal::CBidirectionalOutputRangeFromPoint< T, Value > | Aim: refined concept of single pass range with an routputIterator() method from a point |
| DGtal::CSinglePassOutputRangeFromPoint< T, Value > | Aim: refined concept of single pass range with a outputIterator() method from a point |
| DGtal::CSpace< T > | Aim: Defines the concept describing a digital space, ie a cartesian product of integer lines |
| DGtal::CUndirectedSimpleLocalGraph< T > | Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices |
| DGtal::CAdjacency< T > | |
| DGtal::CDomainAdjacency< T > | Aim: Refines the concept CAdjacency by telling that the adjacency is specific to a given domain of the embedding digital space |
| DGtal::CUndirectedSimpleGraph< T > | Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices |
| DGtal::CUndirectedSimpleLocalGraph< Adj > | |
| DGtal::CAdjacency< Adj > | Aim: The concept CAdjacency defines an elementary adjacency relation between points of a digital space |
| DGtal::CurvatureFromBinomialConvolverFunctor< TBinomialConvolver, TReal > | Aim: This class is a functor for getting the tangent vector of a binomial convolver |
| DGtal::detail::CurvatureFromDCA< isCCW > | |
| DGtal::detail::CurvatureFromDCA< false > | |
| DGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, Functor > | |
| DGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, detail::CurvatureFromDSSLength > | |
| DGtal::CurvatureFromDSSLengthEstimator< DSSComputer > | |
| DGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, detail::CurvatureFromDSSLengthAndWidth > | |
| DGtal::CurvatureFromDSSEstimator< DSSComputer > | |
| DGtal::detail::CurvatureFromDSSLength | |
| DGtal::detail::CurvatureFromDSSLengthAndWidth | |
| DGtal::CWithGradientMap< T > | Aim: Such object provides a gradient map that associates to each argument some real vector |
| DGtal::LabelledMap< TData, L, TWord, N, M >::DataOrBlockPointer | Used in first block to finish it or to point to the next block |
| DGtal::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) |
| DGtal::DefaultFunctor | Aim: Define a simple default functor that just returns its argument |
| DGtal::DefaultImageRange< TImage > | Aim: model of CConstBidirectionalRangeFromPoint and CBidirectionalOutputRangeFromPoint 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) |
| DGtal::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) |
| DGtal::DGtalInventor< TSpace > | Aim: A stream object based on Open Inventor for exporting or displaying DGtal objects |
| DGtal::DigitalSetBoundary< TKSpace, TDigitalSet > | Aim: A model of CDigitalSurfaceContainer which defines the digital surface as the boundary of a given digital set |
| DGtal::DigitalSetBySTLSet< TDomain > | Aim: A container class for storing sets of digital points within some given domain |
| DGtal::DigitalSetBySTLVector< TDomain > | Aim: Realizes the concept CDigitalSet by using the STL container std::vector |
| DGtal::DigitalSetConverter< OutputDigitalSet > | Aim: Utility class to convert between types of sets |
| DGtal::DigitalSetDomain< TDigitalSet > | Aim: Constructs a domain limited to the given digital set |
| DGtal::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 |
| DGtal::DigitalSetInserter< TDigitalSet > | Aim: this output iterator class is designed to allow algorithms to insert points in the digital set. Using the assignment operator, even when dereferenced, causes the digital set to insert a point |
| DGtal::DigitalSetSelector< Domain, Preferences > | Aim: Automatically defines an adequate digital set type according to the hints given by the user |
| DGtal::DigitalSetSelector< Domain, SMALL_DS+LOW_VAR_DS+HIGH_ITER_DS+LOW_BEL_DS > | |
| DGtal::DigitalSetSelector< Domain, SMALL_DS+LOW_VAR_DS+LOW_ITER_DS+LOW_BEL_DS > | |
| DGtal::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 |
| DGtal::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 |
| DGtal::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) |
| DGtal::DigitalSurfaceEmbedderWithNormalVectorEstimatorGradientMap< TDigitalSurfaceEmbedder, TNormalVectorEstimator > | |
| DGtal::DigitalTopology< TForegroundAdjacency, TBackgroundAdjacency > | Aim: Represents a digital topology as a couple of adjacency relations |
| DGtal::Display2DFactory | Factory for Display2D: |
| DGtal::Display3D | Aim: This semi abstract class defines the stream mechanism to display 3d primitive (like PointVector, 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) |
| DGtal::Board3DTo2D | Class for PDF, PNG, PS, EPS, SVG export drawings with Cairo with 3D->2D projection |
| DGtal::Viewer3D | Aim: Display 3D primitive (like PointVector, DigitalSetBySTLSet, Object ...). This class uses the libQGLViewer library (http://www.libqglviewer.com ). It inherits of the class Display3D and permits to display object using a simple stream mechanism of "<<" |
| DGtal::Display3DFactory | Factory for GPL Display3D: |
| DGtal::detail::DistanceFromDCA | |
| DGtal::DistanceFunctorFromPoint< TImage > | |
| DistanceTraits< TImage, TSet, norm > | |
| DistanceTraits< TImage, TSet, 1 > | |
| DGtal::DistanceTransformation< TSpace, TPointPredicate, p, IntegerLong > | Aim: Implementation of the linear in time distance transformation for separable metrics |
| DGtal::DomainAdjacency< TDomain, TAdjacency > | Aim: Given a domain and an adjacency, limits the given adjacency to the specified domain for all adjacency and neighborhood computations |
| DGtal::deprecated::DomainMetricAdjacency< Domain, maxNorm1, dimension > | Aim: Describes digital adjacencies in a digital domain that are defined with the 1-norm and the infinity-norm |
| DGtal::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 |
| DGtal::DrawableWithBoard2D | |
| DGtal::CustomColors | Custom style class redefining the pen color and the fill color. You may use Board2D::Color::None for transparent color |
| DGtal::CustomFillColor | Custom style class redefining the fill color. You may use Board2D::Color::None for transparent color |
| DGtal::CustomPen | Custom style class redefining the pen attributes. You may use Board2D::Color::None for transparent color |
| DGtal::CustomPenColor | Custom style class redefining the pen color. You may use Board2D::Color::None for transparent color |
| DGtal::DefaultDrawStyle_DigitalSetBySTLSet | |
| DGtal::DefaultDrawStyle_DigitalSetBySTLVector | |
| DGtal::DefaultDrawStyle_FP | |
| DGtal::DefaultDrawStyle_FrechetShortcut | |
| DGtal::DefaultDrawStyle_GeometricalDCA | |
| DGtal::DefaultDrawStyle_GeometricalDSS | |
| DGtal::DefaultDrawStyle_ImageContainerByHashTree | |
| DGtal::DefaultDrawStyle_ImageContainerBySTLVector | |
| DGtal::DefaultDrawStyle_KhalimskyCell | |
| DGtal::DefaultDrawStyle_Object | |
| DGtal::DefaultDrawStyle_SignedKhalimskyCell | |
| DGtal::DefaultDrawStyleBB_ArithmeticalDSS | |
| DGtal::DefaultDrawStyleCircular_AngleLinearMinimizer | |
| DGtal::DefaultDrawStyleFilled_LatticePolytope2D | |
| DGtal::DefaultDrawStyleGrid_FreemanChain | |
| DGtal::DefaultDrawStyleGrid_HyperRectDomain | |
| DGtal::DefaultDrawStyleGrid_PointVector | |
| DGtal::DefaultDrawStyleInterGrid_FreemanChain | |
| DGtal::DefaultDrawStylePaving_HyperRectDomain | |
| DGtal::DefaultDrawStylePaving_PointVector | |
| DGtal::DefaultDrawStylePoints_ArithmeticalDSS | |
| DGtal::DefaultDrawStyleTransparent_LatticePolytope2D | |
| MyDomainStyleCustomRed | |
| MyDrawStyleCustomBlue | |
| MyDrawStyleCustomColor | |
| MyDrawStyleCustomFillColor | |
| MyDrawStyleCustomGreen | |
| MyDrawStyleCustomGreen | |
| MyDrawStyleCustomRed | |
| MyDrawStyleCustomRed | |
| MyObjectStyleCustom | |
| MyObjectStyleCustomRed | |
| MyStyleCustom | |
| MyStyleCustomRed | |
| DGtal::DrawableWithDisplay3D | |
| DGtal::DrawWithBoardModifier | |
| DGtal::CustomStyle | |
| DGtal::SetMode | Modifier class in a Board2D stream. Useful to choose your own mode for a given class. Realizes the concept CDrawableWithBoard2D |
| DGtal::DrawWithDisplay3DModifier | Base class specifying the methods for classes which intend to modify a Viewer3D stream |
| DGtal::CameraDirection | CameraDirection class to set camera direction |
| DGtal::CameraPosition | CameraPosition class to set camera position |
| DGtal::CameraUpVector | CameraUpVector class to set camera up-vector |
| DGtal::CameraZNearFar | CameraZNearFar class to set near and far distance |
| DGtal::ClippingPlane | Class for adding a Clipping plane through the Viewer3D stream. Realizes the concept CDrawableWithViewer3D |
| DGtal::CustomColors3D | Custom style class redefining the fill color and the gl_LINE/gl_POINT color. You can use DGtal::Color with alpha transparency value but you nedd to take into account the z-buffer during the Open-GL based rendering |
| DGtal::CustomStyle3D | Modifier class in a Display3D stream. Useful to choose your own style for a given class. Realizes the concept CDrawableWithDisplay3D |
| DGtal::SetMode3D | Modifier class in a Display3D stream. Useful to choose your own mode for a given class. Realizes the concept CDrawableWithDisplay3D |
| DGtal::TransformedKSSurfel | Class to modify the position and scale to construct better illustration mode |
| DGtal::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 |
| Dummy1< T > | |
| Dummy2< T > | |
| DummyBigObject | |
| DGtal::DummyObject< T > | |
| DGtal::DynamicBidirectionalSegmentComputer | |
| DGtal::DynamicSegmentComputer | |
| DynArrayLXY< Value > | |
| DynArrayXYOfLabelledMap< Value, L, TWord, N, M > | |
| DynArrayXYOfMap< Value > | |
| DGtal::DigitalSurface< TDigitalSurfaceContainer >::Edge | |
| DGtal::Object< TDigitalTopology, TDigitalSet >::Edge | |
| DGtal::EqualPointPredicate< TPoint > | Aim: The predicate returns true when the point given as argument equals the reference point given at construction |
| DGtal::MPolynomialEvaluatorImpl< 1, TRing, TOwner, TAlloc, TX >::EvalFun | |
| DGtal::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX >::EvalFun< XX, Fun > | |
| DGtal::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX >::EvalFun2 | |
| DGtal::Expander< TObject > | Aim: This class is useful to visit an object by adjacencies, layer by layer |
| DGtal::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 |
| DGtal::DigitalSurface< TDigitalSurfaceContainer >::Face | |
| DGtal::FalseBoolFct0 | |
| FindAndGetValue< I, S, D, V > | |
| FindAndGetValue< ImageContainerBySTLMap< D, V >, DigitalSetFromMap< ImageContainerBySTLMap< D, V > >, D, V > | |
| DGtal::IndexedListWithBlocks< TValue, N, M >::FirstBlock | |
| DGtal::FMM< TImage, TSet, TPointPredicate, TPointFunctor > | Aim: Fast Marching Method (FMM) for nd distance transforms |
| DGtal::ForwardCategory | |
| DGtal::BidirectionalCategory | |
| DGtal::RandomAccessCategory | |
| DGtal::ForwardSegmentComputer | |
| DGtal::FP< TIterator, TInteger, connectivity > | Aim: Computes the faithful polygon (FP) of a range of 4/8-connected 2D Points |
| DGtal::FPLengthEstimator< TConstIterator > | Aim: a model of CGlobalCurveEstimator that computes the length of a digital curve using its FP (faithful polygon) |
| DGtal::LighterSternBrocot< TInteger, TQuotient, TMap >::Fraction | This fraction is a model of CPositiveIrreducibleFraction |
| DGtal::LightSternBrocot< TInteger, TQuotient, TMap >::Fraction | This fraction is a model of CPositiveIrreducibleFraction |
| DGtal::SternBrocot< TInteger, TQuotient >::Fraction | This fraction is a model of CPositiveIrreducibleFraction |
| DGtal::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 |
| DGtal::FreemanChain< TInteger > | |
| DGtal::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 |
| DGtal::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) |
| DGtal::GaussianConvolutionWeights< TDistance > | Aim: implement a Gaussian centered convolution kernel |
| DGtal::GeometricalDCA< 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 |
| DGtal::GeometricalDSS< 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 |
| DGtal::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 |
| DGtal::GrayscaleColorMap< PValue > | Aim: This class template may be used to (linearly) convert scalar values in a given range into gray levels |
| DGtal::deprecated::GreedyDecomposition< TSegment > | Aim: Computes the greedy decomposition of a sequence into segments (the last element of a given segment is the first one one of the next segment) |
| DGtal::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 |
| DGtal::BasicColorToScalarFunctors::GreenChannel | |
| DGtal::GridCurve< TKSpace > | Aim: describes, in a cellular space of dimension n, a closed of open sequence of signed d-cells (or d-scells), d being either equal to 1 or (n-1) |
| DGtal::detail::HasNestedType< IC > | Aim: Checks whether type has a nested type called 'Type' or not. NB: from en.wikipedia.org/wiki/Substitution_failure_is_not_an_error |
| DGtal::LongvolReader< TImageContainer >::HeaderField | |
| DGtal::VolReader< TImageContainer >::HeaderField | |
| DGtal::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 |
| DGtal::HyperRectDomain< TSpace > | Aim: Parallelepidec region of a digital space, model of a 'CDomain' |
| DGtal::HyperRectDomain_Iterator< TPoint > | |
| DGtal::HyperRectDomain_subIterator< TPoint > | |
| DGtal::IdentityBoolFct1 | |
| DGtal::Image< TImageContainer > | Aim: implements association bewteen points lying in a digital domain and values |
| DGtal::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 |
| DGtal::ImageContainerByHashTree< TDomain, TValue, THashKey > | Model of CImageContainer implementing the association key<->Value using a hash tree. This class provides a built-in iterator |
| DGtal::experimental::ImageContainerByITKImage< TDomain, TValue > | Aim: implements a model of CImageContainer using a ITK Image |
| DGtal::ImageContainerBySTLMap< TDomain, TValue > | |
| DGtal::ImageContainerBySTLVector< TDomain, TValue > | |
| DGtal::ImageFromSet< TImage > | Aim: Define utilities to convert a digital set into an image |
| DGtal::ImageLinearCellEmbedder< TKSpace, TImage, TEmbedder > | Aim: a cellular embedder for images. (default constructible, copy constructible, assignable). Model of CCellEmbedder |
| DGtal::ImageSelector< Domain, Value, Preferences > | Aim: Automatically defines an adequate image type according to the hints given by the user |
| DGtal::ImageSelector< Domain, Value, LOW_ITER_I+LOW_BEL_I > | |
| DGtal::ImplicitBall< TSpace > | Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball in nD. |
| DGtal::ImplicitDigitalEllipse3< TPoint3 > | |
| ImplicitDigitalEllipse3< TPoint3 > | |
| DGtal::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 |
| DGtal::ImplicitFunctionDiff1LinearCellEmbedder< TKSpace, TImplicitFunctionDiff1, TEmbedder > | Aim: a cellular embedder for implicit functions, (default constructible, copy constructible, assignable). Model of CCellEmbedder and CWithGradientMap |
| DGtal::ImplicitFunctionDiff1LinearCellEmbedderGradientMap< TKSpace, TImplicitFunctionDiff1, TEmbedder > | |
| DGtal::ImplicitFunctionLinearCellEmbedder< TKSpace, TImplicitFunction, TEmbedder > | Aim: a cellular embedder for implicit functions, (default constructible, copy constructible, assignable). Model of CCellEmbedder |
| DGtal::ImplicitHyperCube< TSpace > | Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create an hypercube in nD. |
| DGtal::ImplicitNorm1Ball< TSpace > | Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball for the L_1 norm in nD |
| DGtal::ImplicitPolynomial3Shape< TSpace > | Aim: model of CEuclideanOrientedShape concepts to create a shape from a polynomial |
| DGtal::ImplicitRoundedHyperCube< TSpace > | Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a rounded hypercube in nD. |
| DGtal::ImpliesBoolFct2 | |
| DGtal::IndexedListWithBlocks< TValue, N, M > | Aim: Represents a mixed list/array structure which is useful in some context. It is essentially a list of blocks |
| DGtal::InfiniteNumberException | |
| DGtal::InputException | |
| DGtal::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 |
| InsertAndAlwaysSetValue< I, S, D, V > | |
| InsertAndAlwaysSetValue< ImageContainerBySTLMap< D, V >, DigitalSetFromMap< ImageContainerBySTLMap< D, V > >, D, V > | |
| InsertAndSetValue< I, S, D, V > | |
| InsertAndSetValue< ImageContainerBySTLMap< D, V >, DigitalSetFromMap< ImageContainerBySTLMap< D, V > >, D, V > | |
| DGtal::IntegerComputer< TInteger > | Aim: This class gathers several types and methods to make computation with integers |
| DGtal::IntervalForegroundPredicate< Image > | Aim: Define a simple Foreground predicate thresholding image values between two constant values |
| DGtal::IntervalThresholder< T > | Aim: A small functor with an operator () that compares one value to an interval |
| DGtal::IOException | |
| DGtal::detail::IsCirculator< IC, flagHasNestedType > | Aim: Checks whether type is a circular or a classical iterator. NB: from en.wikipedia.org/wiki/Substitution_failure_is_not_an_error |
| DGtal::IsCirculator< IC > | Aim: Checks whether type is a circular or a classical iterator |
| DGtal::detail::IsCirculator< IC, true > | |
| DGtal::IsLowerPointPredicate< TPoint > | Aim: The predicate returns true when the point is below (or equal) the given upper bound |
| DGtal::IsUpperPointPredicate< TPoint > | Aim: The predicate returns true when the point is above (or equal) the given lower bound |
| DGtal::IsWithinPointPredicate< TPoint > | Aim: The predicate returns true when the point is within the given bounds |
| DGtal::IndexedListWithBlocks< TValue, N, M >::Iterator | |
| DGtal::ImageContainerByHashTree< TDomain, TValue, THashKey >::Iterator | |
| DGtal::IteratorAdapter< TIterator, TFunctor, TReturnType > | This class adapts any lvalue iterator so that operator* returns a member on the element pointed to by the iterator, instead the element itself |
| DGtal::IteratorCirculatorTagTraits< C > | Aim: Provides the category of the iterator (resp. circulator) {ForwardCategory,BidirectionalCategory,RandomAccessCategory} |
| DGtal::IteratorCirculatorTagTraits< boost::bidirectional_traversal_tag > | |
| DGtal::IteratorCirculatorTagTraits< boost::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::bidirectional_traversal_tag > > | |
| DGtal::IteratorCirculatorTagTraits< boost::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::forward_traversal_tag > > | |
| DGtal::IteratorCirculatorTagTraits< boost::detail::iterator_category_with_traversal< std::input_iterator_tag, boost::random_access_traversal_tag > > | |
| DGtal::IteratorCirculatorTagTraits< boost::forward_traversal_tag > | |
| DGtal::IteratorCirculatorTagTraits< boost::random_access_traversal_tag > | |
| DGtal::IteratorCirculatorTagTraits< std::bidirectional_iterator_tag > | |
| DGtal::IteratorCirculatorTagTraits< std::forward_iterator_tag > | |
| DGtal::IteratorCirculatorTagTraits< std::random_access_iterator_tag > | |
| DGtal::IteratorCirculatorTraits< IC > | Aim: Provides nested types for both iterators and circulators: Type, Category, Value, Difference, Pointer and Reference |
| DGtal::IteratorCirculatorTraits< T * > | |
| DGtal::IteratorCirculatorTraits< T const * > | |
| DGtal::IteratorCirculatorType< IC > | Aim: Provides the type of as a nested type |
| DGtal::detail::IteratorCirculatorTypeImpl< b > | Aim: Defines the Iterator or Circulator type as a nested type according to the value of b |
| DGtal::detail::IteratorCirculatorTypeImpl< true > | |
| DGtal::IteratorType | |
| DGtal::IVector< T, TAlloc, usePointers > | |
| DGtal::IVector< T, TAlloc, true > | |
| DGtal::IVViewer | Aim: A facade to represent an inventor window for 3D objects. May be a SoXt or a SoQt examiner viewer. NB: backported from ImaGeneUtils library |
| DGtal::LabelledMap< TData, L, TWord, N, M >::KeyCompare | Key comparator class. Always natural ordering |
| DGtal::KhalimskyCell< dim, TInteger > | Represents an (unsigned) cell in a cellular grid space by its Khalimsky coordinates |
| DGtal::KhalimskySpaceND< dim, TInteger > | Aim: This class is a model of CCellularGridSpaceND. It represents the cubical grid as a cell complex, whose cells are defined as an array of integers. The topology of the cells is defined by the parity of the coordinates (even: closed, odd: open) |
| DGtal::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) |
| DGtal::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) |
| DGtal::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) |
| DGtal::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 |
| DGtal::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 |
| DGtal::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 |
| DGtal::detail::LabelledMapMemFunctor | |
| DGtal::Labels< L, TWord > | Aim: Stores a set of labels in {O..L-1} as a sequence of bits |
| DGtal::Lattice< TSpace > | Aim: Represents an n-dimensional integer lattice in an m-dimensional real vector space |
| DGtal::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 |
| LessThanOnFace< Vector > | |
| DGtal::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 |
| DGtal::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 |
| DGtal::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 |
| DGtal::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 |
| DGtal::LinearAlgebra< Space > | Aim: A utility class that contains methods to perform integral linear algebra |
| DGtal::Display3D::lineD3D | |
| DGtal::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) |
| DGtal::LocalConvolutionNormalVectorEstimator< TDigitalSurface, TKernelFunctor > | Aim: Computes the normal vector at a surface element by convolution of elementary normal vector to adjacent surfel |
| DGtal::LOG2< X > | |
| DGtal::LOG2< 1 > | |
| DGtal::LOG2< 2 > | |
| LogScaleFunctor< Scalar > | [LogScaleFunctor] |
| DGtal::LongvolReader< TImageContainer > | Aim: implements methods to read a "Longvol" file format (with DGtal::uint64_t value type) |
| DGtal::LongvolWriter< TImage, TFunctor > | Aim: Export a 3D Image using the Longvol formats (volumetric image with DGtal::uint64_t value type) |
| DGtal::MagickReader< TImageContainer > | Aim: implements methods to read a 2D image using the ImageMagick library |
| DGtal::MaxFunctor< T > | |
| DGtal::deprecated::MaximalSegments< TSegment > | Aim: Computes the set of maximal segments of a sequence. Maximal segments are segments that cannot be included in other segments. This class is a model of CDecomposition |
| DGtal::BasicColorToScalarFunctors::MeanChannels | |
| DGtal::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,.. |
| DGtal::MeasureOfStraightLines | The aim of this class is to compute the measure in the Lebesgues sense of the set of straight lines associated to domains defined as polygons in the (a,b)-parameter space. This parameter space maps the line $ax-y+b=0$ to the point $(a,b)$ |
| DGtal::MemoryException | |
| DGtal::MeshFromPoints< TPoint > | Aim: This class is defined to represent a surface mesh through a set a vertex and a set of faces represented by its vertex index. By default it does not memorize the color Face and all faces will have the white color |
| DGtal::MeshReader< TPoint > | Aim: Defined to import OFF and OFS surface mesh. It allows to import a MeshFromPoints object and takes into accouts the optional color faces |
| DGtal::MeshWriter< TPoint > | Aim: Export a Mesh (MeshFromPoints object) in different format as OFF and OBJ) |
| DGtal::MetricAdjacency< TSpace, maxNorm1, dimension > | Aim: Describes digital adjacencies in digital spaces that are defined with the 1-norm and the infinity-norm |
| DGtal::MetricAdjacency< TSpace, 1, 2 > | |
| DGtal::MetricAdjacency< TSpace, 1, 3 > | |
| DGtal::MetricAdjacency< TSpace, 2, 2 > | |
| DGtal::MetricAdjacency< TSpace, 2, 3 > | |
| DGtal::MetricAdjacency< TSpace, 3, 3 > | |
| DGtal::MinFunctor< T > | |
| DGtal::MinusFunctor< T > | |
| DGtal::MLPLengthEstimator< TConstIterator > | Aim: a model of CGlobalCurveEstimator that computes the length of a digital curve using its MLP (given by the FP) |
| DGtal::ModuloComputer< TInteger > | Implements basic functions on modular arithmetic |
| DGtal::Morton< THashKey, TPoint > | Aim: Implements the binary Morton code construction in nD |
| DGtal::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 |
| DGtal::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 |
| DGtal::MPolynomial< 0, TRing, TAlloc > | Aim: Specialization of MPolynomial for degree 0 |
| DGtal::MPolynomialDerivativeComputer< N, n, Ring, Alloc > | |
| DGtal::MPolynomialDerivativeComputer< 0, 0, Ring, Alloc > | |
| DGtal::MPolynomialDerivativeComputer< 0, n, Ring, Alloc > | |
| DGtal::MPolynomialDerivativeComputer< N, 0, Ring, Alloc > | |
| DGtal::MPolynomialEvaluator< n, TRing, TAlloc, TX > | |
| DGtal::MPolynomialEvaluator< 1, TRing, TAlloc, TX > | |
| DGtal::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX > | |
| DGtal::MPolynomialEvaluatorImpl< 1, TRing, TOwner, TAlloc, TX > | |
| myreverse_iterator< _Iterator > | |
| MyTransValueFunctor< TValue > | Aim: Define a simple functor that returns a 'trans' value |
| DGtal::Negate< T > | |
| DGtal::Negate< TagFalse > | |
| DGtal::Negate< TagTrue > | |
| DGtal::LightSternBrocot< TInteger, TQuotient, TMap >::Node | |
| DGtal::LighterSternBrocot< TInteger, TQuotient, TMap >::Node | |
| DGtal::SternBrocot< TInteger, TQuotient >::Node | |
| DGtal::ImageContainerByHashTree< TDomain, TValue, THashKey >::Node | |
| DGtal::BreadthFirstVisitor< TGraph, TMarkSet >::NodeAccessor | |
| DGtal::DepthFirstVisitor< TGraph, TMarkSet >::NodeAccessor | |
| Norm1< P > | |
| DGtal::detail::NormalizedTangentVectorFromDSS | |
| DGtal::NormalVectorEstimatorLinearCellEmbedder< TDigitalSurface, TNormalVectorEstimator, TEmbedder > | Aim: model of cellular embedder for normal vector estimators on digital surface, (default constructible, copy constructible, assignable) |
| DGtal::detail::NormalVectorFromDCA | |
| DGtal::NotBoolFct1 | |
| DGtal::NotPointPredicate< TPointPredicate > | Aim: The predicate returns true when the point predicate given at construction return false. Thus inverse a predicate: NOT operator |
| DGtal::NumberTraits< T > | Aim: The traits class for all models of Cinteger |
| DGtal::NumberTraits< double > | |
| DGtal::NumberTraits< float > | |
| DGtal::NumberTraits< int16_t > | |
| DGtal::NumberTraits< int32_t > | |
| DGtal::NumberTraits< int64_t > | |
| DGtal::NumberTraits< int8_t > | |
| DGtal::NumberTraits< long double > | |
| DGtal::NumberTraits< uint16_t > | |
| DGtal::NumberTraits< uint32_t > | |
| DGtal::NumberTraits< uint64_t > | |
| DGtal::NumberTraits< uint8_t > | |
| DGtal::Object< TDigitalTopology, TDigitalSet > | Aim: An object (or digital object) represents a set in some digital space associated with a digital topology |
| DGtal::FrechetShortcut< TIterator, TInteger >::Backpath::occulter_attributes | |
| DGtal::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 |
| DGtal::OpInSTLContainers< Container, std::reverse_iterator< typename Container::iterator > > | |
| DGtal::OrBoolFct2 | |
| DGtal::OrderedAlphabet | Aim: Describes an alphabet over an interval of (ascii) letters, where the lexicographic order can be changed (shifted, reversed, ...). Useful for the arithmetic minimum length polygon (AMLP) |
| DGtal::OutputIteratorAdapter< TIterator, TFunctor, TInputValue > | Aim: Adapts an output iterator i with a unary functor f, both given at construction, so that the element pointed to by i is updated with a given value through f |
| DGtal::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 |
| DGtal::Pair1st< ReturnType > | Aim: Define a simple functor that returns the first member of a pair |
| DGtal::Pair1stMutator< ReturnType > | Aim: Define a simple unary functor that returns a reference on the first member of a pair in order to update it |
| DGtal::Pair2nd< ReturnType > | Aim: Define a simple functor that returns the second member of a pair |
| DGtal::Pair2ndMutator< ReturnType > | Aim: Define a simple unary functor that returns a reference on the first member of a pair in order to update it |
| DGtal::ParametricShapeArcLengthFunctor< TParametricShape > | Aim: implements a functor that estimates the arc length of a paramtric curve |
| DGtal::ParametricShapeCurvatureFunctor< TParametricShape > | Aim: implements a functor that computes the curvature at a given point of a parametric shape |
| DGtal::ParametricShapeTangentFunctor< TParametricShape > | Aim: implements a functor that computes the tangent vector at a given point of a parametric shape |
| DGtal::Pattern< TFraction > | Aim: This class represents a pattern, i.e. the path between two consecutive upper leaning points on a digital straight line |
| DGtal::PGMWriter< TImage, TFunctor > | Aim: Export a 2D and a 3D Image using the Netpbm PGM formats (ASCII mode) |
| DGtal::PNMReader< TImageContainer > | Aim: Import a 2D or 3D using the Netpbm formats (ASCII mode) |
| DGtal::Point2ShapePredicate< TSurface, isUpward, isClosed > | Aim: Predicate returning 'true' iff a given point is in the 'interior' of a given shape, 'false' otherwise |
| DGtal::Point2ShapePredicateComparator< T, b1, b2 > | Aim: A small struct with an operator that compares two values according to two bool template parameters |
| DGtal::Point2ShapePredicateComparator< T, false, false > | Aim: A small struct with an operator that compares two values (<) |
| DGtal::Point2ShapePredicateComparator< T, false, true > | Aim: A small struct with an operator that compares two values (<=) |
| DGtal::Point2ShapePredicateComparator< T, true, false > | Aim: A small struct with an operator that compares two values (>) |
| DGtal::Point2ShapePredicateComparator< T, true, true > | Aim: A small struct with an operator that compares two values (>=) |
| Point3D | |
| DGtal::deprecated::Point3dTo2dXY< Coordinate > | Aim: transforms a 3d point into a 2d point due to a projection on the xy-plane |
| DGtal::deprecated::Point3dTo2dXZ< Coordinate > | Aim: transforms a 3d point into a 2d point due to a projection on the xz-plane |
| DGtal::deprecated::Point3dTo2dYZ< Coordinate > | Aim: transforms a 3d point into a 2d point due to a projection on the yz-plane |
| DGtal::Display3D::pointD3D | |
| DGtal::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 |
| DGtal::PointListReader< TPoint > | Aim: Implements method to read a set of points represented in each line of a file |
| DGtal::details::PointValueCompare< T > | Aim: Small binary predicate to order candidates points according to their (absolute) distance value |
| DGtal::PointVector< dim, TEuclideanRing > | Aim: Implements basic operations that will be used in Point and Vector classes |
| DGtal::Display3D::polygonD3D | |
| DGtal::detail::PosDepScaleDepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| DGtal::detail::PosDepScaleDepSCEstimator< DCAComputer, detail::DistanceFromDCA > | |
| DGtal::DistanceFromDCAEstimator< DCAComputer > | |
| DGtal::detail::PosDepScaleIndepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| DGtal::detail::PosDepScaleIndepSCEstimator< DCAComputer, detail::NormalVectorFromDCA > | |
| DGtal::NormalFromDCAEstimator< DCAComputer > | |
| DGtal::detail::PosDepScaleIndepSCEstimator< DCAComputer, detail::TangentVectorFromDCA > | |
| DGtal::TangentFromDCAEstimator< DCAComputer > | |
| DGtal::detail::PosIndepScaleDepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| DGtal::detail::PosIndepScaleDepSCEstimator< DCAComputer, detail::CurvatureFromDCA< isCCW > > | |
| DGtal::CurvatureFromDCAEstimator< DCAComputer, isCCW > | |
| DGtal::detail::PosIndepScaleIndepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| DGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::NormalizedTangentVectorFromDSS > | |
| DGtal::TangentFromDSSEstimator< DSSComputer > | |
| DGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::TangentAngleFromDSS > | |
| DGtal::TangentAngleFromDSSEstimator< DSSComputer > | |
| DGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::TangentVectorFromDSS< DSSComputer > > | |
| DGtal::TangentVectorFromDSSEstimator< DSSComputer > | |
| DGtal::POW< X, exponent > | |
| DGtal::POW< X, 1 > | |
| DGtal::PPMWriter< TImage, TFunctor > | Aim: Export a 2D and a 3D Image using the Netpbm PPM formats (ASCII mode) |
| DGtal::PredicateCombiner< TPredicate1, TPredicate2, TBinaryFunctor > | Aim: The predicate returns true when the given binary functor returns true for the two Predicates given at construction |
| DGtal::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) |
| DGtal::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 |
| DGtal::promote_trait< A, B > | |
| DGtal::promote_trait< int32_t, int64_t > | |
| DGtal::Display3D::quadD3D | |
| DGtal::RandomColorMap | Aim: access to random color from a gradientColorMap |
| DGtal::RawReader< TImageContainer > | Aim: implements methods to read a "Vol" file format |
| DGtal::RawWriter< TImage, TFunctor > | Aim: Raw binary export of an Image |
| DGtal::StdMapRebinder::Rebinder< Key, Value > | |
| DGtal::BasicColorToScalarFunctors::RedChannel | |
| DGtal::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) |
| DGtal::ReverseDistanceTransformation< Image, p, IntegerShort > | Aim: Implementation of the linear in time reverse distance transformation |
| DGtal::ReverseIterator< Iterator > | This class adapts any bidirectional iterator so that operator++ calls operator– and vice versa |
| DGtal::ConceptUtils::SameType< T1, T2 > | |
| DGtal::ConceptUtils::SameType< T, T > | |
| DGtal::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) |
| DGtal::KhalimskySpaceND< dim, TInteger >::SCellMap< Value > | |
| DGtal::SCellToArrow< KSpace > | Aim: transforms a signed cell into an arrow, ie. a pair point-vector |
| DGtal::deprecated::SCellToArrow< KSpace > | Aim: transforms a signed cell into an arrow, ie. a pair point-vector |
| DGtal::SCellToCode< KSpace > | Aim: transforms a 2d signed cell, basically a linel, into a code (0,1,2 or 3), |
| DGtal::deprecated::SCellToCode< KSpace > | Aim: transforms a 2d scell, basically a linel, into a code (0,1,2 or 3), |
| DGtal::deprecated::SCellToIncidentPoints< KSpace > | Aim: transforms a linel into a pair of points, which are the centers of the two incident pixels |
| DGtal::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 |
| DGtal::deprecated::SCellToInnerPoint< KSpace > | Aim: transforms a signed cell into a point, basically a linel into the indirect incident pixel center |
| DGtal::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 |
| DGtal::SCellToMidPoint< KSpace > | Aim: transforms a scell into a real point (the coordinates are divided by 2) |
| DGtal::deprecated::SCellToMidPoint< KSpace > | Aim: transforms a scell into a real point (the coordinates are divided by 2) |
| DGtal::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 |
| DGtal::deprecated::SCellToOuterPoint< KSpace > | Aim: transforms a sigend cell into a point, basically a linel into the direct incident pixel center |
| DGtal::deprecated::SCellToPoint< KSpace > | Aim: transforms a scell into a point |
| DGtal::SCellToPoint< KSpace > | Aim: transforms a scell into a point |
| DGtal::SaturatedSegmentation< TSegmentComputer >::SegmentComputerIterator | Aim: Specific iterator to visit all the maximal segments of a saturated segmentation |
| DGtal::GreedySegmentation< TSegmentComputer >::SegmentComputerIterator | Aim: Specific iterator to visit all the segments of a greedy segmentation |
| DGtal::SegmentComputerTraits< SC > | Aim: Provides the category of the segment computer {ForwardSegmentComputer,BidirectionalSegmentComputer, DynamicSegmentComputer, DynamicBidirectionalSegmentComputer} |
| SegmentedPlane | |
| DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator | |
| DGtal::deprecated::GreedyDecomposition< TSegment >::SegmentIterator | |
| DGtal::SeparableMetricHelper< TPoint, TInternalValue, tp > | Aim: Implements basic functions associated to metrics used by separable volumetric algorithms |
| DGtal::SeparableMetricHelper< TPoint, TInternalValue, 0 > | |
| DGtal::SeparableMetricHelper< TPoint, TInternalValue, 1 > | |
| DGtal::SeparableMetricHelper< TPoint, TInternalValue, 2 > | |
| DGtal::SetFromImage< TSet > | Aim: Define utilities to convert a digital set into an image |
| DGtal::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 |
| DGtal::SetPredicate< TDigitalSet > | Aim: The predicate returning true iff the point is in the domain given at construction |
| DGtal::SetValueIterator< TImage, TIteratorOnPts > | Aim: implements an output iterator, which is able to write values in an underlying image, by calling its setValue method |
| LibBoard::Shape [external] | Abstract structure for a 2D shape |
| LibBoard::ShapeList [external] | A group of shapes |
| LibBoard::Board [external] | Class for EPS, FIG or SVG drawings |
| DGtal::Board2D | Aim: This class specializes a 'Board' class so as to display DGtal objects more naturally (with <<). The user has simply to declare a Board2D object and uses stream operators to display most digital objects. Furthermore, one can use this class to modify the current style for drawing |
| LibBoard::Board [external] | Class for EPS, FIG or SVG drawings |
| LibBoard::ShapeList [external] | A group of shapes |
| DGtal::Shapes< TDomain > | Aim: A utility class for constructing different shapes (balls, diamonds, and others) |
| DGtal::Signal< TValue > | Aim: Represents a discrete signal, periodic or not. The signal can be passed by value since it is only cloned when modified |
| DGtal::SignalData< TValue > | |
| DGtal::SignedKhalimskyCell< dim, TInteger > | Represents a signed cell in a cellular grid space by its Khalimsky coordinates and a boolean value |
| DGtal::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) |
| DGtal::SimpleMatrix< TComponent, TM, TN > | Aim: implements basic MxN Matrix services (M,N>=1) |
| DGtal::SimpleMatrixSpecializations< TMatrix, TM, TN > | Aim: Implement internal matrix services for specialized matrix size |
| DGtal::SimpleMatrixSpecializations< TMatrix, 1, 1 > | Aim: |
| DGtal::SimpleMatrixSpecializations< TMatrix, 2, 2 > | Aim: |
| DGtal::SimpleMatrixSpecializations< TMatrix, 3, 3 > | Aim: |
| DGtal::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) |
| DGtal::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) |
| DGtal::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 |
| DGtal::SpaceND< dim, TInteger > | Aim: SpaceND is a utility class that defines the fundamental structure of a Digital Space in ND |
| DGtal::ImageContainerBySTLVector< TDomain, TValue >::SpanIterator | |
| DGtal::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 |
| DGtal::SphericalAccumulator< TVector > | Aim: implements an accumulator (as histograms for 1D scalars) adapted to spherical point samples |
| DGtal::StandardDSLQ0< TFraction > | |
| DGtal::StarShaped2D< TSpace > | |
| DGtal::AccFlower2D< TSpace > | Aim: Model of the concept StarShaped represents any accelerated flower in the plane |
| DGtal::Ball2D< TSpace > | Aim: Model of the concept StarShaped represents any circle in the plane |
| DGtal::Ellipse2D< TSpace > | Aim: Model of the concept StarShaped represents any ellipse in the plane |
| DGtal::Flower2D< TSpace > | Aim: Model of the concept StarShaped represents any flower with k-petals in the plane |
| DGtal::NGon2D< TSpace > | Aim: Model of the concept StarShaped represents any regular k-gon in the plane |
| DGtal::StarShaped3D< TSpace > | |
| DGtal::Ball3D< TSpace > | Aim: Model of the concept StarShaped3D represents any Sphere in the space |
| DGtal::COBANaivePlane< TSpace, TInternalInteger >::State | |
| DGtal::UmbrellaComputer< TDigitalSurfaceTracker >::State | |
| DGtal::Statistic< RealNumberType > | 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 |
| DGtal::StdMapRebinder | |
| DGtal::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 |
| DGtal::STLMapToVertexMapAdapter< TMap > | Aim: This class adapts any map of the STL to match with the CVertexMap concept |
| DGtal::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 |
| DGtal::Style2DFactory | |
| DGtal::SpaceND< dim, TInteger >::Subcospace< codimension > | Define the type of a sub co-Space |
| DGtal::SpaceND< dim, TInteger >::Subspace< subdimension > | Define the type of a subspace |
| DGtal::Surfaces< TKSpace > | Aim: A utility class for constructing surfaces (i.e. set of (n-1)-cells) |
| DGtal::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 |
| DGtal::KhalimskySpaceND< dim, TInteger >::SurfelMap< Value > | |
| DGtal::DigitalSurface< TDigitalSurfaceContainer >::SurfelMap< Value > | |
| DGtal::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) |
| DGtal::SurfelSetPredicate< TSurfelSet, TSurfel > | Aim: The predicate returning true iff the point is in the domain given at construction |
| DGtal::TagFalse | |
| DGtal::TagTrue | |
| DGtal::TagUnknown | |
| DGtal::detail::TangentAngleFromDSS | |
| DGtal::TangentFromBinomialConvolverFunctor< TBinomialConvolver, TRealPoint > | Aim: This class is a functor for getting the tangent vector of a binomial convolver |
| DGtal::detail::TangentVectorFromDCA | |
| DGtal::detail::TangentVectorFromDSS< DSS > | |
| DGtal::detail::TangentVectorFromDSS< DSSComputer > | |
| DGtal::Thresholder< T, isLower, isEqual > | Aim: A small functor with an operator () that compares one value to a threshold value according to two bool template parameters |
| DGtal::Thresholder< T, false, false > | |
| DGtal::Thresholder< T, false, true > | |
| DGtal::Thresholder< T, true, false > | |
| DGtal::Thresholder< T, true, true > | |
| DGtal::ArithmeticalDSS< TIterator, TInteger, connectivity >::Tools< TInt, c > | |
| DGtal::FrechetShortcut< TIterator, TInteger >::Tools | |
| DGtal::ArithmeticalDSS< TIterator, TInteger, connectivity >::Tools< TInt, 4 > | |
| DGtal::Trace | Implementation of basic methods to trace out messages with indentation levels |
| DGtal::TraceWriter | Virtual Class to implement trace writers |
| DGtal::TraceWriterFile | |
| DGtal::TraceWriterTerm | Implements trace prefix for color terminals |
| DGtal::ExplicitDigitalSurface< TKSpace, TSurfelPredicate >::Tracker | |
| DGtal::SetOfSurfels< TKSpace, TSurfelSet >::Tracker | |
| DGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >::Tracker | |
| DGtal::ImplicitDigitalSurface< TKSpace, TPointPredicate >::Tracker | |
| DGtal::DigitalSetBoundary< TKSpace, TDigitalSet >::Tracker | |
| DGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >::Tracker | |
| DGtal::Display3D::triangleD3D | |
| DGtal::TrueBoolFct0 | |
| DGtal::TrueGlobalEstimatorOnPoints< TConstIteratorOnPoints, TParametricShape, TParametricShapeFunctor > | Aim: Computes the true quantity to each element of a range associated to a parametric shape |
| DGtal::TrueLocalEstimatorOnPoints< TConstIteratorOnPoints, TParametricShape, TParametricShapeFunctor > | Aim: Computes the true quantity to each element of a range associated to a parametric shape |
| DGtal::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) |
| DGtal::BLUELocalLengthEstimator< TConstIterator > | Aim: Best Linear Unbiased Two step length estimator |
| DGtal::RosenProffittLocalLengthEstimator< TConstIterator > | Aim: Rosen-Proffitt Length Estimator |
| DGtal::UmbrellaComputer< TDigitalSurfaceTracker > | Aim: Useful for computing umbrellas on 'DigitalSurface's, ie set of n-1 cells around a n-3 cell |
| DGtal::LabelledMap< TData, L, TWord, N, M >::ValueCompare | Value comparator class. Always natural ordering between keys |
| DGtal::AngleLinearMinimizer::ValueInfo | |
| DGtal::IndexedListWithBlocks< TValue, N, M >::ValueOrBlockPointer | Used in blocks to finish it or to point to the next block |
| DGtal::BreadthFirstVisitor< TGraph, TMarkSet >::VertexAccessor | |
| DGtal::DepthFirstVisitor< TGraph, TMarkSet >::VertexAccessor | |
| DGtal::Object< TDigitalTopology, TDigitalSet >::VertexMap< Value > | |
| DGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >::VertexMap< Value > | |
| DGtal::DigitalSurface< TDigitalSurfaceContainer >::VertexMap< Value > | |
| DGtal::MetricAdjacency< TSpace, 2, 3 >::VertexMap< Value > | |
| DGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >::VertexMap< Value > | |
| DGtal::MetricAdjacency< TSpace, 3, 3 >::VertexMap< Value > | |
| DGtal::MetricAdjacency< TSpace, 2, 2 >::VertexMap< Value > | |
| DGtal::MetricAdjacency< TSpace, maxNorm1, dimension >::VertexMap< Value > | |
| DGtal::CUndirectedSimpleLocalGraph< T >::VertexMap< Value > | |
| DGtal::DomainAdjacency< TDomain, TAdjacency >::VertexMap< Value > | |
| DGtal::MetricAdjacency< TSpace, 1, 3 >::VertexMap< Value > | |
| DGtal::MetricAdjacency< TSpace, 1, 2 >::VertexMap< Value > | |
| VertexSize | |
| DGtal::VolReader< TImageContainer > | Aim: implements methods to read a "Vol" file format |
| DGtal::VolWriter< TImage, TFunctor > | Aim: Export a 3D Image using the Vol formats |
| DGtal::VoronoiMap< TSpace, TPointPredicate, p > | Aim: Implementation of the linear in time Voronoi map construction |
| DGtal::Display3D::voxelD3D | |
| DGtal::Warning_promote_trait_not_specialized_for_this_case | |
| DGtal::Xe_kComputer< n, Ring, Alloc > | |
| DGtal::Xe_kComputer< 0, Ring, Alloc > | |
| DGtal::XorBoolFct2 | |
1.8.1.1
