| CDGtal::LabelledMap< TData, L, TWord, N, M >::__AnyBlock | |
| CDGtal::LabelledMap< TData, L, TWord, N, M >::__FirstBlock | |
| CA< TC, TD > | |
| CA1 | |
| CA< TC, int > | |
| CB< TC > | |
| CDGtal::functors::Abs< T > | |
| 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::DigitalSurface_graph_traversal_category | |
| Cboost::Object_graph_traversal_category | |
| Cboost::AdjacencyGraphConcept< G > | Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/AdjacencyGraph.html |
| CDGtal::AffineBasis< TPoint > | Aim: Utility class to determine the affine geometry of an input set of points. It provides exact results when the input is composed of lattice points, and may determine a basis, the dimension, or an orthogonal vector |
| CDGtal::AffineGeometry< TPoint > | Aim: Utility class to determine the affine geometry of an input set of points. It provides exact results when the input is composed of lattice points, and may determine a basis, the dimension, or an orthogonal vector |
| CDGtal::detail::AffineGeometryInternalNumber< TScalar, Robust > | |
| CDGtal::detail::AffineGeometryInternalNumber< double, false > | |
| CDGtal::detail::AffineGeometryInternalNumber< double, true > | |
| CDGtal::detail::AffineGeometryInternalNumber< float, false > | |
| CDGtal::detail::AffineGeometryInternalNumber< float, true > | |
| CDGtal::detail::AffineGeometryInternalNumber< int32_t, false > | |
| CDGtal::detail::AffineGeometryInternalNumber< int32_t, true > | |
| CDGtal::detail::AffineGeometryInternalNumber< int64_t, false > | |
| CDGtal::detail::AffineGeometryInternalNumber< int64_t, true > | |
| CDGtal::detail::AffineGeometryPointOperations< dim, TEuclideanRing, TContainer > | Aim: Internal class used by AffineGeometry to differentiate operations on lattice points and operations on points with floating-point coordinates |
| CDGtal::detail::AffineGeometryPointOperations< dim, double, TContainer > | Aim: Internal class used by AffineGeometry to differentiate operations on lattice points and operations on points with floating-point coordinates. This specialization assumes double as components |
| CDGtal::detail::AffineGeometryPointOperations< dim, float, TContainer > | Aim: Internal class used by AffineGeometry to differentiate operations on lattice points and operations on points with floating-point coordinates. This specialization assumes float as components |
| CDGtal::detail::AffineGeometryScalarOperations< TScalar > | Aim: Internal class used by AffineGeometry to differentiate operations on point coordinates, which may be integer or floating-point numbers.. The generic class assume integer coordinates, while there are two specializations for float and double |
| CDGtal::detail::AffineGeometryScalarOperations< double > | Aim: Internal class used by AffineGeometry to differentiate operations on lattice points and operations on points with floating-point coordinates. This specialization assume double for coordinates |
| CDGtal::detail::AffineGeometryScalarOperations< float > | Aim: Internal class used by AffineGeometry to differentiate operations on lattice points and operations on points with floating-point coordinates. This specialization assume float for coordinates |
| 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) |
| CAliasToConstRefMember | |
| CAliasToCountedPtrOrPtrMember | |
| CAliasToPtrMember | |
| CAliasToRefMember | |
| CDGtal::AlphaThickSegmentComputer< TInputPoint, TConstIterator > | Aim: This class is devoted to the recognition of alpha thick segments as described in [48] . 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 |
| CAnalyzer< KSpace, N > | |
| CDGtal::functors::AndBoolFct2 | |
| CDGtal::AngleComputer | |
| CAngleLessCell | |
| CDGtal::AngleLinearMinimizer | Aim: Used to minimize the angle variation between different angles while taking into accounts min and max constraints. Example ( |
| CDGtal::AngleLinearMinimizerByAdaptiveStepGradientDescent | |
| CDGtal::AngleLinearMinimizerByGradientDescent | |
| CDGtal::AngleLinearMinimizerByRelaxation | |
| 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< TCoordinate, TCoordinate, 4 > | |
| CDGtal::StandardDSL< TCoordinate, TInteger > | Aim: This class is an alias of ArithmeticalDSS for standard DSL. It represents a standard digital straight line (DSL), ie. the set of digital points \( (x,y) \in \mathbb{Z}^2 \) such that \( \mu \leq ax - by < \mu + \omega \) with \( a,b,\mu,\omega \in \mathbb{Z} \), \( \gcd(a,b) = 1 \) and \( \omega = |a| + |b| \). Note that any DSL such that \( \omega = |a| + |b| \) is simply 4-connected |
| CDGtal::ArithmeticalDSL< TCoordinate, TCoordinate, 8 > | |
| CDGtal::NaiveDSL< TCoordinate, TInteger > | Aim: This class is an alias of ArithmeticalDSS for naive DSL. It represents a naive digital straight line (DSL), ie. the set of digital points \( (x,y) \in \mathbb{Z}^2 \) such that \( \mu \leq ax - by < \mu + \omega \) with \( a,b,\mu,\omega \in \mathbb{Z} \), \( \gcd(a,b) = 1 \) and \( \omega = \max(|a|,|b|) \). Note that any DSL such that \( \omega = \max(|a|,|b|) \) is simply 8-connected |
| 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< TCoordinate, TCoordinate, 4 > | |
| CDGtal::StandardDSS4< TCoordinate, TInteger > | Aim: This class represents a standard digital straight segment (DSS), ie. the sequence of simply 4-connected digital points contained in a standard digital straight line (DSL) between two points of it. This class is an alias of ArithmeticalDSS |
| CDGtal::ArithmeticalDSS< TCoordinate, TCoordinate, 8 > | |
| CDGtal::NaiveDSS8< TCoordinate, TInteger > | Aim: This class represents a standard digital straight segment (DSS), ie. the sequence of simply 8-connected digital points contained in a naive digital straight line (DSL) between two points of it. This class is an alias of ArithmeticalDSS |
| 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::ArithmeticalDSSComputerOnSurfels< TKSpace, TIterator, TInteger > | Aim: This class is a wrapper around ArithmeticalDSS that is devoted to the dynamic recognition of digital straight segments (DSS) along a sequence of surfels lying on a slice of the digital surface (i.e., the orthogonal direction of all surfels belong to a same plane, most pairs of consecutive surfels share a common linel) |
| 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) |
| CDGtal::ArithmeticConversionTraits< T, U, Enable > | Aim: Trait class to get result type of arithmetic binary operators between two given types |
| CDGtal::ArithmeticConversionTraits< BigInteger, BigInteger > | Specialization when both operands are BigInteger |
| CDGtal::ArithmeticConversionTraits< BigInteger, U, typename std::enable_if< std::is_integral< U >::value >::type > | Specialization when second operand is a BigInteger |
| CDGtal::ArithmeticConversionTraits< LeftEuclideanRing, PointVector< dim, RightEuclideanRing, RightContainer >, typename std::enable_if< IsArithmeticConversionValid< LeftEuclideanRing, RightEuclideanRing >::value &&! IsAPointVector< LeftEuclideanRing >::value >::type > | Specialization of ArithmeticConversionTraits when right operand is a PointVector |
| CDGtal::ArithmeticConversionTraits< PointVector< dim, LeftEuclideanRing, LeftContainer >, PointVector< dim, RightEuclideanRing, RightContainer >, typename std::enable_if< IsArithmeticConversionValid< LeftEuclideanRing, RightEuclideanRing >::value >::type > | Specialization of ArithmeticConversionTraits when both operands are PointVector |
| CDGtal::ArithmeticConversionTraits< PointVector< dim, LeftEuclideanRing, LeftContainer >, RightEuclideanRing, typename std::enable_if< IsArithmeticConversionValid< LeftEuclideanRing, RightEuclideanRing >::value &&! IsAPointVector< RightEuclideanRing >::value >::type > | Specialization of ArithmeticConversionTraits when left operand is a PointVector |
| CDGtal::ArithmeticConversionTraits< std::remove_cv< std::remove_reference< T >::type >::type, std::remove_cv< std::remove_reference< U >::type >::type > | |
| CDGtal::ArithmeticConversionTraits< T, U, typename std::enable_if< ! std::is_same< T, typename std::remove_cv< typename std::remove_reference< T >::type >::type >::value||! std::is_same< U, typename std::remove_cv< typename std::remove_reference< U >::type >::type >::value >::type > | Specialization in order to remove const specifiers and references from given types |
| CDGtal::ArithmeticConversionTraits< T, BigInteger, typename std::enable_if< std::is_integral< T >::value >::type > | Specialization when first operand is a BigInteger |
| CDGtal::ArithmeticConversionTraits< T, U, typename std::enable_if< std::is_arithmetic< T >::value &&std::is_arithmetic< U >::value >::type > | Specialization for (fundamental) arithmetic types |
| CArrayLXY< Value, L, X, Y > | |
| CArrayXYOfLabelledMap< Value, L, X, Y, TWord, N, M > | |
| CArrayXYOfList< Value, L, X, Y > | |
| CArrayXYOfMap< Value, L, X, Y > | |
| Cboost::Assignable< T > | Go to http://www.sgi.com/tech/stl/Assignable.html |
| CDGtal::concepts::CUnaryFunctor< T, T::Cell, T::RealPoint > | |
| CDGtal::concepts::CCellEmbedder< T > | Aim: A cell embedder is a mapping from unsigned cells to Euclidean points. It adds inner types to functor |
| CDGtal::concepts::CUnaryFunctor< T, T::Point, T::RealPoint > | |
| CDGtal::concepts::CPointEmbedder< T > | Aim: A point embedder is a mapping from digital points to Euclidean points. It adds inner types to functor |
| CDGtal::concepts::CUnaryFunctor< T, T::Point, T::Value > | |
| CDGtal::concepts::CPointFunctor< T > | Aim: Defines a functor on points |
| CDGtal::concepts::COrientationFunctor< T > | Aim: This concept gathers models implementing an orientation test of \( k+1 \) points in a space of dimension \( n \) |
| CDGtal::concepts::COrientationFunctor2< T > | Aim: This concept is a refinement of COrientationFunctor, useful for simple algebraic curves that can be uniquely defined by only two points |
| CDGtal::concepts::CUnaryFunctor< T, T::Point, bool > | |
| CDGtal::concepts::CPredicate< T, T::Point > | |
| CDGtal::concepts::CPointPredicate< T > | Aim: Defines a predicate on a point |
| CDGtal::concepts::CDigitalSet< T > | Aim: Represents a set of points within the given domain. This set of points is modifiable by the user. It is thus very close to the STL concept of simple associative container (like set std::set<Point>), except that there is a notion of maximal set of points (the whole domain) |
| CDGtal::concepts::CUnaryFunctor< T, TElement, bool > | |
| CDGtal::concepts::CPredicate< T, TElement > | Aim: Defines a predicate function, ie. a functor mapping a domain into the set of booleans |
| CDGtal::concepts::CUnaryFunctor< T, T::SCell, T::RealPoint > | |
| CDGtal::concepts::CSCellEmbedder< T > | Aim: A cell embedder is a mapping from signed cells to Euclidean points. It adds inner types to functor |
| CDGtal::concepts::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 |
| CDGtal::concepts::CUnaryFunctor< T, T::Surfel, bool > | |
| CDGtal::concepts::CPredicate< T, T::Surfel > | |
| CDGtal::concepts::CSurfelPredicate< T > | Aim: Defines a predicate on a surfel |
| CDGtal::concepts::CUnaryFunctor< T, T::Vertex, bool > | |
| CDGtal::concepts::CPredicate< T, T::Vertex > | |
| CDGtal::concepts::CVertexPredicate< T > | Aim: Defines a predicate on a vertex |
| CDGtal::C2x2DetComputer< T > | Aim: This concept gathers all models that are able to compute the (sign of the) determinant of a 2x2 matrix with integral entries |
| CDGtal::concepts::CLMSTDSSFilter< T > | Aim: Defines the concept describing a functor which filters DSSes for L-MST calculations |
| CDGtal::concepts::CLMSTTangentFromDSS< T > | Aim: Defines the concept describing a functor which calculates a direction of the 2D DSS and an eccentricity [70] of a given point in this DSS |
| CDGtal::concepts::CLabel< T > | Aim: Define the concept of DGtal labels. Models of CLabel can be default-constructible, assignable and equality comparable |
| CDGtal::concepts::CQuantity< T > | Aim: defines the concept of quantity in DGtal |
| CDGtal::concepts::CBoundedNumber< T > | Aim: The concept CBoundedNumber specifies what are the bounded numbers. Models of this concept should be listed in NumberTraits class and should have the isBounded property |
| CDGtal::concepts::CIntegralNumber< T > | Aim: Concept checking for Integral Numbers. Models of this concept should be listed in NumberTraits class and should have the isIntegral property |
| CDGtal::concepts::CInteger< T > | Aim: Concept checking for Integer Numbers. More precisely, this concept is a refinement of both CEuclideanRing and CIntegralNumber |
| CDGtal::concepts::CSignedNumber< T > | Aim: Concept checking for Signed Numbers. Models of this concept should be listed in NumberTraits class and should have the isSigned property |
| CDGtal::concepts::CCommutativeRing< T > | Aim: Defines the mathematical concept equivalent to a unitary commutative ring |
| CDGtal::concepts::CEuclideanRing< T > | Aim: Defines the mathematical concept equivalent to a unitary commutative ring with a division operator |
| CDGtal::concepts::CInteger< T > | Aim: Concept checking for Integer Numbers. More precisely, this concept is a refinement of both CEuclideanRing and CIntegralNumber |
| CDGtal::concepts::CUnsignedNumber< T > | Aim: Concept checking for Unsigned numbers. Models of this concept should be listed in NumberTraits class and should have the isUnsigned property |
| CDGtal::concepts::CMetricSpace< T > | Aim: defines the concept of metric spaces |
| CDGtal::concepts::CDigitalMetricSpace< T > | Aim: defines the concept of digital metric spaces |
| CDGtal::concepts::CSeparableMetric< T > | Aim: defines the concept of separable metrics |
| CDGtal::concepts::CPolarPointComparator2D< T > | Aim: This concept gathers classes that are able to compare the position of two given points \( P, Q \) around a pole \( O \). More precisely, they compare the oriented angles lying between the horizontal line passing by \( O \) and the rays \( [OP) \) and \( [OQ) \) (in a counter-clockwise orientation). This is equivalent to compare the angle in radians from 0 (included) to 2 π (excluded) |
| CDGtal::concepts::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| CDGtal::concepts::CPowerMetric< T > | Aim: defines the concept of special weighted metrics, so called power metrics |
| CDGtal::concepts::CPowerSeparableMetric< T > | Aim: defines the concept of separable metrics |
| CDGtal::concepts::CPrimitiveComputer< T > | Aim: Defines the concept describing an object that computes some primitive from input points, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes |
| CDGtal::concepts::CIncrementalPrimitiveComputer< T > | Aim: Defines the concept describing an object that computes some primitive from input points given one at a time, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes |
| CDGtal::concepts::CAdditivePrimitiveComputer< T > | Aim: Defines the concept describing an object that computes some primitive from input points given group by group, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes |
| CDGtal::concepts::CSegment< T > | Aim: Defines the concept describing a segment, ie. a valid and not empty range |
| CDGtal::concepts::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 |
| CDGtal::concepts::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 |
| CDGtal::concepts::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 guarantees 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 |
| CDGtal::concepts::CBidirectionalSegmentComputer< T > | Aim: Defines the concept describing a bidirectional segment computer, ie. a model of concepts::CSegment that can extend itself in the two possible directions |
| CDGtal::concepts::CDynamicBidirectionalSegmentComputer< T > | Aim: Defines the concept describing a dynamic and bidirectional segment computer, ie. a model of concepts::CSegment that can extend and retract itself in either direction |
| CDGtal::concepts::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) |
| CDGtal::concepts::CDynamicBidirectionalSegmentComputer< T > | Aim: Defines the concept describing a dynamic and bidirectional segment computer, ie. a model of concepts::CSegment that can extend and retract itself in either direction |
| CDGtal::concepts::CSegmentComputerEstimator< T > | Aim: This concept is a refinement of CCurveLocalGeometricEstimator devoted to the estimation of a geometric quantiy along a segment detected by a segment computer |
| CDGtal::concepts::CStack< T > | Aim: This concept gathers classes that provide a stack interface |
| CDGtal::concepts::CSurfelLocalEstimator< T > | Aim: This concept describes an object that can process a range of surfels (that are supposed to belong to some (abstract) surface) so as to return one estimated quantity for each element of the range (or a given subrange) |
| CDGtal::concepts::CDigitalSurfaceLocalEstimator< T > | Aim: This concept describes an object that can process a range over some generic digital surface so as to return one estimated quantity for each element of the range (or a given subrange) |
| CDGtal::concepts::CVectorSpace< T > | Aim: Base concept for vector space structure |
| CDGtal::concepts::CDiscreteExteriorCalculusVectorSpace< T > | Aim: Lift linear algebra container concept into the dec package |
| CDGtal::concepts::CMatrix< T > | Aim: Represent any static or dynamic sized matrix having sparse or dense representation |
| CDGtal::concepts::CDenseMatrix< T > | Aim: Represent any dynamic or static sized matrix having dense representation |
| CDGtal::concepts::CDynamicMatrix< T > | Aim: Represent any dynamic sized matrix having sparse or dense representation |
| CDGtal::concepts::CSparseMatrix< T, TripletInterator > | Aim: Represent any dynamic or static sized matrix having sparse representation |
| CDGtal::concepts::CStaticMatrix< T > | Aim: Represent any static sized matrix having sparse or dense representation |
| CDGtal::concepts::CVector< T > | Aim: Represent any static or dynamic sized column vector having sparse or dense representation |
| CDGtal::concepts::CDenseVector< T > | Aim: Represent any dynamic or static sized matrix having dense representation |
| CDGtal::concepts::CDynamicVector< T > | Aim: Represent any dynamic sized column vector having sparse or dense representation |
| CDGtal::concepts::CStaticVector< T > | Aim: Represent any static sized column vector having sparse or dense representation |
| CDGtal::concepts::CVertexMap< T > | Aim: models of CVertexMap concept implement mapping between graph vertices and values |
| Cboost::Assignable< I > | |
| CDGtal::concepts::CUnaryFunctor< I, I::Point, I::Value > | |
| CDGtal::concepts::CPointFunctor< I > | |
| CDGtal::concepts::CTrivialConstImage< I > | Aim: Defines the concept describing a read-only image, which is a refinement of CPointFunctor |
| CDGtal::concepts::CConstImage< I > | Aim: Defines the concept describing a read-only image, which is a refinement of CPointFunctor |
| CDGtal::concepts::CImage< I > | Aim: Defines the concept describing a read/write image, having an output iterator |
| CDGtal::concepts::CTrivialImage< I > | Aim: Defines the concept describing an image without extra ranges, which is a refinement of CTrivialConstImage |
| CDGtal::concepts::CImage< I > | Aim: Defines the concept describing a read/write image, having an output iterator |
| Cboost::Assignable< X > | |
| CDGtal::concepts::CUnaryFunctor< X, A &, R & > | |
| CDGtal::concepts::CUnaryFunctor< X, A, R > | Aim: Defines a unary functor, which associates arguments to results |
| CDGtal::concepts::CUnaryFunctor< X, A &, R & > | |
| Cboost::AssociativeContainer< C > | Go to http://www.sgi.com/tech/stl/AssociativeContainer.html |
| CDGtal::ATSolver2D< TKSpace, TLinearAlgebra > | Aim: This class solves Ambrosio-Tortorelli functional on a two-dimensional digital space (a 2D grid or 2D digital surface) for a piecewise smooth scalar/vector function u represented as one/several 2-form(s) and a discontinuity function v represented as a 0-form. The 2-form(s) u is a regularized approximation of an input vector data g, while v represents the set of discontinuities of u. The norm chosen for u is the \( l_2 \)-norm |
| CDGtal::DicomReader< TImageContainer, TFunctor >::Aux< Image, Domain, OutPixelType, PixelType > | |
| CDGtal::ITKDicomReader< TImage >::Aux< Image, Domain, OrigValue, TFunctor, Value > | |
| CDGtal::ITKReader< TImage >::Aux< Image, Domain, OrigValue, TFunctor, Value > | |
| CDGtal::DicomReader< TImageContainer, TFunctor >::Aux< ImageContainerByITKImage< Domain, OutPixelType >, Domain, OutPixelType, PixelType > | |
| CDGtal::ITKDicomReader< TImage >::Aux< ImageContainerByITKImage< Domain, Value >, Domain, OrigValue, TFunctor, Value > | |
| CDGtal::ITKReader< TImage >::Aux< ImageContainerByITKImage< Domain, Value >, Domain, OrigValue, TFunctor, Value > | |
| 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 |
| CDGtal::AxisDomainSplitter< Domain > | Splits a domain along one of the domain grid axis |
| 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::BackwardRigidTransformation2D< TSpace, TInputValue, TOutputValue, TFunctor > | Aim: implements backward rigid transformation of point in the 2D integer space. Warring: This version uses closest neighbor interpolation |
| CDGtal::functors::BackwardRigidTransformation3D< TSpace, TInputValue, TOutputValue, TFunctor > | Aim: implements backward rigid transformation of point in 3D integer space around any arbitrary axis. This implementation uses the Rodrigues' rotation formula. Warring: This version uses closest neighbor interpolation |
| CDGtal::functors::BallConstantFunction< TScalar > | |
| CDGtal::functors::BallConstantPointFunction< TPoint, TScalar > | |
| CBallFunctor< TPoint > | |
| CBallPredicate< TPoint > | |
| 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 useful to apply basic image subsampling in any dimensions by using ImageAdapter class |
| CBenchInfo | |
| Cboost::bidirectional_iterator_archetype | |
| CDGtal::CConstBidirectionalIteratorArchetype< Point > | |
| CDGtal::CConstBidirectionalIteratorArchetype< T > | An archetype of ConstBidirectionalIterator |
| 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 |
| CBinarizer< T > | [Functor] |
| Cboost::BinaryFunction< Func, Return, First, Second > | Go to http://www.sgi.com/tech/stl/BinaryFunction.html |
| CBinaryFunctor | |
| 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 >::BlockPointer | Forward declaration |
| CDGtal::LabelledMap< TData, L, TWord, N, M >::BlockPointer | Forward declaration |
| CDGtal::functors::BlueChannel | |
| CDGtal::details::BoolToTag< Value > | Convert a boolean to the corresponding DGtal tag (TagTrue or TagFalse) |
| CDGtal::details::BoolToTag< false > | |
| 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::BoundedLatticePolytope< TSpace > | Aim: Represents an nD lattice polytope, i.e. a convex polyhedron bounded with vertices with integer coordinates, as a set of inequalities. Otherwise said, it is a H-representation of a polytope (as an intersection of half-spaces). A limitation is that we model only bounded polytopes, i.e. polytopes that can be included in a finite bounding box |
| CDGtal::BoundedLatticePolytopeCounter< TSpace > | Aim: Useful to compute quickly the lattice points within a polytope, i.e. a convex polyhedron |
| CDGtal::detail::BoundedLatticePolytopeSpecializer< N, TInteger > | Aim: It is just a helper class for BoundedLatticePolytope to add dimension specific static methods |
| CDGtal::detail::BoundedLatticePolytopeSpecializer< 3, TInteger > | Aim: 3D specialization for BoundedLatticePolytope to add dimension specific static methods |
| CDGtal::BoundedRationalPolytope< TSpace > | Aim: Represents an nD rational polytope, i.e. a convex polyhedron bounded by vertices with rational coordinates, as a set of inequalities. Otherwise said, it is a H-representation of a polytope (as an intersection of half-spaces). A limitation is that we model only bounded polytopes, i.e. polytopes that can be included in a finite bounding box |
| CDGtal::detail::BoundedRationalPolytopeSpecializer< N, TInteger > | Aim: It is just a helper class for BoundedRationalPolytope to add dimension specific static methods |
| CDGtal::detail::BoundedRationalPolytopeSpecializer< 3, TInteger > | Aim: 3D specialization for BoundedRationalPolytope to add dimension specific static methods |
| 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::concepts::C3DParametricCurve< T > | Aim: |
| CDGtal::concepts::C3DParametricCurveDecorator< T > | Aim: |
| CCallback | |
| CMyCallback | |
| CDGtal::Display3D< Space, KSpace >::Callback | A general callback for the viewer to give control to the user |
| CPolyscopeViewer::Callback | |
| CRandomPointExtension | [viewer3D-extension-derivation] |
| 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::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::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| 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::CConstSinglePassRangeFromPoint< T, Value > | |
| CDGtal::concepts::CSinglePassRangeWithWritableIteratorFromPoint< T, Value > | Aim: refined concept of single pass range with a outputIterator() method from a point |
| CDGtal::concepts::CConstBidirectionalRange< T > | Aim: Defines the concept describing a bidirectional const range |
| CDGtal::concepts::CBidirectionalRange< T > | Aim: Defines the concept describing a bidirectional range |
| CDGtal::concepts::CBidirectionalRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| CDGtal::concepts::CConstBidirectionalRangeFromPoint< T > | Aim: refined concept of const bidirectional range with a begin() method from a point |
| CDGtal::concepts::CBidirectionalRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| CDGtal::concepts::CConstSinglePassRangeFromPoint< T > | Aim: refined concept of const single pass range with a begin() method from a point |
| CDGtal::concepts::CSinglePassRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| CDGtal::concepts::CDomain< T > | Aim: This concept represents a digital domain, i.e. a non mutable subset of points of the given digital space |
| CDGtal::concepts::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| CDGtal::concepts::CSinglePassRange< T > | Aim: Defines the concept describing a range |
| CDGtal::concepts::CSinglePassRangeFromPoint< T > | Aim: refined concept of single pass range with a begin() method from a point |
| CDGtal::concepts::CSinglePassRangeWithWritableIterator< T, Value > | Aim: refined concept of const single pass range which require that an output iterator exists |
| CDGtal::concepts::CBidirectionalRangeWithWritableIterator< T, Value > | Aim: refined concept of bidirectional range which require that a reverse output iterator exists |
| CDGtal::concepts::CBidirectionalRangeWithWritableIteratorFromPoint< T, Value > | Aim: refined concept of single pass range with an routputIterator() method from a point |
| CDGtal::concepts::CSinglePassRangeWithWritableIteratorFromPoint< T, Value > | Aim: refined concept of single pass range with a outputIterator() method from a point |
| CDGtal::concepts::CUndirectedSimpleGraph< T > | Aim: Represents the concept of local graph: each vertex has neighboring vertices, but we do not necessarily know all the vertices |
| CDGtal::concepts::CCurveLocalGeometricEstimator< 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) |
| CDGtal::concepts::CSegmentComputerEstimator< T > | Aim: This concept is a refinement of CCurveLocalGeometricEstimator devoted to the estimation of a geometric quantiy along a segment detected by a segment computer |
| 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::functors::Ceil< T > | Functor that rounds up |
| CDGtal::functors::Ceil< void > | Functor that rounds up |
| CDGtal::CellGeometry< TKSpace > | Aim: Computes and stores sets of cells and provides methods to compute intersections of lattice and rational polytopes with cells |
| CDGtal::CellGeometryFunctions< TKSpace, i, N > | |
| CDGtal::CellGeometryFunctions< TKSpace, 1, 2 > | |
| CDGtal::CellGeometryFunctions< TKSpace, 1, 3 > | |
| CDGtal::CellGeometryFunctions< TKSpace, 2, 2 > | |
| CDGtal::CellGeometryFunctions< TKSpace, 2, 3 > | |
| CDGtal::CellGeometryFunctions< TKSpace, 3, 3 > | |
| CDGtal::KhalimskyPreSpaceND< dim, TInteger >::CellMap< Value > | |
| CDGtal::KhalimskySpaceND< dim, TInteger >::CellMap< Value > | |
| CDGtal::Shortcuts< TKSpace >::CellReader | |
| CDGtal::Shortcuts< TKSpace >::CellWriter | |
| 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::concepts::CGlobalGeometricEstimator< T > | Aim: This concept describes an object that can process a range so as to return one estimated quantity for the whole range |
| 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::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::concepts::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 |
| 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::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 assignment 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::ClippingPlane | Clipping plane |
| 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 |
| CCloneToCountedMember | |
| CCloneToCowMember | |
| CCloneToPtrMember | |
| CCloneToValueMember | |
| 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::PlaneProbingLNeighborhood< TPredicate >::ClosestGridPoint | Aim: Used to store the closest grid point associated to a vertex of the triangle and two extra boolean values about the local configuration at that vertex |
| 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::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< TIterator, iterator_type > | |
| CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< TIterator, BidirectionalCategory > | |
| CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::CodeHandler< TIterator, RandomAccessCategory > | |
| CDGtal::FreemanChain< TInteger >::CodesRange | Aim: 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::ColMajorStorage | Tag (empty structure) specifying a col-major storage order |
| CDGtal::Color | Structure 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::TangencyComputer< TKSpace >::ShortestPaths::Comparator | |
| 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::functors::Composer< TFunctor1, TFunctor2, ReturnType > | Aim: Define a new Functor from the composition of two other functors |
| CDGtal::Mesh< TPoint >::CompPoints | |
| CDGtal::DigitalSetByOctree< Space >::ComputationCacheKey | Helper struct for computing local estimators |
| CDGtal::FrechetShortcut< TIterator, TInteger >::Cone | |
| CConfigPointPredicate< Vector > | |
| Cboost::Const_BinaryPredicate< Func, First, Second > | Go to http://www.boost.org/libs/concept_check/reference.htm |
| Cstring::const_iterator | STL iterator class |
| Cstring::const_reverse_iterator | STL iterator class |
| 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) |
| CConstAliasToConstPtrMember | |
| CConstAliasToConstRefMember | |
| CConstAliasToCountedConstPtrOrConstPtrMember | |
| CDGtal::functors::ConstantPointPredicate< TPoint, boolCst > | Aim: The predicate that returns always the same value boolCst |
| CDGtal::functors::ConstantPointPredicate< TPoint, false > | |
| CDGtal::functors::FalsePointPredicate< TPoint > | Aim: The predicate that returns always false |
| CDGtal::functors::ConstantPointPredicate< TPoint, true > | |
| CDGtal::functors::TruePointPredicate< TPoint > | Aim: The predicate that returns always 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::functors::ConstImageFunctorHolder< TDomain, TValue, TFunctor > | Transform a point-dependent (and possibly domain-dependent) functor into a constant image |
| CDGtal::FreemanChain< TInteger >::ConstIterator | |
| CDGtal::IndexedListWithBlocks< TValue, N, M >::ConstIterator | |
| CDGtal::LabelledMap< TData, L, TWord, N, M >::ConstIterator | |
| CDGtal::StandardDSLQ0< TFraction >::ConstIterator | |
| CDGtal::OneBalancedWordComputer< TConstIterator, TInteger >::ConstPointIterator | |
| CDGtal::functors::ConstImageFunctorHolder< TDomain, TValue, TFunctor >::ConstRange | Constant range on a ConstImageFunctorHolder |
| 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 >::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 |
| CDGtal::functors::ConstValue< TValue > | Aim: Define a simple functor that returns a constant value (0 by default) |
| CDGtal::functors::ConstValueCell< TQuantity, TCell > | Aim: Define a simple functor that returns a constant quantity (0 by default) |
| Cboost::Container< C > | Go to http://www.sgi.com/tech/stl/Container.html |
| CDGtal::ContainerCategory | |
| CDGtal::AssociativeCategory | |
| CDGtal::MultipleAssociativeCategory | |
| CDGtal::MultimapAssociativeCategory | |
| CDGtal::MultisetAssociativeCategory | |
| CDGtal::UnorderedMultimapAssociativeCategory | |
| CDGtal::UnorderedMultisetAssociativeCategory | |
| CDGtal::OrderedAssociativeCategory | |
| CDGtal::MapAssociativeCategory | |
| CDGtal::MultimapAssociativeCategory | |
| CDGtal::MultisetAssociativeCategory | |
| CDGtal::SetAssociativeCategory | |
| CDGtal::PairAssociativeCategory | |
| CDGtal::MapAssociativeCategory | |
| CDGtal::MultimapAssociativeCategory | |
| CDGtal::UnorderedMapAssociativeCategory | |
| CDGtal::UnorderedMultimapAssociativeCategory | |
| CDGtal::SimpleAssociativeCategory | |
| CDGtal::MultisetAssociativeCategory | |
| CDGtal::SetAssociativeCategory | |
| CDGtal::UnorderedMultisetAssociativeCategory | |
| CDGtal::UnorderedSetAssociativeCategory | |
| CDGtal::UniqueAssociativeCategory | |
| CDGtal::MapAssociativeCategory | |
| CDGtal::SetAssociativeCategory | |
| CDGtal::UnorderedMapAssociativeCategory | |
| CDGtal::UnorderedSetAssociativeCategory | |
| CDGtal::UnorderedAssociativeCategory | |
| CDGtal::UnorderedMapAssociativeCategory | |
| CDGtal::UnorderedMultimapAssociativeCategory | |
| CDGtal::UnorderedMultisetAssociativeCategory | |
| CDGtal::UnorderedSetAssociativeCategory | |
| CDGtal::SequenceCategory | |
| 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::ContourHelper | Aim: a helper class to process sequences of points |
| Cboost::Convertible< T > | Go to http://www.boost.org/libs/concept_check/reference.htm |
| CDGtal::ConvexCellComplex< TPoint > | Aim: represents a d-dimensional complex in a d-dimensional space with the following properties and restrictions: |
| CDGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger > | Aim: the common part of all geometric kernels for computing the convex hull or Delaunay triangulation of a range of points |
| CDGtal::ConvexHullIntegralKernel< dim, Integer, InternalInteger > | |
| CDGtal::ConvexHullRationalKernel< dim, Integer, InternalInteger > | |
| CDGtal::DelaunayIntegralKernel< dim, Integer, InternalInteger > | |
| CDGtal::DelaunayRationalKernel< dim, Integer, InternalInteger > | |
| CDGtal::ConvexHullCommonKernel< dim+1, DGtal::int64_t, DGtal::int64_t > | |
| CDGtal::DelaunayIntegralKernel< dim, TCoordinateInteger, TInternalInteger > | Aim: a geometric kernel to compute the Delaunay triangulation of digital points with integer-only arithmetic. It casts lattice point into a higher dimensional space and computes its convex hull. Facets pointing toward the bottom form the simplices of the Delaunay triangulation |
| CDGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger > | Aim: a geometric kernel to compute the Delaunay triangulation of a range of floating points with integer-only arithmetic. Floating points are approximated with rational points with fixed precision (a given number of bits), which are cast in a higher dimensional space and lifted onto the "norm" paraboloid, as classically done when computing a Delaunay triangulation from a convex hull. All remaining computations are exact, as long as there is no overflow |
| CDGtal::ConvexHullCommonKernel< dim+1, TCoordinateInteger, TInternalInteger > | |
| CDGtal::DelaunayIntegralKernel< dim, TCoordinateInteger, TInternalInteger > | |
| CDGtal::DelaunayIntegralKernel< dim-1, TCoordinateInteger, TInternalInteger > | |
| CDGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger > | |
| CDGtal::DelaunayRationalKernel< dim-1, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullCommonKernel< dim, DGtal::int64_t, DGtal::int64_t > | |
| CDGtal::ConvexHullIntegralKernel< 3 > | |
| CDGtal::ConvexHullIntegralKernel< dim, DGtal::int64_t, DGtal::int64_t > | |
| CDGtal::ConvexHullIntegralKernel< dim, TCoordinateInteger, TInternalInteger > | Aim: a geometric kernel to compute the convex hull of digital points with integer-only arithmetic |
| CDGtal::ConvexHullRationalKernel< dim, TCoordinateInteger, TInternalInteger > | Aim: a geometric kernel to compute the convex hull of floating points with integer-only arithmetic. Floating points are approximated with rational points with fixed precision (a given number of bits). All remaining computations are exact, as long as there is no overflow |
| CDGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullIntegralKernel< K, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullIntegralKernel< 1, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullIntegralKernel< dim, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullIntegralKernel< dim-1, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullRationalKernel< dim, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexHullRationalKernel< dim-1, TCoordinateInteger, TInternalInteger > | |
| CDGtal::ConvexityHelper< dim, TInteger, TInternalInteger > | Aim: Provides a set of functions to facilitate the computation of convex hulls and polytopes, as well as shortcuts to build cell complex representing a Delaunay complex |
| CDGtal::detail::ConvexityHelperInternalInteger< TIntegerCoordinate, safe > | |
| CDGtal::detail::ConvexityHelperInternalInteger< DGtal::BigInteger, safe > | |
| CDGtal::detail::ConvexityHelperInternalInteger< DGtal::int32_t, false > | |
| CDGtal::detail::ConvexityHelperInternalInteger< DGtal::int32_t, true > | |
| CDGtal::detail::ConvexityHelperInternalInteger< DGtal::int64_t, false > | |
| CDGtal::detail::ConvexityHelperInternalInteger< DGtal::int64_t, true > | |
| Cboost::CopyConstructible< T > | Go to http://www.sgi.com/tech/stl/CopyConstructible.html |
| CDGtal::C2x2DetComputer< T > | Aim: This concept gathers all models that are able to compute the (sign of the) determinant of a 2x2 matrix with integral entries |
| CDGtal::concepts::CBinner< T > | Aim: Represents an object that places a quantity into a bin, i.e. a functor that associates a natural integer to a continuous value |
| CDGtal::concepts::CDigitalSet< T > | Aim: Represents a set of points within the given domain. This set of points is modifiable by the user. It is thus very close to the STL concept of simple associative container (like set std::set<Point>), except that there is a notion of maximal set of points (the whole domain) |
| CDGtal::concepts::CDigitalSurfaceContainer< T > | Aim: The digital surface container concept describes a minimal set of inner types and methods so as to describe the data of digital surfaces |
| CDGtal::concepts::CDigitalSurfaceTracker< T > | Aim: |
| CDGtal::concepts::CGraphVisitor< T > | Aim: Defines the concept of a visitor onto a graph, that is an object that traverses vertices of the graph according to some order. The user can either use the visitor as is, or even constrain the traversal with a given predicate |
| CDGtal::concepts::CLMSTDSSFilter< T > | Aim: Defines the concept describing a functor which filters DSSes for L-MST calculations |
| CDGtal::concepts::CLMSTTangentFromDSS< T > | Aim: Defines the concept describing a functor which calculates a direction of the 2D DSS and an eccentricity [70] of a given point in this DSS |
| CDGtal::concepts::CMetricSpace< T > | Aim: defines the concept of metric spaces |
| CDGtal::concepts::CPolarPointComparator2D< T > | Aim: This concept gathers classes that are able to compare the position of two given points \( P, Q \) around a pole \( O \). More precisely, they compare the oriented angles lying between the horizontal line passing by \( O \) and the rays \( [OP) \) and \( [OQ) \) (in a counter-clockwise orientation). This is equivalent to compare the angle in radians from 0 (included) to 2 π (excluded) |
| CDGtal::concepts::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| CDGtal::concepts::CPowerMetric< T > | Aim: defines the concept of special weighted metrics, so called power metrics |
| CDGtal::concepts::CPreCellularGridSpaceND< T > | Aim: This concept describes an unbounded cellular grid space in nD. In these spaces obtained by cartesian product, cells have a cubic shape that depends on the dimension: 0-cells are points, 1-cells are unit segments, 2-cells are squares, 3-cells are cubes, and so on |
| CDGtal::concepts::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 |
| CDGtal::concepts::CPrimitiveComputer< T > | Aim: Defines the concept describing an object that computes some primitive from input points, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes |
| CDGtal::concepts::CSegment< T > | Aim: Defines the concept describing a segment, ie. a valid and not empty range |
| CDGtal::concepts::CSegmentComputerEstimator< T > | Aim: This concept is a refinement of CCurveLocalGeometricEstimator devoted to the estimation of a geometric quantiy along a segment detected by a segment computer |
| CDGtal::concepts::CStack< T > | Aim: This concept gathers classes that provide a stack interface |
| CDGtal::concepts::CSurfelLocalEstimator< T > | Aim: This concept describes an object that can process a range of surfels (that are supposed to belong to some (abstract) surface) so as to return one estimated quantity for each element of the range (or a given subrange) |
| CDGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector > | Aim: Utility class to compute curvature measures induced by (1) a corrected normal current defined by a surface mesh with prescribed normals and (2) the standard Lipschitz-Killing invariant forms of area and curvatures |
| CDGtal::CorrectedNormalCurrentFormula< TRealPoint, TRealVector > | Aim: A helper class that provides static methods to compute corrected normal current formulas of curvatures |
| 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::CountedPtr< T > | Aim: Smart pointer based on reference counts |
| 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::CountedPtr< T >::Counter | |
| CDGtal::CowPtr< T > | Aim: Copy on write shared pointer |
| 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::VoxelComplex< KSpace > | |
| CDGtal::VoxelComplex< KSpace, FixtureMap > | |
| CDGtal::CubicalComplex< TKSpace, TCellContainer > | |
| CDGtal::VoxelComplex< TKSpace, TCellContainer > | |
| CDGtal::CubicalComplex< TKSpace, typename TKSpace::template CellMap< CubicalCellData >::Type > | |
| CDGtal::VoxelComplex< TKSpace, TCellContainer > | This class represents a voxel complex living in some Khalimsky space. Voxel complexes are derived from |
| 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::CAdjacency< T > | |
| CDGtal::concepts::CDomainAdjacency< T > | Aim: Refines the concept CAdjacency by telling that the adjacency is specific to a given domain of the embedding digital space |
| CDGtal::concepts::CUndirectedSimpleGraph< 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::concepts::CAdjacency< Adj > | Aim: The concept CAdjacency defines an elementary adjacency relation between points of a digital space |
| 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::CurvatureFromDSSLengthEstimator< DSSComputer > | |
| CDGtal::detail::CurvatureFromDSSBaseEstimator< DSSComputer, detail::CurvatureFromDSSLengthAndWidth > | |
| CDGtal::CurvatureFromDSSEstimator< DSSComputer > | |
| CDGtal::detail::CurvatureFromDSSLength | |
| CDGtal::detail::CurvatureFromDSSLengthAndWidth | |
| CDGtal::concepts::CVertexPredicateArchetype< TVertex > | Aim: Defines a an archetype for concept CVertexPredicate |
| CDGtal::concepts::CWithGradientMap< T > | Aim: Such object provides a gradient map that associates to each argument some real vector |
| CD34 | |
| CDGtal::LabelledMap< TData, L, TWord, N, M >::DataOrBlockPointer | Used in first block to finish it or to point to the next block |
| CDByClone | |
| CDByValue | |
| CDGtal::DecoratorParametricCurveTransformation< TCurve, TTransfromation > | Aim: Implements a decorator for applying transformations to parametric curves |
| 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 |
| CDGtal::C2x2DetComputer< T > | Aim: This concept gathers all models that are able to compute the (sign of the) determinant of a 2x2 matrix with integral entries |
| CDGtal::concepts::CLMSTDSSFilter< T > | Aim: Defines the concept describing a functor which filters DSSes for L-MST calculations |
| CDGtal::concepts::CLMSTTangentFromDSS< T > | Aim: Defines the concept describing a functor which calculates a direction of the 2D DSS and an eccentricity [70] of a given point in this DSS |
| CDGtal::concepts::CLabel< T > | Aim: Define the concept of DGtal labels. Models of CLabel can be default-constructible, assignable and equality comparable |
| CDGtal::concepts::CPolarPointComparator2D< T > | Aim: This concept gathers classes that are able to compare the position of two given points \( P, Q \) around a pole \( O \). More precisely, they compare the oriented angles lying between the horizontal line passing by \( O \) and the rays \( [OP) \) and \( [OQ) \) (in a counter-clockwise orientation). This is equivalent to compare the angle in radians from 0 (included) to 2 π (excluded) |
| CDGtal::concepts::CPositiveIrreducibleFraction< T > | Aim: Defines positive irreducible fractions, i.e. fraction p/q, p and q non-negative integers, with gcd(p,q)=1 |
| CDGtal::concepts::CPreCellularGridSpaceND< T > | Aim: This concept describes an unbounded cellular grid space in nD. In these spaces obtained by cartesian product, cells have a cubic shape that depends on the dimension: 0-cells are points, 1-cells are unit segments, 2-cells are squares, 3-cells are cubes, and so on |
| CDGtal::concepts::CPrimitiveComputer< T > | Aim: Defines the concept describing an object that computes some primitive from input points, while keeping some internal state. At any moment, the object is supposed to store at least one valid primitive for the formerly given input points. A primitive is an informal word that describes some family of objects that share common characteristics. Often, the primitives are geometric, e.g. digital planes |
| CDGtal::concepts::CSTLAssociativeContainer< T > | Aim: Defines the concept describing an Associative Container of the STL (https://www.sgi.com/tech/stl/AssociativeContainer.html) |
| CDGtal::concepts::CSegment< T > | Aim: Defines the concept describing a segment, ie. a valid and not empty range |
| CDGtal::concepts::CStaticMatrix< T > | Aim: Represent any static sized matrix having sparse or dense representation |
| CDGtal::concepts::CStaticVector< T > | Aim: Represent any static sized column vector having sparse or dense representation |
| CDGtal::concepts::CSurfelLocalEstimator< T > | Aim: This concept describes an object that can process a range of surfels (that are supposed to belong to some (abstract) surface) so as to return one estimated quantity for each element of the range (or a given subrange) |
| Cboost::DefaultConstructible< S > | |
| CDGtal::concepts::CLinearAlgebraSolver< S, V, M > | Aim: Describe a linear solver defined over a linear algebra. Problems are of the form: |
| 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 |
| CDGtal::KhalimskyPreSpaceND< dim, TInteger >::AnyCellCollection< Cell > | |
| CDGtal::KhalimskyPreSpaceND< dim, TInteger >::AnyCellCollection< SCell > | |
| CDGtal::KhalimskyPreSpaceND< dim, TInteger >::AnyCellCollection< CellType > | |
| CDerivativeTester< Calculus, order > | |
| CDerivativeTester< Calculus, -1 > | |
| CDiagonalPriority< CubicalComplex > | |
| CDGtal::DicomReader< TImageContainer, TFunctor > | Aim: Import a 3D DICOM image from file series |
| CDGtal::DigitalConvexity< TKSpace > | Aim: A helper class to build polytopes from digital sets and to check digital k-convexity and full convexity |
| CDGtal::DigitalMetricAdapter< TMetric, TInteger > | Aim: simple adapter class which adapts any models of concepts::CMetricSpace to a model of concepts::CDigitalMetricSpace |
| CDGtal::DigitalPlanePredicate< TSpace > | Aim: Representing digital planes, which are digitizations of Euclidean planes, as point predicates |
| 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::DigitalSetByOctree< Space > | A DigitalSet that stores voxels as an octree, or a DAG |
| 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::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::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 |
| 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 different 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::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::DigitalSurfacePredicate< TSurface > | Aim: A point predicate which tells whether a point belongs to the set of pointels of a given digital surface or not |
| CDGtal::DigitalSurfaceRegularization< TDigitalSurface > | Aim: Implements Digital Surface Regularization as described in [28] |
| 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::ArithmeticalDSSComputerOnSurfels< TKSpace, TIterator, TInteger >::DirectPairExtractor | |
| CDGtal::ArithmeticalDSSComputerOnSurfels< TKSpace, TIterator, TInteger >::IndirectPairExtractor | |
| CDGtal::DirichletConditions< TLinearAlgebraBackend > | Aim: A helper class to solve a system with Dirichlet boundary conditions |
| 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::Display2DFactory | Factory 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 > | Base class for viewing DGtal objects |
| CDGtal::PolyscopeViewer< DGtal::Z3i::Space, DGtal::Z3i::KSpace > | |
| CDGtal::PolyscopeViewer< Space, KSpace > | |
| CDGtal::Display3D< Z3i::Space, Z3i::KSpace > | |
| CDGtal::PolyscopeViewer< Space, KSpace > | |
| CDGtal::DisplayData< RealPoint > | Data required to display an object |
| CDGtal::DisplayStyle | Style of display of an element |
| 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::IteratorCompletionTraits< MyImage< T, N > >::DistanceFunctor | |
| CDGtal::DistanceFunctorFromPoint< TImage > | |
| CDistanceTraits< TImage, TSet, norm > | |
| CDistanceTraits< TImage, TSet, 1 > | |
| 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::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::DomainRigidTransformation2D< TDomain, TRigidTransformFunctor > | Aim: implements bounds of transformed domain |
| CDGtal::functors::DomainRigidTransformation3D< TDomain, TRigidTransformFunctor > | Aim: implements bounds of transformed domain |
| CDGtal::DrawableWithBoard2D | |
| CDGtal::CustomColors | Custom style class redefining the pen color and the fill color. You may use Board2D::Color::None for transparent color |
| CDGtal::CustomFillColor | Custom style class redefining the fill color. You may use Board2D::Color::None for transparent color |
| CDGtal::CustomPen | Custom style class redefining the pen attributes. You may use Board2D::Color::None for transparent color |
| CDGtal::CustomPenColor | Custom style class redefining the pen color. You may use Board2D::Color::None for transparent color |
| CMyDomainStyleCustomRed | |
| CMyDrawStyleCustomBlue | |
| CMyDrawStyleCustomColor | |
| CMyDrawStyleCustomFillColor | |
| CMyDrawStyleCustomGreen | |
| CMyDrawStyleCustomGreen | |
| CMyDrawStyleCustomRed | |
| CMyDrawStyleCustomRed | |
| CMyObjectStyleCustom | |
| CMyObjectStyleCustomRed | |
| CMyStyleCustom | |
| CMyStyleCustomRed | |
| CDGtal::DrawWithBoardModifier | |
| CDGtal::CustomStyle | |
| CDGtal::SetMode | Modifier class in a Board2D stream. Useful to choose your own mode for a given class. Realizes the concept CDrawableWithBoard2D |
| 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::detail::DSSDecorator4ConcavePart< TDSS > | Aim: adapter for TDSS used by FP in CONCAVE parts. Has 2 methods: |
| CDGtal::detail::DSSDecorator4ConvexPart< TDSS > | Aim: adapter for TDSS used by FP in CONVEX parts. Has 2 methods: |
| 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::DSSLengthLessEqualFilter< DSS > | |
| CDGtal::DSSMuteFilter< DSS > | |
| CDummy1< T > | |
| CDummy2< T > | |
| CDummyBigObject | |
| CDGtal::functors::DummyEstimatorFromSurfels< TSurfel, TSCellEmbedder > | |
| CDummyTbl | |
| CDGtal::DynamicBidirectionalSegmentComputer | |
| CDGtal::DynamicSegmentComputer | |
| CDynArrayLXY< Value > | |
| CDynArrayXYOfLabelledMap< Value, L, TWord, N, M > | |
| CDynArrayXYOfMap< Value > | |
| CEByAlias | |
| CEByConstAlias | |
| CDGtal::DigitalSurface< TDigitalSurfaceContainer >::Edge | |
| CDGtal::HalfEdgeDataStructure::Edge | |
| CDGtal::IntersectionTargetTrait< TSpace, TSeparation, TDimension >::Edge | Internal Edge structure |
| CDGtal::Object< TDigitalTopology, TDigitalSet >::Edge | |
| Cedge_list_graph_tag | |
| Cboost::DigitalSurface_graph_traversal_category | |
| Cboost::Object_graph_traversal_category | |
| Cboost::EdgeListGraphConcept< G > | Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/EdgeListGraph.html |
| CDGtal::EhrhartPolynomial< TSpace, TInteger > | Aim: This class implements the class Ehrhart Polynomial which is related to lattice point enumeration in bounded lattice polytopes |
| 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::EigenLinearAlgebraBackend | Aim: Provide linear algebra backend using Eigen dense and sparse matrix as well as dense vector. 6 linear solvers available: |
| CDGtal::VoronoiCovarianceMeasureOnDigitalSurface< TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction >::EigenStructure | Structure to hold a diagonalized matrix |
| CDGtal::functors::ElementaryConvolutionNormalVectorEstimator< TSurfel, TEmbedder > | Aim: Estimates normal vector by convolution of elementary normal vector to adjacent surfel |
| CDGtal::EllipticHelix< TSpace > | Aim: Implement a parametric curve – elliptic helix |
| CDGtal::functors::EmbedderFromNormalVectors< TRealPoint, TRealVector > | Functor that projects a face vertex of a surface mesh onto the tangent plane given by a per-face normal vector. This functor can be used in PolygonalCalculus to correct the embedding of digital surfaces using an estimated normal vector field (see [23]) |
| Cboost::EqualityComparable< T > | Go to http://www.sgi.com/tech/stl/EqualityComparable.html |
| CDGtal::concepts::CLabel< T > | Aim: Define the concept of DGtal labels. Models of CLabel can be default-constructible, assignable and equality comparable |
| CDGtal::concepts::CSegment< T > | Aim: Defines the concept describing a segment, ie. a valid and not empty range |
| 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 structure 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 different 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::MPolynomialEvaluatorImpl< n, TRing, TOwner, TAlloc, TX >::EvalFun< XX, Fun > | |
| CDGtal::MPolynomialEvaluatorImpl< 1, TRing, TOwner, TAlloc, TX >::EvalFun | |
| 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 > | |
| CDGtal::ExactPredicateLpSeparableMetric< TSpace, p, TRawValue > | Aim: implements separable l_p metrics with exact predicates |
| CDGtal::ExactPredicateLpSeparableMetric< TSpace, 2, TRawValue > | |
| Cstd::exception | STL class |
| CDGtal::ConnectivityException | |
| CDGtal::IOException | |
| CDGtal::InfiniteNumberException | |
| CDGtal::InputException | |
| CDGtal::MemoryException | |
| 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::QuickHull< TKernel >::Facet | |
| Cstd::false_type | |
| CDGtal::IsAPointVector< PointVector< dim, TEuclideanRing, TContainer > > | Specialization of IsAPointVector for a PointVector |
| CDGtal::IsArithmeticConversionValid< T, U, typename std::conditional< false, ArithmeticConversionType< T, U >, void >::type > | Specialization when arithmetic operation between the two given type is valid |
| CDGtal::Shortcuts< TKSpace >::is_double_nested_container< C< D< T > > > | |
| CDGtal::IsAPointVector< T > | Type trait to check if a given type is a PointVector |
| CDGtal::IsArithmeticConversionValid< T, U, Enable > | Helper to determine if an arithmetic operation between two given types has a valid result type (ie is valid) |
| CDGtal::Shortcuts< TKSpace >::is_double_nested_container< T > | |
| CDGtal::functors::FalseBoolFct0 | |
| CFalseOutsideDomain< Predicate, Domain > | |
| CFByCloneCowPtr | |
| CFByCloneHeap | |
| 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 | |
| Cbenchmark::Fixture | |
| CBenchDomain | |
| CFixture_complex_diamond | |
| CFixture_complex_fig4 | |
| CFixture_isthmus | |
| CFixture_object_diamond_with_hole | |
| CFixture_X | |
| 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::functors::Floor< T > | Functor that rounds down |
| CDGtal::functors::Floor< void > | Functor that rounds down |
| CDGtal::FMM< TImage, TSet, TPointPredicate, TPointFunctor > | Aim: Fast Marching Method (FMM) for nd distance transforms |
| Cboost::forward_iterator_archetype | |
| CDGtal::CForwardIteratorArchetype< Point > | |
| CDGtal::CForwardIteratorArchetype< T > | An archetype of ForwardIterator |
| CDGtal::ForwardCategory | |
| CDGtal::BidirectionalCategory | |
| CDGtal::RandomAccessCategory | |
| Cboost::ForwardContainer< C > | Go to http://www.sgi.com/tech/stl/ForwardContainer.html |
| Cboost::ForwardContainer< T > | |
| CDGtal::concepts::CSTLAssociativeContainer< T > | Aim: Defines the concept describing an Associative Container of the STL (https://www.sgi.com/tech/stl/AssociativeContainer.html) |
| Cboost::ForwardIterator< T > | Go to http://www.sgi.com/tech/stl/ForwardIterator.html |
| CDGtal::functors::ForwardRigidTransformation2D< TSpace, TInputValue, TOutputValue, TFunctor > | Aim: implements forward rigid transformation of point in the 2D integer space. Warring: This version uses closest neighbor interpolation |
| CDGtal::functors::ForwardRigidTransformation3D< TSpace, TInputValue, TOutputValue, TFunctor > | Aim: implements forward rigid transformation of point in 3D integer space around any arbitrary axis. This implementation uses the Rodrigues' rotation formula. Warring: This version uses closest neighbor interpolation |
| 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 >::Fraction | This fraction is a model of CPositiveIrreducibleFraction |
| CDGtal::LightSternBrocot< TInteger, TQuotient, TMap >::Fraction | This fraction is a model of CPositiveIrreducibleFraction |
| CDGtal::SternBrocot< TInteger, TQuotient >::Fraction | This 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::FreemanChain< TInteger > | |
| 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 |
| CFunctor< T, Point > | |
| CDGtal::functors::FunctorHolder< FunctorStorage, NeedDereference > | Aim: hold any callable object (function, functor, lambda, ...) as a C(Unary)Functor model |
| 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::functors::GaussianKernel | Aim: 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::GenericLatticeConvexHull< dim, TCoordinateInteger, TInternalInteger > | Aim: Implements the quickhull algorithm by Barber et al. [7], a famous arbitrary dimensional convex hull computation algorithm. It relies on dedicated geometric kernels for computing and comparing facet geometries |
| CDGtal::detail::GenericLatticeConvexHullComputers< dim, TCoordinateInteger, TInternalInteger, K > | |
| CDGtal::detail::GenericLatticeConvexHullComputers< dim, TCoordinateInteger, TInternalInteger, 1 > | |
| 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, DGtal::Color, TFunctor > | |
| 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::GeodesicsInHeat< TPolygonalCalculus > | This class implements [38] on polygonal surfaces (using Discrete differential calculus on polygonal surfaces) |
| 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 |
| Cqi::grammar | |
| CDGtal::MPolynomialGrammar< Iterator > | |
| 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::detail::GridPoint< Integer, Index > | A grid point consists of a couple of nonnegative coordinates \( (x,y) \) and an integer index \( k \) that determines a point used as origin. For a triplet of vectors \( (m_k)_{0 \leq k \leq 2} \) and a point \( q \), a grid point is defined as: \( q - m_{k} + x m_{(k+1)\bmod 3} + y m_{(k+2)\bmod 3} \). \( q - m_{k} \), called base point, is used as origin |
| CDGtal::detail::GridPointOnProbingRay< Integer, Index > | Aim: Represents a grid point along a discrete ray defined on a grid |
| 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 |
| CDGtal::HalfEdgeDataStructure::HalfEdge | |
| CDGtal::HalfEdgeDataStructure | Aim: This class represents an half-edge data structure, which is a structure for representing the topology of a combinatorial 2-dimensional surface or an embedding of a planar graph in the plane. It does not store any geometry. As a minimal example, these lines of code build two triangles connected by the edge {1,2} |
| CDGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::HalfSpace | |
| Cstd::hash< DGtal::BigInteger > | |
| Cboost::hash< DGtal::BigInteger > | |
| Cboost::hash< DGtal::KhalimskyCell< dim, TInteger > > | Extend boost namespace to define a boost::hash function on DGtal::KhalimskyCell |
| Cstd::hash< DGtal::KhalimskyCell< dim, TInteger > > | Extend std namespace to define a std::hash function on DGtal::KhalimskyCell |
| Cstd::hash< DGtal::PointVector< dim, EuclideanRing, Container > > | |
| Cboost::hash< DGtal::SignedKhalimskyCell< dim, TInteger > > | Extend boost namespace to define a boost::hash function on DGtal::SignedKhalimskyCell |
| Cstd::hash< DGtal::SignedKhalimskyCell< dim, TInteger > > | Extend std namespace to define a std::hash function on DGtal::SignedKhalimskyCell |
| 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::HyperRectDomain< TSpace > | Aim: Parallelepidec region of a digital space, model of a 'CDomain' |
| CDGtal::functors::Identity | Aim: 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::IIPrincipalCurvaturesAndDirectionsFunctor< 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 only for 3D space. Note that by second we mean the direction with second 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 between points lying in a digital domain and values |
| 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::ImageToConstantFunctor< Image, PointPredicate, TValue > | |
| CDGtal::ImplicitBall< TSpace > | Aim: model of CEuclideanOrientedShape and CEuclideanBoundedShape concepts to create a ball in nD. |
| CImplicitDigitalBall3< TPoint3 > | |
| CDGtal::ImplicitDigitalEllipse3< TPoint3 > | |
| CImplicitDigitalEllipse3< TPoint3 > | |
| 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::ImplicitFunctionDiff1LinearCellEmbedderGradientMap< KSpace, ImplicitFunctionDiff1, Embedder > | |
| CDGtal::ImplicitFunctionDiff1LinearCellEmbedderGradientMap< TKSpace, TImplicitFunctionDiff1, TEmbedder > | Forward declaration |
| 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::DigitalSurface_graph_traversal_category | |
| Cboost::Object_graph_traversal_category | |
| 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::IndexedDigitalSurface< TDigitalSurfaceContainer > | Aim: Represents a digital surface with the topology of its dual surface. Its aim is to mimic the standard DigitalSurface, but to optimize its traversal and topology services. The idea is simply to number all its vertices (ie surfels), arcs, and faces and to store its topology with an half-edge data structure. It is essentially a PolygonalSurface but with services specific to DigitalSurface, like a tracker, a DigitalSurfaceContainer, etc. In theory, it can replace a DigitalSurface in many algorithms, and is more efficient if you need to do a lot of traversal on it (like many k-ring operations) |
| 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::IndexedDigitalSurface< TDigitalSurfaceContainer >::IndexedPropertyMap< TData > | |
| CDGtal::PolygonalSurface< TPoint >::IndexedPropertyMap< TData > | |
| CDGtal::TriangulatedSurface< TPoint >::IndexedPropertyMap< TData > | |
| CDGtal::InexactPredicateLpSeparableMetric< TSpace, TValue > | Aim: implements separable l_p metrics with approximated predicates |
| 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: |
| Cboost::input_iterator_archetype | |
| CDGtal::CSinglePassIteratorArchetype< Point > | |
| CDGtal::CSinglePassIteratorArchetype< T > | An archetype of SingePassIterator |
| 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::IntegerConverter< dim, TInteger > | ----------— INTEGER/POINT CONVERSION SERVICES -----------------— |
| CDGtal::IntegerConverter< dim, DGtal::BigInteger > | |
| CDGtal::IntegerConverter< dim, DGtal::int32_t > | |
| CDGtal::IntegerConverter< dim, DGtal::int64_t > | |
| CIntegralCstToTag< T > | Transform a std::integral_constant<bool, value> to the corresponding DGtal tag |
| CIntegralCstToTag< std::false_type > | |
| CIntegralCstToTag< std::true_type > | |
| CDGtal::IntegralIntervals< TInteger > | Aim: |
| 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::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::IntersectionTargetTrait< TSpace, TSeparation, TDimension >::IntersectionTarget< Space, Separation, Dimension > | Internal intersection target structure |
| CDGtal::IntersectionTargetTrait< TSpace, TSeparation, TDimension >::IntersectionTarget< Space, 26, 1 > | |
| CDGtal::IntersectionTargetTrait< TSpace, TSeparation, TDimension >::IntersectionTarget< Space, 6, 1 > | |
| CDGtal::IntersectionTargetTrait< TSpace, TSeparation, TDimension > | Aim: A class for intersection target used for voxelization |
| CDGtal::functors::IntervalForegroundPredicate< Image > | Aim: Define a simple Foreground predicate thresholding image values between two constant values (the first one being excluded) |
| CDGtal::functors::IntervalThresholder< T > | Aim: A small functor with an operator () that compares one value to an interval |
| 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::experimental::ImageContainerByHashTree< TDomain, TValue, THashKey >::Iterator | Built-in iterator on an HashTree. This iterator visits all node in the tree |
| CDGtal::IndexedListWithBlocks< TValue, N, M >::Iterator | |
| Cstring::iterator | STL iterator class |
| Cboost::iterator_adaptor | |
| CDGtal::ConstIteratorAdapter< TIterator, TFunctor, TReturnType > | |
| CDGtal::ConstIteratorAdapter< typename TRange::ConstIterator, TFunctor, TReturnType > | |
| CDGtal::ConstIteratorAdapter< ConstIterator, Projector2d, Point2d > | |
| CDGtal::ConstIteratorAdapter< typename Domain::ConstIterator, TImage, Value > | |
| CDGtal::ConstIteratorAdapter< typename Image::ConstIterator, Functor, Point > | |
| CDGtal::ReverseIterator< ConstIterator > | |
| CDGtal::ReverseIterator< ConstCirculator > | |
| CDGtal::ConstIteratorAdapter< TIterator, TLightFunctor, TReturnType > | This class adapts any iterator so that operator* returns another element than the one pointed to by the iterator |
| CDGtal::ReverseIterator< Iterator > | This class adapts any bidirectional iterator so that operator++ calls operator-- and vice versa |
| Cboost::iterator_facade | |
| CDGtal::HyperRectDomain_Iterator< Point > | |
| CDGtal::HyperRectDomain_ReverseIterator< Iterator > | |
| CDGtal::HyperRectDomain_ReverseIterator< ConstIterator > | |
| CDGtal::HyperRectDomain_subIterator< Point > | |
| CDGtal::IntegerSequenceIterator< VertexIndex > | |
| CDGtal::IntegerSequenceIterator< Vertex > | |
| CDGtal::ArithmeticalDSL< TCoordinate, TInteger, adjacency >::ConstIterator | Aim: This class aims at representing an iterator that provides a way to scan the points of a DSL. It is both a model of readable iterator and of bidirectional iterator |
| CDGtal::CubicalComplex< TKSpace, TCellContainer >::ConstIterator | |
| CDGtal::CubicalComplex< TKSpace, TCellContainer >::Iterator | |
| CDGtal::HyperRectDomain_Iterator< TPoint > | Iterator for HyperRectDomain |
| CDGtal::HyperRectDomain_ReverseIterator< TIterator > | Reverse iterator for HyperRectDomain |
| CDGtal::HyperRectDomain_subIterator< TPoint > | |
| CDGtal::IntegerSequenceIterator< TInteger > | Aim: It is a simple class that mimics a (non mutable) iterator over integers. You can increment it, decrement it, displace it, compare it, etc. It is useful if you have a collection of consecutive integers, and you wish to create an iterator over it. It is used in the class TriangulatedSurface for example, since vertices are numbers from 0 to nbVertices - 1 |
| CDGtal::UnorderedSetByBlock< Key, TSplitter, Hash, KeyEqual, UnorderedMapAllocator >::const_iterator | Read iterator on set elements. Model of ForwardIterator |
| CDGtal::UnorderedSetByBlock< Key, TSplitter, Hash, KeyEqual, UnorderedMapAllocator >::iterator | Read-write iterator on set elements. Model of ForwardIterator |
| Cboost::graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::adjacency_iterator | |
| Cboost::graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::edge_iterator | |
| Cboost::graph_traits< DGtal::DigitalSurface< TDigitalSurfaceContainer > >::out_edge_iterator | |
| Cboost::graph_traits< DGtal::Object< TDigitalTopology, TDigitalSet > >::adjacency_iterator | |
| Cboost::graph_traits< DGtal::Object< TDigitalTopology, TDigitalSet > >::edge_iterator | |
| Cboost::graph_traits< DGtal::Object< TDigitalTopology, TDigitalSet > >::out_edge_iterator | |
| Cboost::iterator_facade< ArrayImageIterator< const Self >, const Self::Value, std::random_access_iterator_tag, decltype(((new const Self)) ->dereference(const Self::Point::diagonal(0), const Self::Point::Coordinate(0))) > | |
| CDGtal::ArrayImageIterator< const Self > | |
| Cboost::iterator_facade< ArrayImageIterator< Self >, Self::Value, std::random_access_iterator_tag, decltype(((new Self)) ->dereference(Self::Point::diagonal(0), Self::Point::Coordinate(0))) > | |
| CDGtal::ArrayImageIterator< Self > | |
| Cboost::iterator_facade< ArrayImageIterator< TIterableClass >, TIterableClass::Value, std::random_access_iterator_tag, decltype(((new TIterableClass)) ->dereference(TIterableClass::Point::diagonal(0), TIterableClass::Point::Coordinate(0))) > | |
| CDGtal::ArrayImageIterator< TIterableClass > | Aim: Random access iterator over an image given his definition domain and viewable domain |
| 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::ArrayImageAdapter< TArrayIterator, HyperRectDomain< TSpace > > | Aim: Image adapter for generic arrays with sub-domain view capability |
| CDGtal::IteratorCompletion< MyImage< T, N > > | |
| CMyImage< T, N > | [includes] |
| CDGtal::IteratorCompletionTraits< TDerived > | Aim: Traits that must be specialized for each IteratorCompletion derived class |
| CDGtal::IteratorCompletionTraits< ArrayImageAdapter< TArrayIterator, TDomain > > | [IteratorCompletionTraits] |
| CDGtal::IteratorCompletionTraits< MyImage< T, N > > | |
| CDGtal::IteratorType | |
| CDGtal::ITKDicomReader< TImage > | Aim: Import a 2D/3D DICOM Image from file series |
| CDGtal::ITKIOTrait< Value > | Aim: Provide type trait for ITK reader and ITK writer |
| CDGtal::ITKIOTrait< bool > | |
| CDGtal::ITKReader< TImage > | Aim: Import a 2D/3D Image using the ITK formats |
| CDGtal::ITKWriter< TImage, TFunctor > | Export a 2D/3D Image using the ITK formats |
| CDGtal::ITKWriter< ImageContainerByITKImage< TDomain, TValue >, TFunctor > | |
| 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::NaiveParametricCurveDigitizer3D< TParametricCurve >::KConstIter | A structure used for making iterations over digital curve with respect to K_NEXT |
| CDGtal::detail::KeyComparatorForPairKeyData< KeyComparator, PairKeyData > | |
| CDGtal::LabelledMap< TData, L, TWord, N, M >::KeyCompare | Key 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::KhalimskyPreCell< dim, TInteger > | Represents an unsigned cell in an unbounded cellular grid space by its Khalimsky coordinates |
| 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 > | Internal class of KhalimskySpaceND that provides some optimizations depending on the space type |
| CDGtal::KhalimskySpaceND< 2, Integer > | |
| CDGtal::KhalimskySpaceND< 3, Integer > | |
| CDGtal::KhalimskySpaceND< dim, Integer > | |
| CDGtal::KhalimskySpaceNDHelper< KhalimskySpaceND< dim, DGtal::int32_t > > | |
| CDGtal::KhalimskySpaceND< dimAmbient, DGtal::int32_t > | |
| CDGtal::KhalimskySpaceNDHelper< KhalimskySpaceND< dim, TInteger > > | |
| CDGtal::KhalimskySpaceND< dimAmbient, TInteger > | |
| CDGtal::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) |
| CDGtal::NaiveParametricCurveDigitizer3D< TParametricCurve >::KIter | A structure used for making iterations over digital curve with respect to K_NEXT |
| CDGtal::Knot_3_1< TSpace > | Aim: Implement a parametrized knot 3, 1 |
| CDGtal::Knot_3_2< TSpace > | Aim: Implement a parametrized knot 3, 2 |
| CDGtal::Knot_4_1< TSpace > | Aim: Implement a parametrized knot 4, 1 |
| CDGtal::Knot_4_3< TSpace > | Aim: Implement a parametrized knot 4, 3 |
| CDGtal::Knot_5_1< TSpace > | Aim: Implement a parametrized knot 5, 1 |
| CDGtal::Knot_5_2< TSpace > | Aim: Implement a parametrized knot 5, 2 |
| CDGtal::Knot_6_2< TSpace > | Aim: Implement a parametrized knot 6, 2 |
| CDGtal::Knot_7_4< TSpace > | Aim: Implement a parametrized knot 7, 4 |
| 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::detail::LabelledMapMemFunctor | |
| CDGtal::Labels< L, TWord > | Aim: Stores a set of labels in {O..L-1} as a sequence of bits |
| CDGtal::LagrangeInterpolation< TEuclideanRing > | Aim: This class implements Lagrange basis functions and Lagrange interpolation |
| CDGtal::functors::Lambda64Function | |
| CDGtal::functors::LambdaExponentialFunction | |
| CDGtal::LambdaMST2DEstimator< TSpace, TSegmentation, Functor > | |
| CDGtal::LambdaMST2D< Segmentation2D, LambdaFunctor > | |
| CDGtal::LambdaMST2DEstimator< Z2i::Space, DSSSegmentationComputer, TangentFromDSS2DFunctor< DSSSegmentationComputer::SegmentComputer, functors::Lambda64Function > > | |
| CDGtal::LambdaMST2D< DSSSegmentationComputer, LambdaFunction > | Aim: Simplify creation of Lambda MST tangent estimator |
| CDGtal::LambdaMST3DBy2DEstimator< Iterator3D, Functor, LambdaFunctor, CONNECTIVITY > | |
| CDGtal::LambdaMST3DBy2DEstimator< Iterator3D, TangentFromDSS3DBy2DFunctor, functors::Lambda64Function, 8 > | |
| CDGtal::LambdaMST3DBy2D< Iterator3D, LambdaFunctor, CONNECTIVITY > | Aim: Simplify creation of Lambda MST tangent estimator |
| CDGtal::LambdaMST3DEstimator< TSpace, TSegmentation, Functor, DSSFilter > | |
| CDGtal::LambdaMST3D< DSSSegmentationComputer, LambdaFunction, DSSFilter > | Aim: Simplify creation of Lambda MST tangent estimator |
| CDGtal::functors::LambdaSinFromPiFunction | |
| 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::LatticeSetByIntervals< TSpace > | Aim: |
| CDGtal::BoundedLatticePolytope< TSpace >::LeftStrictUnitCell | |
| CDGtal::BoundedLatticePolytope< TSpace >::LeftStrictUnitSegment | |
| CDGtal::experimental::ChamferNorm2D< TSpace >::LessOrEqThanAngular | |
| CDGtal::experimental::ChamferNorm2D< TSpace >::LessThanAngular | |
| Cboost::LessThanComparable< T > | Go to http://www.sgi.com/tech/stl/LessThanComparable.html |
| CDGtal::concepts::CQuantity< T > | Aim: defines the concept of quantity in DGtal |
| CLessThanOnFace< Vector > | |
| 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::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 > | |
| CLogFct | |
| CLogScaleFunctor< Scalar > | [LogScaleFunctor] |
| 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) |
| CDGtal::LpMetric< TSpace > | Aim: implements l_p metrics |
| Cboost_concepts::LvalueIteratorConcept< Iterator > | Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/LvalueIteratorConcept.html |
| Cstd::map< K, T > | STL class |
| CDGtal::ImageContainerBySTLMap< Z2i::Domain, DGtal::int32_t > | |
| CDGtal::ImageContainerBySTLMap< TDomain, TValue > | |
| CDGtal::functors::Max< T > | |
| CDGtal::MaximalSegmentSliceEstimation< TSurface > | Aim: |
| CDGtal::functors::MeanChannels | |
| CDGtal::MeaningfulScaleAnalysis< TProfile > | Aim: This class implements different methods used to define the meaningful scale analysis as proposed in [63] . 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::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)$ |
| CMedianPlane< Naive, Symmetric > | |
| 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: [86]] |
| 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::MeshHelpers | Aim: Static class that provides builder and converters between meshes |
| CDGtal::MeshReader< TPoint > | Aim: Defined to import OFF and OFS surface mesh. It allows to import a Mesh object and takes into accounts the optional color faces |
| CDGtal::MeshVoxelizer< TDigitalSet, Separation > | Aim: A class for computing the digitization of a triangle or a Mesh |
| 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::functors::Min< T > | Duplicated STL functors |
| CDGtal::functors::Minus< T > | |
| 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::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::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, TRing, TOwner, TAlloc, TX > | |
| 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::functors::MultiplicationByScalar< T > | |
| CMultiScaleAnalyzer< KSpace, N > | |
| CMultiScaleAnalyzer< KSpace, 0 > | Specialization |
| CDGtal::MultiStatistics | Aim: This class stores a set of sample values for several variables and can then compute different statistics, like sample mean, sample variance, sample unbiased variance, etc |
| Cboost::mutable_bidirectional_iterator_archetype | |
| CDGtal::CBidirectionalIteratorArchetype< T > | An archetype of BidirectionalIterator |
| 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 |
| Cmy_edge_copier< Graph1, Graph2 > | |
| Cmy_vertex_copier< Graph1, Graph2, VertexIndexMap > | |
| CMyBallPredicate< TP, TI > | |
| CMyPoint | |
| CMyPointD | |
| CMyTransValueFunctor< TValue > | Aim: Define a simple functor that returns a 'trans' value |
| CDGtal::Naive3DDSSComputer< TIterator, TInteger, connectivity > | Aim: Dynamic recognition of a 3d-digital straight segment (DSS) |
| CDGtal::NaiveParametricCurveDigitizer3D< TParametricCurve > | Aim: Digitization of 3D parametric curves. This method produces, for good parameters step and k_next, a 26-connected digital curves obtained from a digitization process of 3D parametric curves |
| CDGtal::NClone< T > | |
| CDGtal::Negate< T > | |
| CDGtal::Negate< TagFalse > | |
| CDGtal::Negate< TagTrue > | |
| CDGtal::NeighborhoodConvexityAnalyzer< TKSpace, K > | Aim: A class that models a \( (2k+1)^d \) neighborhood and that provides services to analyse the convexity properties of a digital set within this neighborhood |
| CDGtal::DigitalSetByOctree< Space >::Node | Node for octree |
| CDGtal::experimental::ImageContainerByHashTree< TDomain, TValue, THashKey >::Node | |
| CDGtal::LighterSternBrocot< TInteger, TQuotient, TMap >::Node | |
| CDGtal::LightSternBrocot< TInteger, TQuotient, TMap >::Node | |
| CDGtal::SternBrocot< TInteger, TQuotient >::Node | |
| CDGtal::GraphVisitorRange< TGraphVisitor >::NodeAccessor | |
| CDGtal::SymmetricConvexExpander< TKSpace, TPointPredicate >::NodeComparator | |
| CNorm1< P > | |
| CDGtal::NormalCycleComputer< TRealPoint, TRealVector > | Aim: Utility class to compute curvatures measures induced by (1) the normal cycle induced by a SurfaceMesh, (2) the standard Lipschitz-Killing invariant forms of area and curvatures |
| CDGtal::NormalCycleFormula< TRealPoint, TRealVector > | Aim: A helper class that provides static methods to compute normal cycle formulas of curvatures |
| CDGtal::detail::NormalizedTangentVectorFromDSS | |
| CDGtal::VoronoiCovarianceMeasureOnDigitalSurface< TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction >::Normals | Structure 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::PlaneProbingParallelepipedEstimator< TPredicate, mode >::NotAbovePredicate | |
| 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::NumberTraitsImpl< T, Enable > | Aim: The traits class for all models of Cinteger (implementation) |
| CDGtal::ParamType< Integer > | |
| CDGtal::ParamType< UnsignedInteger > | |
| CDGtal::UnsignedVersion< Integer > | |
| CDGtal::UnsignedVersion< Component > | |
| CDGtal::IsBounded< Integer > | |
| CDGtal::NumberTraitsImpl< DGtal::BigInteger, Enable > | Specialization of NumberTraitsImpl for DGtal::BigInteger |
| CDGtal::NumberTraitsImpl< std::decay< T >::type > | |
| CDGtal::NumberTraits< T > | Aim: The traits class for all models of Cinteger |
| CDGtal::NumberTraitsImpl< std::decay< TInteger >::type > | |
| CDGtal::SignedVersion< TInteger > | |
| CDGtal::UnsignedVersion< TInteger > | |
| CDGtal::NumberTraits< TInteger > | |
| CDGtal::details::NumberTraitsImplFundamental< T > | NumberTraits common part for fundamental integer and floating-point types |
| CDGtal::NumberTraitsImpl< T, typename std::enable_if< std::is_floating_point< T >::value >::type > | Specialization of NumberTraitsImpl for fundamental floating-point types |
| CDGtal::NumberTraitsImpl< T, typename std::enable_if< std::is_integral< T >::value >::type > | Specialization of NumberTraitsImpl for fundamental integer types |
| CDGtal::Object< TDigitalTopology, TDigitalSet > | Aim: An object (or digital object) represents a set in some digital space associated with a digital topology |
| CObjects2D | |
| CDGtal::FrechetShortcut< TIterator, TInteger >::Backpath::occulter_attributes | |
| CDGtal::DigitalSetByOctree< Space >::OctreeIterator | Iterator over the octree |
| CDGtal::OneBalancedWordComputer< TConstIterator, TInteger > | Aim: |
| CDGtal::OneItemOutputIterator< T > | Aim: model of output iterator, ie incrementable and writable iterator, which only stores in a variable the last assigned item |
| CDGtal::OpInSTLContainers< Container, Iterator > | |
| CDGtal::OpInSTLContainers< Container, std::reverse_iterator< typename Container::iterator > > | |
| CDGtal::OppositeDuality< duality_orig > | |
| CDGtal::OppositeDuality< DUAL > | |
| CDGtal::OppositeDuality< PRIMAL > | |
| COptions | |
| CDGtal::functors::OrBoolFct2 | |
| CDGtal::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) |
| CDGtal::OrderedLinearRegression | Description of class 'OrderedLinearRegression' |
| Cboost::OutputIterator< T > | Go to http://www.sgi.com/tech/stl/OutputIterator.html |
| CDGtal::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 |
| 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 |
| Cstd::pair< T1, T2 > | STL class |
| CDGtal::DistanceBreadthFirstVisitor< TGraph, TVertexFunctor, TMarkSet >::Node | |
| CDGtal::functors::Pair1st< ReturnType > | Aim: Define a simple functor that returns the first member of a pair |
| 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 |
| CPairSorted2nd< T1, T2 > | [polyhedralizer-typedefs] |
| CDGtal::ParallelIIEstimator< TEstimator, TSplitter > | Run an Integral Invariant estimator in parallel |
| 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::Parameters | |
| CDGtal::ParameterValue | |
| 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::ParDirCollapse< CC > | Aim: Implements thinning algorithms in cubical complexes. The implementation supports any model of cubical complex, for instance a DGtal::CubicalComplex< KhalimskySpaceND< 3, int > >. Three approaches are provided. The first—ParDirCollapse—bases on directional collapse of free pairs of faces. Second—CollapseSurface—is an extension of ParDirCollapse such that faces of dimension one lower than the dimension of the complex are kept. The last approach —CollapseIsthmus—is also an extension of ParDirCollapse such that faces of dimension one lower than the complex are preserved when they do not contain free faces of dimension two lower than the complex. Paper: Chaussard, J. and Couprie, M., Surface Thinning in 3D Cubical Complexes, Combinatorial Image Analysis, (2009) |
| CLibBoard::Path | A 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::PConvexity< TSpace > | Aim: A class to check if digital sets are P-convex. The P-convexity is defined as follows: A digital set X subset of \( \mathbb{Z}^d \) is P-convex iff |
| 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) |
| CDGtal::PlaneProbingDigitalSurfaceLocalEstimator< TSurface, TInternalProbingAlgorithm > | Aim: Adapt a plane-probing estimator on a digital surface to estimate normal vectors |
| CDGtal::PlaneProbingNeighborhood< TPredicate > | Aim: A base virtual class that represents a way to probe a neighborhood, used in the plane probing based estimators, see DGtal::PlaneProbingTetrahedronEstimator or DGtal::PlaneProbingParallelepipedEstimator |
| CDGtal::PlaneProbingHNeighborhood< TPredicate > | Aim: Represent a way to probe the H-neighborhood |
| CDGtal::PlaneProbingRNeighborhood< TPredicate > | Aim: Represent a way to probe the R-neighborhood |
| CDGtal::PlaneProbingLNeighborhood< TPredicate > | Aim: Represents a way to probe the L-neighborhood, see [83] for details |
| CDGtal::PlaneProbingR1Neighborhood< TPredicate > | Aim: Represent a way to probe the R-neighborhood, with the R1 optimization, see [102] for details |
| CDGtal::PlaneProbingParallelepipedEstimator< TPredicate, mode > | Aim: |
| CDGtal::PlaneProbingTetrahedronEstimator< TPredicate, mode > | Aim: A class that locally estimates a normal on a digital set using only a predicate "does a point x belong to the digital set or not?" |
| CLibBoard::Point | Struct 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 (>=) |
| CPoint3D | |
| CPointConverter< StorageOrder > | Converter between col-major and row-major storage order |
| CPointConverter< ColMajorStorage > | |
| CPointConverter< RowMajorStorage > | |
| CDGtal::functors::PointFunctorFromPointPredicateAndDomain< TPointPredicate, TDomain, TValue > | Create a point functor from a point predicate and a domain |
| CDGtal::functors::PointFunctorHolder< TPoint, TValue, TFunctor > | Aim: hold any object callable on points as a DGtal::concepts::CPointFunctor model |
| 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::PointOnProbingRay< Integer, Index > | A ray consists of a permutation \( \sigma \) and an integer index \( \lambda \) (position on the ray). For a triplet of vectors \( (m_k)_{0 \leq k \leq 2} \) and a point \( q \), a point on the ray is defined as: \( q - m_{\sigma(0)} + m_{\sigma(1)} + \lambda m_{\sigma(2)} \). \( q - m_{\sigma(0)} + m_{\sigma(1)} \) is called the base point |
| 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::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::PolygonalCalculus< TRealPoint, TRealVector > | Implements differential operators on polygonal surfaces from [42] |
| CDGtal::PolygonalSurface< TPoint > | Aim: Represents a polygon mesh, i.e. a 2-dimensional combinatorial surface whose faces are (topologically at least) simple polygons. The topology is stored with a half-edge data structure. This object stored the positions of vertices in space. If you need further data attached to the surface, you may use property maps (see PolygonalSurface::makeVertexMap) |
| CDGtal::functors::SphereFittingEstimator< TSurfel, TEmbedder, TNormalVectorEstimatorCache >::PoncaPoint | |
| CDGtal::detail::PosDepScaleDepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| CDGtal::detail::PosDepScaleDepSCEstimator< DCAComputer, detail::DistanceFromDCA > | |
| CDGtal::DistanceFromDCAEstimator< DCAComputer > | |
| CDGtal::detail::PosDepScaleIndepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| CDGtal::detail::PosDepScaleIndepSCEstimator< DCAComputer, detail::NormalVectorFromDCA > | |
| CDGtal::NormalFromDCAEstimator< DCAComputer > | |
| CDGtal::detail::PosDepScaleIndepSCEstimator< DCAComputer, detail::TangentVectorFromDCA > | |
| CDGtal::TangentFromDCAEstimator< DCAComputer > | |
| CDGtal::detail::PosIndepScaleDepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| CDGtal::detail::PosIndepScaleDepSCEstimator< DCAComputer, detail::CurvatureFromDCA< true > > | |
| CDGtal::CurvatureFromDCAEstimator< DCAComputer, isCCW > | |
| CDGtal::detail::PosIndepScaleIndepSCEstimator< TSegmentComputer, Functor, ReturnType > | |
| CDGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::NormalizedTangentVectorFromDSS > | |
| CDGtal::TangentFromDSSEstimator< DSSComputer > | |
| CDGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::TangentAngleFromDSS > | |
| CDGtal::TangentAngleFromDSSEstimator< DSSComputer > | |
| CDGtal::detail::PosIndepScaleIndepSCEstimator< DSSComputer, detail::TangentVectorFromDSS< DSSComputer > > | |
| CDGtal::TangentVectorFromDSSEstimator< 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::ReverseDistanceTransformation< TWeightImage, TPSeparableMetric, TImageContainer > | |
| CDGtal::ReverseDistanceTransformation< TWeightImage, TPSeparableMetric, TImageContainer > | Aim: Implementation of the linear in time reverse distance transformation for separable metrics |
| 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 |
| 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::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::Preimage2D< Shape > | Aim: Computes the preimage of the 2D Euclidean shapes crossing a sequence of n straight segments in O(n), with the algorithm of O'Rourke (1981) |
| CDGtal::PlaneProbingDigitalSurfaceLocalEstimator< TSurface, TInternalProbingAlgorithm >::ProbingFrame | |
| 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::promote_trait< A, B > | |
| CDGtal::promote_trait< int32_t, int64_t > | |
| CDGtal::DiscreteExteriorCalculus< dimEmbedded, dimAmbient, TLinearAlgebraBackend, TInteger >::Property | Holds size 'primal_size', 'dual_size', 'index' and 'flipped' for each cell of the DEC object. To avoid inserting both positive and negative cells in a DEC object, only non signed cells are stored internally |
| CDGtal::QuantifiedColorMap< TColorMap > | Aim: A modifier class that quantifies any colormap into a given number of colors. It is particularly useful when rendering colored objects, since for instance blender is very slow to load many different materials |
| CDGtal::functors::SphereFittingEstimator< TSurfel, TEmbedder, TNormalVectorEstimatorCache >::Quantity | Quantity type: a 3-sphere (model of CQuantity) |
| CDGtal::Quantity< T > | Wrapper for array of quantities |
| CDGtal::QuickHull< TKernel > | Aim: Implements the quickhull algorithm by Barber et al. [7], a famous arbitrary dimensional convex hull computation algorithm. It relies on dedicated geometric kernels for computing and comparing facet geometries |
| 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::RandomColorMap | Aim: access to random color from a gradientColorMap |
| CDGtal::BoundedRationalPolytope< TSpace >::Rational | |
| CRawIO< Image > | |
| CRawIO16< Image > | |
| CRawIO32< Image > | |
| CRawIO8< Image > | |
| 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::Rect | Struct representing a rectangle on the plane |
| CDGtal::detail::RecursivePConvexity< dim, TInteger > | |
| CDGtal::detail::RecursivePConvexity< 1, TInteger > | |
| 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::RegularDomainSplitter< Domain > | Splits a domain evenly along all dimensions |
| 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::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] |
| Cstring::reverse_iterator | STL iterator class |
| Cboost::ReversibleContainer< C > | Go to http://www.sgi.com/tech/stl/ReversibleContainer.html |
| CDGtal::BoundedLatticePolytope< TSpace >::RightStrictUnitCell | |
| CDGtal::BoundedLatticePolytope< TSpace >::RightStrictUnitSegment | |
| CDGtal::functors::Round< T > | Functor that rounds to the nearest integer |
| CDGtal::functors::Round< void > | Functor that rounds to the nearest integer |
| CDGtal::RowMajorStorage | Tag (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::Shortcuts< TKSpace >::SCellReader | |
| 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::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::Shortcuts< TKSpace >::SCellWriter | |
| CDGtal::GreedySegmentation< TSegmentComputer >::SegmentComputerIterator | Aim: Specific iterator to visit all the segments of a greedy segmentation |
| CDGtal::SaturatedSegmentation< TSegmentComputer >::SegmentComputerIterator | Aim: 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} |
| CSegmentedPlane | |
| 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::SetValueIterator< TImage, TIteratorOnPts > | Aim: implements an output iterator, which is able to write values in an underlying image, by calling its setValue method |
| Cboost::SGIAssignable< T > | Go to http://www.boost.org/libs/concept_check/reference.htm |
| CLibBoard::Shape | Abstract structure for a 2D shape |
| CLibBoard::Dot | A line between two points |
| CLibBoard::Ellipse | An ellipse |
| CLibBoard::Circle | A circle |
| CLibBoard::Arc | An arc |
| CLibBoard::Line | A line between two points |
| CLibBoard::Arrow | A line between two points with an arrow at one extremity |
| CLibBoard::Polyline | A polygonal line described by a series of 2D points |
| CLibBoard::GouraudTriangle | A triangle with shaded filling according to colors given for each vertex |
| CLibBoard::Rectangle | A rectangle |
| CLibBoard::Image | Used to draw image in figure |
| CLibBoard::Triangle | A triangle. Basically a Polyline with a convenient constructor |
| CLibBoard::QuadraticBezierCurve | A quadratic Bezier curve having 3 control points. NB. It is also a parabola arc |
| CLibBoard::ShapeList | A group of shapes |
| CLibBoard::Board | Class for EPS, FIG or SVG drawings |
| CDGtal::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 |
| CLibBoard::Group | A group of shapes. A group is basically a ShapeList except that when rendered in either an SVG of a FIG file, it is a true compound element |
| CLibBoard::Text | A piece of text |
| CDGtal::functors::ShapeGeometricFunctors::ShapeFirstPrincipalCurvatureFunctor< TShape > | Aim: A functor RealPoint -> Quantity that returns the first principal curvature at given point (i.e. smallest principal curvature) |
| CDGtal::functors::ShapeGeometricFunctors::ShapeFirstPrincipalDirectionFunctor< TShape > | Aim: A functor RealPoint -> RealVector that returns the first principal direction at given point (i.e. direction of smallest principal curvature) |
| CDGtal::functors::ShapeGeometricFunctors::ShapeGaussianCurvatureFunctor< TShape > | Aim: A functor RealPoint -> Quantity that returns the gaussian curvature at given point |
| 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::functors::ShapeGeometricFunctors::ShapePrincipalCurvaturesAndDirectionsFunctor< TShape > | Aim: A functor RealPoint -> (Scalar,Scalar,RealVector,RealVector that returns the principal curvatures and the principal directions as a tuple at given point (k1,k2,d1,d2) |
| CDGtal::Shapes< TDomain > | Aim: A utility class for constructing different shapes (balls, diamonds, and others) |
| CDGtal::functors::ShapeGeometricFunctors::ShapeSecondPrincipalCurvatureFunctor< TShape > | Aim: A functor RealPoint -> Quantity that returns the second principal curvature at given point (i.e. greatest principal curvature) |
| CDGtal::functors::ShapeGeometricFunctors::ShapeSecondPrincipalDirectionFunctor< TShape > | Aim: A functor RealPoint -> RealVector that returns the second principal direction at given point (i.e. direction of second/greatest principal curvature) |
| CDGtal::Shortcuts< TKSpace > | Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface with few lines of code. The drawback is that you use specific types or objects, which could lead to faster code or more compact data structures |
| CDGtal::ShortcutsGeometry< TKSpace > | Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface in a few lines. The drawback is that you use specific types or objects, which could lead to faster code or more compact data structures |
| CDGtal::Shortcuts< KSpace > | |
| CDGtal::ShortcutsGeometry< KSpace > | |
| CDGtal::Shortcuts< Z3i::KSpace > | |
| CDGtal::ShortcutsGeometry< Z3i::KSpace > | |
| CDGtal::TangencyComputer< TKSpace >::ShortestPaths | |
| CDGtal::ShroudsRegularization< TDigitalSurfaceContainer > | Aim: Implements the Shrouds Regularization algorithm of Nielson et al [91] |
| 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::SignalData< TValue > | |
| CSignedDistToCircle< Point > | [Templated signed_dist_to_unit_circle] |
| 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 > | Represents a signed cell in an unbounded cellular grid space by its Khalimsky coordinates and a boolean value |
| 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}
\) |
| 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::SimpleDistanceColorMap< TValue > | Aim: simple blue to red colormap for distance information for instance |
| 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::SimpleLinearRegression | Description of class 'SimpleLinearRegression' |
| CDGtal::SimpleMatrix< TComponent, TM, TN > | Aim: implements basic MxN Matrix services (M,N>=1) |
| 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 threshold. 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 |
| CSlice | |
| 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 > | |
| 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 Ponca 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::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder > | Aim: This functor estimates normal vector for a collection of surfels using spherical accumulator based Hough voting |
| CDGtal::SphericalTriangle< TSpace > | Aim: Represent a triangle drawn onto a sphere of radius 1 |
| CDGtal::SplitInfo< Domain > | Data structure returned by Domain splitters |
| CDGtal::Splitter< TElement, TWord > | |
| 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::Astroid2D< Space > | |
| CDGtal::Flower2D< Space > | |
| CDGtal::Lemniscate2D< Space > | |
| CDGtal::AccFlower2D< TSpace > | Aim: Model of the concept StarShaped represents any accelerated flower in the plane |
| CDGtal::Astroid2D< TSpace > | Aim: Model of the concept StarShaped represents an astroid |
| CDGtal::Ball2D< TSpace > | Aim: Model of the concept StarShaped represents any circle in the plane |
| CDGtal::Ellipse2D< TSpace > | Aim: Model of the concept StarShaped represents any ellipse in the plane |
| CDGtal::Flower2D< TSpace > | Aim: Model of the concept StarShaped represents any flower with k-petals in the plane |
| CDGtal::Lemniscate2D< TSpace > | Aim: Model of the concept StarShaped represents a lemniscate |
| CDGtal::NGon2D< TSpace > | Aim: Model of the concept StarShaped represents any regular k-gon in the plane |
| CDGtal::StarShaped3D< TSpace > | |
| CDGtal::Ball3D< TSpace > | Aim: Model of the concept StarShaped3D represents any Sphere in the space |
| CDGtal::AlphaThickSegmentComputer< TInputPoint, TConstIterator >::State | |
| CDGtal::ChordNaivePlaneComputer< TSpace, TInputPoint, TInternalScalar >::State | |
| CDGtal::COBANaivePlaneComputer< TSpace, TInternalInteger >::State | |
| CDGtal::UmbrellaComputer< TDigitalSurfaceTracker >::State | |
| CLibBoard::Board::State | |
| Cboost::static_object | |
| CDGtal::DummyObject< T > | |
| Cboost::static_visitor | |
| CDGtal::MPolynomialReader< n, TRing, TAlloc, TIterator >::ExprNodeMaker | |
| 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::STBReader< TImageContainer, TFunctor > | Aim: Image reader using the stb_image.h header only code |
| CDGtal::STBWriter< TImageContainer, TFunctor > | Aim: Image Writer using the stb_image.h header only code |
| 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::BoundedLatticePolytope< TSpace >::StrictUnitCell | |
| CDGtal::BoundedLatticePolytope< TSpace >::StrictUnitSegment | |
| Cstring | STL class |
| 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::SurfaceMesh< TRealPoint, TRealVector > | Aim: Represents an embedded mesh as faces and a list of vertices. Vertices may be shared among faces but no specific topology is required. However, you also have methods to navigate between neighbor vertices, faces, etc. The mesh can be equipped with normals at faces and/or vertices |
| CDGtal::SurfaceMeshHelper< TRealPoint, TRealVector > | Aim: An helper class for building classical meshes |
| CDGtal::SurfaceMeshMeasure< TRealPoint, TRealVector, TValue > | Aim: stores an arbitrary measure on a SurfaceMesh object. The measure can be spread onto its vertices, edges, or faces. This class is notably used by CorrectedNormalCurrentComputer and NormalCycleComputer to store the curvature measures, which may be located on different cells. The measure can be scalar or any other summable type (see template parameter TValue) |
| CDGtal::SurfaceMeshReader< TRealPoint, TRealVector > | Aim: An helper class for reading mesh files (Wavefront OBJ at this point) and creating a SurfaceMesh |
| CDGtal::SurfaceMeshWriter< TRealPoint, TRealVector > | Aim: An helper class for writing mesh file formats (Waverfront OBJ at this point) and creating a SurfaceMesh |
| CDGtal::Surfaces< TKSpace > | Aim: A utility class for constructing surfaces (i.e. set of (n-1)-cells) |
| Csurfel_position | |
| Csurfel_position_t | |
| 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::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::functors::SurfelSetPredicate< TSurfelSet, TSurfel > | Aim: The predicate returning true iff the point is in the domain given at construction |
| CDGtal::SVOReader< Space > | Class to read SVO file |
| CDGtal::SVOWriter< Space > | Helper class to write an octree to a file using SVO file format |
| Cboost_concepts::SwappableIteratorConcept< Iterator > | Go to http://www.boost.org/doc/libs/1_52_0/libs/iterator/doc/SwappableIterator.html |
| CDGtal::SymmetricConvexExpander< TKSpace, TPointPredicate > | Aim: SymmetricConvexExpander computes symmetric fully convex subsets of a given digital set |
| 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::TangencyComputer< TKSpace > | Aim: A class that computes tangency to a given digital set. It provides services to compute all the cotangent points to a given point, or to compute shortest paths |
| 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::TangentFromDSS3DBy2DFunctor | |
| CDGtal::TangentFromDSS3DFunctor< DSS, LambdaFunction > | |
| CDGtal::detail::TangentVectorFromDCA | |
| CDGtal::detail::TangentVectorFromDSS< DSS > | |
| CDGtal::Clone< T >::TempPtr | Internal 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 |
| CtestDigitalSetToCellularGridConverter | |
| CTestFixture | |
| CTestImage< N > | |
| CtestLambdaMST2D | |
| CtestLambdaMST3D | |
| CTestPlaneProbingParallelepipedEstimator< Integer, mode > | |
| CTestPlaneProbingTetrahedronEstimator< Integer, mode > | |
| CtestRigidTransformation2D | |
| CtestRigidTransformation3D | |
| CDGtal::functors::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 |
| CDGtal::functors::Thresholder< T, false, false > | |
| CDGtal::functors::Thresholder< T, false, true > | |
| CDGtal::functors::Thresholder< T, true, false > | |
| CDGtal::functors::Thresholder< T, true, true > | |
| 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 |
| CDGtal::TiledImage< TImageContainer, TImageFactory, TImageCacheReadPolicy, TImageCacheWritePolicy >::TiledIterator | |
| CDGtal::TimeStampMemoizer< TKey, TValue > | Aim: A generic class to store a given maximum number of pairs (key, value). The class tends to memorize pairs which are accessed more frequently than others. It is thus a memoizer, which is used to memorize the result of costly computations. The memoization principle is simple: a timestamp is attached to a pair (key,value). Each time a query is made, if the item was memoized, the result is returned while the timestamp of the item is updated. User can also add or update a value in the memoizer, which updates also its timestamp. After adding a pair (key,value), if the maximal number of items is reached, at least the oldest half (or a fraction) of the items are deleted, leaving space for storing new pairs (key,value) |
| CTMap | |
| CDGtal::STLMapToVertexMapAdapter< TMap > | Aim: This class adapts any map of the STL to match with the CVertexMap concept |
| CDGtal::detail::toCoordinateImpl< TInput, TOutput > | Aim: Define a simple functor that can cast a signed integer (possibly a DGtal::BigInteger) into another |
| CDGtal::detail::toCoordinateImpl< DGtal::BigInteger, DGtal::BigInteger > | |
| CDGtal::detail::toCoordinateImpl< DGtal::BigInteger, TOutput > | |
| 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 > | |
| CTool< Container, T > | |
| CTool< std::forward_list< int >, T > | |
| CDGtal::FrechetShortcut< TIterator, TInteger >::Tools | |
| CDGtal::detail::top_node | |
| CDGtal::Trace | Implementation of basic methods to trace out messages with indentation levels |
| CDGtal::TraceWriter | Virtual Class to implement trace writers |
| CDGtal::TraceWriterFile | |
| CDGtal::TraceWriterTerm | Implements trace prefix for color terminals |
| CDGtal::DigitalSetBoundary< TKSpace, TDigitalSet >::Tracker | |
| CDGtal::ExplicitDigitalSurface< TKSpace, TSurfelPredicate >::Tracker | |
| CDGtal::ImplicitDigitalSurface< TKSpace, TPointPredicate >::Tracker | |
| CDGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >::Tracker | |
| CDGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >::Tracker | |
| CDGtal::SetOfSurfels< TKSpace, TSurfelSet >::Tracker | |
| CDGtal::ChordGenericStandardPlaneComputer< TSpace, TInputPoint, TInternalScalar >::Transform | |
| CDGtal::COBAGenericStandardPlaneComputer< TSpace, TInternalInteger >::Transform | |
| CLibBoard::Transform | Base class for transforms |
| CLibBoard::TransformCairo | Structure representing a scaling and translation suitable for an Cairo output |
| CLibBoard::TransformEPS | Structure representing a scaling and translation suitable for an EPS output |
| CLibBoard::TransformFIG | Structure representing a scaling and translation suitable for an XFig output |
| CLibBoard::TransformSVG | Structure representing a scaling and translation suitable for an SVG output |
| CLibBoard::TransformTikZ | Structure representing a scaling and translation suitable for an TikZ output |
| Cboost::transform_iterator | |
| CDGtal::IteratorAdapter< TIterator, TFunctor, TReturnType > | |
| CDGtal::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 |
| CDGtal::DigitalSetByOctree< Space >::TraversalMemory | Helper struct to store traversal and go to next leaf |
| CDGtal::HalfEdgeDataStructure::Triangle | Represents an unoriented triangle as three vertices |
| CTriangleByClone | |
| CTriangleByCloneAndCow | |
| CTriangleByConstReference | |
| CTriangleByValue | |
| CTriangleContext | |
| CDGtal::TriangulatedSurface< TPoint > | Aim: Represents a triangulated surface. The topology is stored with a half-edge data structure. This object stored the positions of vertices in space. If you need further data attached to the surface, you may use property maps (see TriangulatedSurface::makeVertexMap) |
| CTriple< T1, T2, T3 > | |
| Cstd::true_type | |
| CDGtal::IsAPointVector< PointVector< dim, TEuclideanRing, TContainer > > | Specialization of IsAPointVector for a PointVector |
| CDGtal::IsArithmeticConversionValid< T, U, typename std::conditional< false, ArithmeticConversionType< T, U >, void >::type > | Specialization when arithmetic operation between the two given type is valid |
| CDGtal::Shortcuts< TKSpace >::is_double_nested_container< C< D< T > > > | |
| 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 associated to a parametric shape or to a subrange 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::functors::Trunc< T > | Functor that rounds towards zero |
| CDGtal::functors::Trunc< void > | Functor that rounds towards zero |
| 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::BLUELocalLengthEstimator< TConstIterator > | Aim: Best Linear Unbiased Two step length estimator |
| CDGtal::RosenProffittLocalLengthEstimator< TConstIterator > | Aim: Rosen-Proffitt Length Estimator |
| CDGtal::UmbrellaComputer< TDigitalSurfaceTracker > | Aim: Useful for computing umbrellas on 'DigitalSurface's, ie set of n-1 cells around a n-3 cell |
| Cboost::UnaryFunction< Func, Return, Arg > | Go to http://www.sgi.com/tech/stl/UnaryFunction.html |
| CUnaryFunctor | |
| CDGtal::functors::UnaryMinus< T > | |
| 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 |
| CDGtal::BoundedLatticePolytope< TSpace >::UnitCell | |
| CDGtal::BoundedRationalPolytope< TSpace >::UnitCell | |
| CDGtal::BoundedLatticePolytope< TSpace >::UnitSegment | |
| CDGtal::BoundedRationalPolytope< TSpace >::UnitSegment | |
| CUnorderedPointSetPredicate | |
| CDGtal::UnorderedSetByBlock< Key, TSplitter, Hash, KeyEqual, UnorderedMapAllocator > | |
| Cboost::UnsignedInteger< T > | Go to http://www.boost.org/libs/concept_check/reference.htm |
| CDGtal::PlaneProbingNeighborhood< TPredicate >::UpdateOperation | |
| CDGtal::TangentFromDSS2DFunctor< DSS, LambdaFunction >::Value | |
| CDGtal::TangentFromDSS3DFunctor< DSS, LambdaFunction >::Value | |
| CDGtal::LabelledMap< TData, L, TWord, N, M >::ValueCompare | Value comparator class. Always natural ordering between keys |
| CDGtal::detail::ValueConverter< X, Y > | Generic definition of a class for converting type X toward type Y |
| CDGtal::detail::ValueConverter< std::string, double > | Specialized definitions of a class for converting type X toward type Y |
| CDGtal::detail::ValueConverter< std::string, float > | Specialized definitions of a class for converting type X toward type Y |
| CDGtal::detail::ValueConverter< std::string, int > | Specialized definitions of a class for converting type X toward type Y |
| CDGtal::detail::ValueConverter< X, std::string > | Specialized definitions of a class for converting type X toward type Y |
| CDGtal::AngleLinearMinimizer::ValueInfo | |
| CDGtal::IndexedListWithBlocks< TValue, N, M >::ValueOrBlockPointer | Used in blocks to finish it or to point to the next block |
| CDGtal::Shortcuts< TKSpace >::ValueReader< Value > | |
| CValueToTag< V > | Transform a boolean value to the corresponding DGtal tag |
| CValueToTag< false > | |
| CValueToTag< true > | |
| CDGtal::Shortcuts< TKSpace >::ValueWriter< Value > | |
| 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::ImageContainerBySTLVector< Domain, Storage * > | |
| CDGtal::ImageContainerBySTLVector< Domain, bool > | |
| CDGtal::ImageContainerBySTLVector< Domain, GrayScale > | |
| CDGtal::ImageContainerBySTLVector< Domain, float > | |
| CDGtal::ImageContainerBySTLVector< Domain, double > | |
| CDGtal::ImageContainerBySTLVector< Domain, Value > | |
| CDGtal::ImageContainerBySTLVector< Z2i::Domain, DGtal::int32_t > | |
| CDGtal::ImageContainerBySTLVector< Z3i::Domain, double > | |
| CDGtal::ImageContainerBySTLVector< HyperRectDomain< Z2i::Space >, std::unordered_set< Z2i::Point > > | |
| CDGtal::ImageContainerBySTLVector< Z2i::Domain, int > | |
| CDGtal::ImageContainerBySTLVector< TDomain, TValue > | |
| 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 |
| CDGtal::functors::VectorRounding< TRealVector, TVector > | |
| CDGtal::VectorsInHeat< TPolygonalCalculus > | This class implements [110] on polygonal surfaces (using Discrete differential calculus on polygonal surfaces) |
| Cvertex_list_graph_tag | |
| Cboost::DigitalSurface_graph_traversal_category | |
| Cboost::Object_graph_traversal_category | |
| Cvertex_position | |
| Cvertex_position_t | |
| CDGtal::GraphVisitorRange< TGraphVisitor >::VertexAccessor | |
| Cboost::VertexListGraphConcept< G > | Go to http://www.boost.org/doc/libs/1_52_0/libs/graph/doc/VertexListGraph.html |
| CDGtal::concepts::CUndirectedSimpleLocalGraph< T >::VertexMap< Value > | |
| CDGtal::DigitalSurface< TDigitalSurfaceContainer >::VertexMap< Value > | |
| CDGtal::DomainAdjacency< TDomain, TAdjacency >::VertexMap< Value > | |
| CDGtal::IndexedDigitalSurface< TDigitalSurfaceContainer >::VertexMap< Value > | |
| CDGtal::LightExplicitDigitalSurface< TKSpace, TSurfelPredicate >::VertexMap< Value > | |
| CDGtal::LightImplicitDigitalSurface< TKSpace, TPointPredicate >::VertexMap< Value > | |
| CDGtal::MetricAdjacency< TSpace, maxNorm1, dimension >::VertexMap< Value > | |
| CDGtal::Object< TDigitalTopology, TDigitalSet >::VertexMap< Value > | |
| CDGtal::PolygonalSurface< TPoint >::VertexMap< Value > | |
| CDGtal::SurfaceMesh< TRealPoint, TRealVector >::VertexMap< Value > | |
| CDGtal::TriangulatedSurface< TPoint >::VertexMap< Value > | |
| CVertexSize | |
| 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::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::DistanceTransformation< TSpace, TPointPredicate, TSeparableMetric, TImageContainer > | Aim: Implementation of the linear in time distance transformation for separable metrics |
| CDGtal::VoronoiMapComplete< TSpace, TPointPredicate, TSeparableMetric, TImageContainer > | Aim: Implementation of the linear in time Voronoi map construction |
| CDGtal::Warning_promote_trait_not_specialized_for_this_case | |
| CDGtal::WindingNumbersShape< TSpace > | Aim: model of a CEuclideanOrientedShape from an implicit function from an oriented point cloud. The implicit function is given by the generalized winding number of the oriented point cloud [8] . We use the libIGL implementation |
| CDGtal::WithQuantity< T, Type > | Attach a property to an element |
| 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 | |
1.18.0