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