DGtal 1.3.0
Loading...
Searching...
No Matches
Public Types | Static Public Member Functions | Private Member Functions
DGtal::ShortcutsGeometry< TKSpace > Class Template Reference

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. More...

#include <DGtal/helpers/ShortcutsGeometry.h>

Inheritance diagram for DGtal::ShortcutsGeometry< TKSpace >:
DGtal::Shortcuts< TKSpace >

Public Types

typedef Shortcuts< TKSpace > Base
 
typedef ShortcutsGeometry< TKSpace > Self
 
typedef TKSpace KSpace
 Digital cellular space. More...
 
typedef KSpace::Space Space
 Digital space. More...
 
typedef Space::Integer Integer
 Integer numbers. More...
 
typedef Space::Point Point
 Point with integer coordinates. More...
 
typedef Space::Vector Vector
 Vector with integer coordinates. More...
 
typedef Space::RealVector RealVector
 Vector with floating-point coordinates. More...
 
typedef Space::RealPoint RealPoint
 Point with floating-point coordinates. More...
 
typedef RealVector::Component Scalar
 Floating-point numbers. More...
 
typedef HyperRectDomain< SpaceDomain
 An (hyper-)rectangular domain. More...
 
typedef unsigned char GrayScale
 The type for 8-bits gray-scale elements. More...
 
typedef MPolynomial< Space::dimension, ScalarScalarPolynomial
 defines a multi-variate polynomial : RealPoint -> Scalar More...
 
typedef ImplicitPolynomial3Shape< SpaceImplicitShape3D
 
typedef GaussDigitizer< Space, ImplicitShape3DDigitizedImplicitShape3D
 defines the digitization of an implicit shape. More...
 
typedef ImageContainerBySTLVector< Domain, bool > BinaryImage
 defines a black and white image with (hyper-)rectangular domain. More...
 
typedef ImageContainerBySTLVector< Domain, GrayScaleGrayScaleImage
 defines a grey-level image with (hyper-)rectangular domain. More...
 
typedef ImageContainerBySTLVector< Domain, float > FloatImage
 defines a float image with (hyper-)rectangular domain. More...
 
typedef ImageContainerBySTLVector< Domain, double > DoubleImage
 defines a double image with (hyper-)rectangular domain. More...
 
typedef KSpace::SurfelSet SurfelSet
 defines a set of surfels More...
 
typedef LightImplicitDigitalSurface< KSpace, BinaryImageLightSurfaceContainer
 
typedef ::DGtal::DigitalSurface< LightSurfaceContainerLightDigitalSurface
 defines a connected digital surface over a binary image. More...
 
typedef SetOfSurfels< KSpace, SurfelSetExplicitSurfaceContainer
 defines a heavy container that represents any digital surface. More...
 
typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainerDigitalSurface
 defines an arbitrary digital surface over a binary image. More...
 
typedef IndexedDigitalSurface< ExplicitSurfaceContainerIdxDigitalSurface
 defines a connected or not indexed digital surface. More...
 
typedef LightDigitalSurface::Surfel Surfel
 
typedef LightDigitalSurface::Cell Cell
 
typedef LightDigitalSurface::SCell SCell
 
typedef LightDigitalSurface::Vertex Vertex
 
typedef LightDigitalSurface::Arc Arc
 
typedef LightDigitalSurface::Face Face
 
typedef LightDigitalSurface::ArcRange ArcRange
 
typedef IdxDigitalSurface::Vertex IdxSurfel
 
typedef IdxDigitalSurface::Vertex IdxVertex
 
typedef IdxDigitalSurface::Arc IdxArc
 
typedef IdxDigitalSurface::ArcRange IdxArcRange
 
typedef std::set< IdxSurfelIdxSurfelSet
 
typedef std::vector< SurfelSurfelRange
 
typedef std::vector< CellCellRange
 
typedef std::vector< IdxSurfelIdxSurfelRange
 
typedef std::vector< ScalarScalars
 
typedef std::vector< RealVectorRealVectors
 
typedef std::vector< RealPointRealPoints
 
typedef ::DGtal::Statistic< ScalarScalarStatistic
 
typedef sgf::ShapePositionFunctor< ImplicitShape3DPositionFunctor
 
typedef sgf::ShapeNormalVectorFunctor< ImplicitShape3DNormalFunctor
 
typedef sgf::ShapeMeanCurvatureFunctor< ImplicitShape3DMeanCurvatureFunctor
 
typedef sgf::ShapeGaussianCurvatureFunctor< ImplicitShape3DGaussianCurvatureFunctor
 
typedef sgf::ShapeFirstPrincipalCurvatureFunctor< ImplicitShape3DFirstPrincipalCurvatureFunctor
 
typedef sgf::ShapeSecondPrincipalCurvatureFunctor< ImplicitShape3DSecondPrincipalCurvatureFunctor
 
typedef sgf::ShapeFirstPrincipalDirectionFunctor< ImplicitShape3DFirstPrincipalDirectionFunctor
 
typedef sgf::ShapeSecondPrincipalDirectionFunctor< ImplicitShape3DSecondPrincipalDirectionFunctor
 
typedef sgf::ShapePrincipalCurvaturesAndDirectionsFunctor< ImplicitShape3DPrincipalCurvaturesAndDirectionsFunctor
 
typedef functors::IIPrincipalCurvaturesAndDirectionsFunctor< Space >::Quantity CurvatureTensorQuantity
 
typedef std::vector< CurvatureTensorQuantityCurvatureTensorQuantities
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PositionFunctorTruePositionEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, NormalFunctorTrueNormalEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, MeanCurvatureFunctorTrueMeanCurvatureEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, GaussianCurvatureFunctorTrueGaussianCurvatureEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalCurvatureFunctorTrueFirstPrincipalCurvatureEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalCurvatureFunctorTrueSecondPrincipalCurvatureEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalDirectionFunctorTrueFirstPrincipalDirectionEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalDirectionFunctorTrueSecondPrincipalDirectionEstimator
 
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PrincipalCurvaturesAndDirectionsFunctorTruePrincipalCurvaturesAndDirectionsEstimator
 
typedef ::DGtal::Mesh< RealPointMesh
 
typedef ::DGtal::TriangulatedSurface< RealPointTriangulatedSurface
 
typedef ::DGtal::PolygonalSurface< RealPointPolygonalSurface
 
typedef std::map< Surfel, IdxSurfelSurfel2Index
 
typedef std::map< Cell, IdxVertexCell2Index
 
- Public Types inherited from DGtal::Shortcuts< TKSpace >
typedef TKSpace KSpace
 Digital cellular space. More...
 
typedef KSpace::Space Space
 Digital space. More...
 
typedef Space::Integer Integer
 Integer numbers. More...
 
typedef Space::Point Point
 Point with integer coordinates. More...
 
typedef Space::Vector Vector
 Vector with integer coordinates. More...
 
typedef Space::RealVector RealVector
 Vector with floating-point coordinates. More...
 
typedef Space::RealPoint RealPoint
 Point with floating-point coordinates. More...
 
typedef RealVector::Component Scalar
 Floating-point numbers. More...
 
typedef HyperRectDomain< SpaceDomain
 An (hyper-)rectangular domain. More...
 
typedef unsigned char GrayScale
 The type for 8-bits gray-scale elements. More...
 
typedef MPolynomial< Space::dimension, ScalarScalarPolynomial
 defines a multi-variate polynomial : RealPoint -> Scalar More...
 
typedef ImplicitPolynomial3Shape< SpaceImplicitShape3D
 
typedef GaussDigitizer< Space, ImplicitShape3DDigitizedImplicitShape3D
 defines the digitization of an implicit shape. More...
 
typedef ImageContainerBySTLVector< Domain, bool > BinaryImage
 defines a black and white image with (hyper-)rectangular domain. More...
 
typedef ImageContainerBySTLVector< Domain, GrayScaleGrayScaleImage
 defines a grey-level image with (hyper-)rectangular domain. More...
 
typedef ImageContainerBySTLVector< Domain, float > FloatImage
 defines a float image with (hyper-)rectangular domain. More...
 
typedef ImageContainerBySTLVector< Domain, double > DoubleImage
 defines a double image with (hyper-)rectangular domain. More...
 
typedef KSpace::SurfelSet SurfelSet
 defines a set of surfels More...
 
typedef LightImplicitDigitalSurface< KSpace, BinaryImageLightSurfaceContainer
 
typedef ::DGtal::DigitalSurface< LightSurfaceContainerLightDigitalSurface
 defines a connected digital surface over a binary image. More...
 
typedef SetOfSurfels< KSpace, SurfelSetExplicitSurfaceContainer
 defines a heavy container that represents any digital surface. More...
 
typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainerDigitalSurface
 defines an arbitrary digital surface over a binary image. More...
 
typedef IndexedDigitalSurface< ExplicitSurfaceContainerIdxDigitalSurface
 defines a connected or not indexed digital surface. More...
 
typedef LightDigitalSurface::Surfel Surfel
 
typedef LightDigitalSurface::Cell Cell
 
typedef LightDigitalSurface::SCell SCell
 
typedef LightDigitalSurface::Vertex Vertex
 
typedef LightDigitalSurface::Arc Arc
 
typedef LightDigitalSurface::Face Face
 
typedef LightDigitalSurface::ArcRange ArcRange
 
typedef IdxDigitalSurface::Vertex IdxSurfel
 
typedef IdxDigitalSurface::Vertex IdxVertex
 
typedef IdxDigitalSurface::Arc IdxArc
 
typedef IdxDigitalSurface::ArcRange IdxArcRange
 
typedef std::set< IdxSurfelIdxSurfelSet
 
typedef std::vector< SCellSCellRange
 
typedef std::vector< CellCellRange
 
typedef CellRange PointelRange
 
typedef SCellRange SurfelRange
 
typedef std::vector< IdxSurfelIdxSurfelRange
 
typedef std::vector< ScalarScalars
 
typedef std::vector< RealVectorRealVectors
 
typedef std::vector< RealPointRealPoints
 
typedef IdxVertex Idx
 
typedef std::vector< IdxVertexIdxRange
 
typedef ::DGtal::Mesh< RealPointMesh
 
typedef ::DGtal::TriangulatedSurface< RealPointTriangulatedSurface
 
typedef ::DGtal::PolygonalSurface< RealPointPolygonalSurface
 
typedef ::DGtal::SurfaceMesh< RealPoint, RealPointSurfaceMesh
 
typedef std::map< Surfel, IdxSurfelSurfel2Index
 
typedef std::map< Cell, IdxVertexCell2Index
 
typedef ::DGtal::Color Color
 
typedef std::vector< ColorColors
 
typedef GradientColorMap< ScalarColorMap
 
typedef TickedColorMap< Scalar, ColorMapZeroTickedColorMap
 

Public Member Functions

Standard services
 ShortcutsGeometry ()=delete
 
 ~ShortcutsGeometry ()=delete
 
 ShortcutsGeometry (const ShortcutsGeometry &other)=delete
 
 ShortcutsGeometry (ShortcutsGeometry &&other)=delete
 
ShortcutsGeometryoperator= (const ShortcutsGeometry &other)=delete
 
ShortcutsGeometryoperator= (ShortcutsGeometry &&other)=delete
 
- Public Member Functions inherited from DGtal::Shortcuts< TKSpace >
 Shortcuts ()=delete
 
 ~Shortcuts ()=delete
 
 Shortcuts (const Shortcuts &other)=delete
 
 Shortcuts (Shortcuts &&other)=delete
 
Shortcutsoperator= (const Shortcuts &other)=delete
 
Shortcutsoperator= (Shortcuts &&other)=delete
 
void selfDisplay (std::ostream &out) const
 
bool isValid () const
 

Static Public Member Functions

static Parameters parametersKSpace ()
 
static KSpace getKSpace (const Point &low, const Point &up, Parameters params=parametersKSpace())
 
static KSpace getKSpace (CountedPtr< BinaryImage > bimage, Parameters params=parametersKSpace())
 
static KSpace getKSpace (CountedPtr< GrayScaleImage > gimage, Parameters params=parametersKSpace())
 
template<typename TDigitalSurfaceContainer >
static KSpace getKSpace (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static KSpace getKSpace (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)
 
static KSpace getKSpace (Parameters params=parametersKSpace()|parametersDigitizedImplicitShape3D())
 
static Parameters parametersDigitizedImplicitShape3D ()
 
Exact geometry services
static Parameters defaultParameters ()
 
static Parameters parametersShapeGeometry ()
 
static RealPoints getPositions (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static RealPoints getPositions (CountedPtr< ImplicitShape3D > shape, const RealPoints &points, const Parameters &params=parametersShapeGeometry())
 
static RealVectors getNormalVectors (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static Scalars getMeanCurvatures (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static Scalars getGaussianCurvatures (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static Scalars getFirstPrincipalCurvatures (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static Scalars getSecondPrincipalCurvatures (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static RealVectors getFirstPrincipalDirections (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static RealVectors getSecondPrincipalDirections (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
static CurvatureTensorQuantities getPrincipalCurvaturesAndDirections (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
 
Geometry estimation services
static Parameters parametersGeometryEstimation ()
 
static RealVectors getTrivialNormalVectors (const KSpace &K, const SurfelRange &surfels)
 
template<typename TAnyDigitalSurface >
static RealVectors getCTrivialNormalVectors (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation())
 
template<typename TAnyDigitalSurface >
static RealVectors getVCMNormalVectors (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation())
 
static RealVectors getIINormalVectors (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static RealVectors getIINormalVectors (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
 
template<typename TPointPredicate >
static RealVectors getIINormalVectors (const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static Scalars getIIMeanCurvatures (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static Scalars getIIMeanCurvatures (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
 
template<typename TPointPredicate >
static Scalars getIIMeanCurvatures (const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static Scalars getIIGaussianCurvatures (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static Scalars getIIGaussianCurvatures (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
 
template<typename TPointPredicate >
static Scalars getIIGaussianCurvatures (const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
 
template<typename TPointPredicate >
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections (const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
 
AT approximation services
static Parameters parametersATApproximation ()
 
template<typename TAnyDigitalSurface , typename VectorFieldInput >
static VectorFieldInput getATVectorFieldApproximation (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const VectorFieldInput &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
 
template<typename TAnyDigitalSurface , typename VectorFieldInput , typename CellRangeConstIterator >
static VectorFieldInput getATVectorFieldApproximation (Scalars &features, CellRangeConstIterator itB, CellRangeConstIterator itE, CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const VectorFieldInput &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
 
template<typename TAnyDigitalSurface >
static Scalars getATScalarFieldApproximation (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Scalars &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
 
template<typename TAnyDigitalSurface , typename CellRangeConstIterator >
static Scalars getATScalarFieldApproximation (Scalars &features, CellRangeConstIterator itB, CellRangeConstIterator itE, CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Scalars &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
 
Error measure services
static void orientVectors (RealVectors &v, const RealVectors &ref_v)
 
static ScalarStatistic getStatistic (const Scalars &v)
 
static Scalars getVectorsAngleDeviation (const RealVectors &v1, const RealVectors &v2)
 
static Scalars getScalarsAbsoluteDifference (const Scalars &v1, const Scalars &v2)
 
static Scalar getScalarsNormL2 (const Scalars &v1, const Scalars &v2)
 
static Scalar getScalarsNormL1 (const Scalars &v1, const Scalars &v2)
 
static Scalar getScalarsNormLoo (const Scalars &v1, const Scalars &v2)
 
- Static Public Member Functions inherited from DGtal::Shortcuts< TKSpace >
static Parameters defaultParameters ()
 
static std::map< std::string, std::string > getPolynomialList ()
 
static Parameters parametersImplicitShape3D ()
 
static CountedPtr< ImplicitShape3DmakeImplicitShape3D (const Parameters &params=parametersImplicitShape3D())
 
static Parameters parametersKSpace ()
 
static KSpace getKSpace (const Point &low, const Point &up, Parameters params=parametersKSpace())
 
static KSpace getKSpace (CountedPtr< BinaryImage > bimage, Parameters params=parametersKSpace())
 
static KSpace getKSpace (CountedPtr< GrayScaleImage > gimage, Parameters params=parametersKSpace())
 
template<typename TDigitalSurfaceContainer >
static KSpace getKSpace (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static KSpace getKSpace (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static const KSpacerefKSpace (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static const KSpacerefKSpace (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)
 
static CanonicCellEmbedder< KSpacegetCellEmbedder (const KSpace &K)
 
static CanonicSCellEmbedder< KSpacegetSCellEmbedder (const KSpace &K)
 
static Parameters parametersDigitizedImplicitShape3D ()
 
static KSpace getKSpace (Parameters params=parametersKSpace()|parametersDigitizedImplicitShape3D())
 
static CountedPtr< DigitizedImplicitShape3DmakeDigitizedImplicitShape3D (CountedPtr< ImplicitShape3D > shape, Parameters params=parametersDigitizedImplicitShape3D())
 
static Parameters parametersBinaryImage ()
 
static CountedPtr< BinaryImagemakeBinaryImage (Domain shapeDomain)
 
static CountedPtr< BinaryImagemakeBinaryImage (CountedPtr< DigitizedImplicitShape3D > shape_digitization, Parameters params=parametersBinaryImage())
 
static CountedPtr< BinaryImagemakeBinaryImage (CountedPtr< DigitizedImplicitShape3D > shape_digitization, Domain shapeDomain, Parameters params=parametersBinaryImage())
 
static CountedPtr< BinaryImagemakeBinaryImage (CountedPtr< BinaryImage > bimage, Parameters params=parametersBinaryImage())
 
static CountedPtr< BinaryImagemakeBinaryImage (std::string input, Parameters params=parametersBinaryImage())
 
static CountedPtr< BinaryImagemakeBinaryImage (CountedPtr< GrayScaleImage > gray_scale_image, Parameters params=parametersBinaryImage())
 
static bool saveBinaryImage (CountedPtr< BinaryImage > bimage, std::string output)
 
static Parameters parametersGrayScaleImage ()
 
static CountedPtr< GrayScaleImagemakeGrayScaleImage (Domain aDomain)
 
static CountedPtr< GrayScaleImagemakeGrayScaleImage (std::string input)
 
static CountedPtr< GrayScaleImagemakeGrayScaleImage (CountedPtr< BinaryImage > binary_image, std::function< GrayScale(bool) > const &bool2grayscale=[](bool v) { return v ?(unsigned char) 255 :(unsigned char) 0;})
 
static bool saveGrayScaleImage (CountedPtr< GrayScaleImage > gray_scale_image, std::string output)
 
static CountedPtr< GrayScaleImagemakeGrayScaleImage (CountedPtr< FloatImage > fimage, Parameters params=parametersGrayScaleImage())
 
static CountedPtr< GrayScaleImagemakeGrayScaleImage (CountedPtr< DoubleImage > fimage, Parameters params=parametersGrayScaleImage())
 
static CountedPtr< FloatImagemakeFloatImage (Domain aDomain)
 
static CountedPtr< FloatImagemakeFloatImage (std::string input)
 
static CountedPtr< FloatImagemakeFloatImage (CountedPtr< ImplicitShape3D > shape, Parameters params=parametersDigitizedImplicitShape3D())
 
static CountedPtr< DoubleImagemakeDoubleImage (Domain aDomain)
 
static CountedPtr< DoubleImagemakeDoubleImage (std::string input)
 
static CountedPtr< DoubleImagemakeDoubleImage (CountedPtr< ImplicitShape3D > shape, Parameters params=parametersDigitizedImplicitShape3D())
 
static Parameters parametersDigitalSurface ()
 
template<typename TDigitalSurfaceContainer >
static CanonicCellEmbedder< KSpacegetCellEmbedder (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static CanonicSCellEmbedder< KSpacegetSCellEmbedder (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static CanonicCellEmbedder< KSpacegetCellEmbedder (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static CanonicSCellEmbedder< KSpacegetSCellEmbedder (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)
 
static CountedPtr< LightDigitalSurfacemakeLightDigitalSurface (CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())
 
static std::vector< CountedPtr< LightDigitalSurface > > makeLightDigitalSurfaces (CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())
 
static std::vector< CountedPtr< LightDigitalSurface > > makeLightDigitalSurfaces (SurfelRange &surfel_reps, CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())
 
template<typename TPointPredicate >
static CountedPtr< DigitalSurfacemakeDigitalSurface (CountedPtr< TPointPredicate > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())
 
static CountedPtr< DigitalSurfacemakeDigitalSurface (CountedPtr< IdxDigitalSurface > idx_surface, const Parameters &params=parametersDigitalSurface())
 
static CountedPtr< IdxDigitalSurfacemakeIdxDigitalSurface (CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())
 
template<typename TSurfelRange >
static CountedPtr< IdxDigitalSurfacemakeIdxDigitalSurface (const TSurfelRange &surfels, ConstAlias< KSpace > K, const Parameters &params=parametersDigitalSurface())
 
template<typename TDigitalSurfaceContainer >
static CountedPtr< IdxDigitalSurfacemakeIdxDigitalSurface (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Parameters &params=parametersDigitalSurface())
 
static CountedPtr< IdxDigitalSurfacemakeIdxDigitalSurface (const std::vector< CountedPtr< LightDigitalSurface > > &surfaces, const Parameters &params=parametersDigitalSurface())
 
template<typename TDigitalSurfaceContainer >
static CellRange getCellRange (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Dimension k)
 
template<typename TDigitalSurfaceContainer >
static PointelRange getCellRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Dimension k)
 
template<typename TDigitalSurfaceContainer >
static PointelRange getPointelRange (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
template<typename TDigitalSurfaceContainer >
static PointelRange getPointelRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)
 
static PointelRange getPointelRange (const KSpace &K, const SCell &surfel)
 
template<typename TDigitalSurfaceContainer >
static SurfelRange getSurfelRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Parameters &params=parametersDigitalSurface())
 
template<typename TDigitalSurfaceContainer >
static SurfelRange getSurfelRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Surfel &start_surfel, const Parameters &params=parametersDigitalSurface())
 
static IdxSurfelRange getIdxSurfelRange (CountedPtr< IdxDigitalSurface > surface, const Parameters &params=parametersDigitalSurface())
 
static IdxSurfelRange getIdxSurfelRange (CountedPtr< IdxDigitalSurface > surface, const IdxSurfel &start_surfel, const Parameters &params=parametersDigitalSurface())
 
template<typename TDigitalSurfaceContainer , typename TCellEmbedder >
static bool saveOFF (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, const TCellEmbedder &embedder, std::string off_file, const Color &face_color=DGtal::Color::None)
 
template<typename TDigitalSurfaceContainer , typename TCellEmbedder >
static bool saveOBJ (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, const TCellEmbedder &embedder, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)
 
template<typename TDigitalSurfaceContainer >
static bool saveOBJ (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)
 
template<typename TDigitalSurfaceContainer >
static bool saveOFF (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, std::string off_file, const Color &face_color=Color(32, 32, 32))
 
template<typename TDigitalSurfaceContainer >
static bool saveOBJ (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)
 
static bool saveVectorFieldOBJ (const RealPoints &positions, const RealVectors &vf, double thickness, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)
 
static Parameters parametersMesh ()
 
static CountedPtr< TriangulatedSurfacemakeTriangulatedSurface (CountedPtr< Mesh > aMesh)
 
static CountedPtr< MeshmakeMesh (CountedPtr< TriangulatedSurface > triSurf, const Color &aColor=Color::White)
 
static CountedPtr< MeshmakeMesh (CountedPtr< PolygonalSurface > polySurf, const Color &aColor=Color::White)
 
template<typename TContainer >
static CountedPtr< TriangulatedSurfacemakeTriangulatedSurface (Surfel2Index &s2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< TriangulatedSurfacemakeTriangulatedSurface (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
static CountedPtr< TriangulatedSurfacemakeTriangulatedSurface (CountedPtr< PolygonalSurface > polySurf, const Parameters &params=parametersMesh())
 
static CountedPtr< PolygonalSurfacemakePolygonalSurface (CountedPtr< Mesh > aMesh)
 
static CountedPtr< PolygonalSurfacemakePolygonalSurface (CountedPtr< GrayScaleImage > gray_scale_image, const Parameters &params=parametersKSpace()|parametersBinaryImage()|parametersDigitalSurface())
 
static CountedPtr< TriangulatedSurfacemakeTriangulatedSurface (CountedPtr< GrayScaleImage > gray_scale_image, const Parameters &params=parametersKSpace()|parametersBinaryImage()|parametersDigitalSurface())
 
template<typename TContainer >
static CountedPtr< PolygonalSurfacemakeDualPolygonalSurface (Surfel2Index &s2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< PolygonalSurfacemakeDualPolygonalSurface (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< PolygonalSurfacemakeDualPolygonalSurface (CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< PolygonalSurfacemakePrimalPolygonalSurface (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< PolygonalSurfacemakePrimalPolygonalSurface (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< PolygonalSurfacemakePrimalPolygonalSurface (CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< SurfaceMeshmakePrimalSurfaceMesh (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< SurfaceMeshmakePrimalSurfaceMesh (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
 
template<typename TContainer >
static CountedPtr< SurfaceMeshmakePrimalSurfaceMesh (CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface)
 
template<typename TPoint >
static bool saveOBJ (CountedPtr< ::DGtal::PolygonalSurface< TPoint > > polysurf, const std::string &objfile)
 
template<typename TPoint >
static bool saveOFF (CountedPtr< ::DGtal::PolygonalSurface< TPoint > > polysurf, std::string off_file, const Color &face_color=DGtal::Color::None)
 
template<typename TPoint >
static bool saveOBJ (CountedPtr< ::DGtal::TriangulatedSurface< TPoint > > trisurf, const std::string &objfile)
 
template<typename TPoint >
static bool saveOBJ (CountedPtr< ::DGtal::PolygonalSurface< TPoint > > polysurf, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)
 
template<typename TPoint >
static bool saveOBJ (CountedPtr< ::DGtal::TriangulatedSurface< TPoint > > trisurf, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)
 
template<typename TPoint >
static bool saveOFF (CountedPtr< ::DGtal::TriangulatedSurface< TPoint > > trisurf, std::string off_file, const Color &face_color=DGtal::Color::None)
 
static Parameters parametersUtilities ()
 
template<typename TValue >
static IdxRange getRangeMatch (const std::vector< TValue > &s1, const std::vector< TValue > &s2, bool perfect=false)
 
template<typename TValue >
static std::vector< TValue > getMatchedRange (const std::vector< TValue > &range, const IdxRange &match)
 
static ColorMap getColorMap (Scalar min, Scalar max, const Parameters &params=parametersUtilities())
 
static ZeroTickedColorMap getZeroTickedColorMap (Scalar min, Scalar max, const Parameters &params=parametersUtilities())
 
template<typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool outputSurfelsAsObj (std::ostream &output, const SurfelRange &surfels, const TCellEmbedder &embedder)
 
template<typename TAnyDigitalSurface >
static bool outputPrimalDigitalSurfaceAsObj (std::ostream &output, CountedPtr< TAnyDigitalSurface > surface)
 
template<typename TAnyDigitalSurface , typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool outputPrimalDigitalSurfaceAsObj (std::ostream &output, CountedPtr< TAnyDigitalSurface > surface, const TCellEmbedder &embedder)
 
static bool outputPrimalIdxDigitalSurfaceAsObj (std::ostream &output, CountedPtr< IdxDigitalSurface > surface)
 
template<typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool outputPrimalIdxDigitalSurfaceAsObj (std::ostream &output, CountedPtr< IdxDigitalSurface > surface, const TCellEmbedder &embedder)
 
template<typename TDigitalSurfaceContainer >
static bool outputDualDigitalSurfaceAsObj (std::ostream &output, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Parameters &params=parametersMesh())
 
template<typename TDigitalSurfaceContainer , typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool outputDualDigitalSurfaceAsObj (std::ostream &output, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const TCellEmbedder &embedder, const Parameters &params=parametersMesh())
 
template<typename TSCellMap , typename TValueWriter >
static bool outputSCellMapAsCSV (std::ostream &output, const KSpace &K, const TSCellMap &anyMap, const TValueWriter &writer)
 
template<typename TCellMap , typename TValueWriter >
static bool outputCellMapAsCSV (std::ostream &output, const KSpace &K, const TCellMap &anyMap, const TValueWriter &writer)
 
static CellRange getPrimalCells (const KSpace &K, const SCell &s, const Dimension k)
 
static CellRange getPrimalVertices (const KSpace &K, const SCell &s)
 
static CellRange getPrimalVertices (const KSpace &K, const Surfel &s, bool ccw)
 

Private Member Functions

 BOOST_CONCEPT_ASSERT ((concepts::CCellularGridSpaceND< TKSpace >))
 

Detailed Description

template<typename TKSpace>
class DGtal::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.

Description of template class 'ShortcutsGeometry'

Template Parameters
TKSpaceany cellular grid space, a model of concepts::CCellularGridSpaceND like KhalimskySpaceND.
Examples
geometry/meshes/curvature-comparator-ii-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-XY-3d.cpp, geometry/meshes/vol-curvature-measures-icnc-3d.cpp, and geometry/meshes/vol-curvature-measures-icnc-XY-3d.cpp.

Definition at line 76 of file ShortcutsGeometry.h.

Member Typedef Documentation

◆ Arc

template<typename TKSpace >
typedef LightDigitalSurface::Arc DGtal::ShortcutsGeometry< TKSpace >::Arc

Definition at line 144 of file ShortcutsGeometry.h.

◆ ArcRange

template<typename TKSpace >
typedef LightDigitalSurface::ArcRange DGtal::ShortcutsGeometry< TKSpace >::ArcRange

Definition at line 146 of file ShortcutsGeometry.h.

◆ Base

template<typename TKSpace >
typedef Shortcuts< TKSpace > DGtal::ShortcutsGeometry< TKSpace >::Base

Definition at line 80 of file ShortcutsGeometry.h.

◆ BinaryImage

template<typename TKSpace >
typedef ImageContainerBySTLVector<Domain, bool> DGtal::ShortcutsGeometry< TKSpace >::BinaryImage

defines a black and white image with (hyper-)rectangular domain.

Definition at line 120 of file ShortcutsGeometry.h.

◆ Cell

template<typename TKSpace >
typedef LightDigitalSurface::Cell DGtal::ShortcutsGeometry< TKSpace >::Cell

Definition at line 141 of file ShortcutsGeometry.h.

◆ Cell2Index

template<typename TKSpace >
typedef std::map<Cell, IdxVertex> DGtal::ShortcutsGeometry< TKSpace >::Cell2Index

Definition at line 198 of file ShortcutsGeometry.h.

◆ CellRange

template<typename TKSpace >
typedef std::vector< Cell > DGtal::ShortcutsGeometry< TKSpace >::CellRange

Definition at line 153 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantities

template<typename TKSpace >
typedef std::vector< CurvatureTensorQuantity > DGtal::ShortcutsGeometry< TKSpace >::CurvatureTensorQuantities

Definition at line 172 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantity

template<typename TKSpace >
typedef functors::IIPrincipalCurvaturesAndDirectionsFunctor<Space>::Quantity DGtal::ShortcutsGeometry< TKSpace >::CurvatureTensorQuantity

Definition at line 171 of file ShortcutsGeometry.h.

◆ DigitalSurface

template<typename TKSpace >
typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainer > DGtal::ShortcutsGeometry< TKSpace >::DigitalSurface

defines an arbitrary digital surface over a binary image.

Definition at line 137 of file ShortcutsGeometry.h.

◆ DigitizedImplicitShape3D

template<typename TKSpace >
typedef GaussDigitizer< Space, ImplicitShape3D > DGtal::ShortcutsGeometry< TKSpace >::DigitizedImplicitShape3D

defines the digitization of an implicit shape.

Definition at line 118 of file ShortcutsGeometry.h.

◆ Domain

template<typename TKSpace >
typedef HyperRectDomain<Space> DGtal::ShortcutsGeometry< TKSpace >::Domain

An (hyper-)rectangular domain.

Definition at line 106 of file ShortcutsGeometry.h.

◆ DoubleImage

template<typename TKSpace >
typedef ImageContainerBySTLVector<Domain, double> DGtal::ShortcutsGeometry< TKSpace >::DoubleImage

defines a double image with (hyper-)rectangular domain.

Definition at line 126 of file ShortcutsGeometry.h.

◆ ExplicitSurfaceContainer

template<typename TKSpace >
typedef SetOfSurfels< KSpace, SurfelSet > DGtal::ShortcutsGeometry< TKSpace >::ExplicitSurfaceContainer

defines a heavy container that represents any digital surface.

Definition at line 135 of file ShortcutsGeometry.h.

◆ Face

template<typename TKSpace >
typedef LightDigitalSurface::Face DGtal::ShortcutsGeometry< TKSpace >::Face

Definition at line 145 of file ShortcutsGeometry.h.

◆ FirstPrincipalCurvatureFunctor

template<typename TKSpace >
typedef sgf::ShapeFirstPrincipalCurvatureFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::FirstPrincipalCurvatureFunctor

Definition at line 165 of file ShortcutsGeometry.h.

◆ FirstPrincipalDirectionFunctor

template<typename TKSpace >
typedef sgf::ShapeFirstPrincipalDirectionFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::FirstPrincipalDirectionFunctor

Definition at line 167 of file ShortcutsGeometry.h.

◆ FloatImage

template<typename TKSpace >
typedef ImageContainerBySTLVector<Domain, float> DGtal::ShortcutsGeometry< TKSpace >::FloatImage

defines a float image with (hyper-)rectangular domain.

Definition at line 124 of file ShortcutsGeometry.h.

◆ GaussianCurvatureFunctor

template<typename TKSpace >
typedef sgf::ShapeGaussianCurvatureFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::GaussianCurvatureFunctor

Definition at line 164 of file ShortcutsGeometry.h.

◆ GrayScale

template<typename TKSpace >
typedef unsigned char DGtal::ShortcutsGeometry< TKSpace >::GrayScale

The type for 8-bits gray-scale elements.

Definition at line 108 of file ShortcutsGeometry.h.

◆ GrayScaleImage

template<typename TKSpace >
typedef ImageContainerBySTLVector<Domain, GrayScale> DGtal::ShortcutsGeometry< TKSpace >::GrayScaleImage

defines a grey-level image with (hyper-)rectangular domain.

Definition at line 122 of file ShortcutsGeometry.h.

◆ IdxArc

template<typename TKSpace >
typedef IdxDigitalSurface::Arc DGtal::ShortcutsGeometry< TKSpace >::IdxArc

Definition at line 149 of file ShortcutsGeometry.h.

◆ IdxArcRange

template<typename TKSpace >
typedef IdxDigitalSurface::ArcRange DGtal::ShortcutsGeometry< TKSpace >::IdxArcRange

Definition at line 150 of file ShortcutsGeometry.h.

◆ IdxDigitalSurface

template<typename TKSpace >
typedef IndexedDigitalSurface< ExplicitSurfaceContainer > DGtal::ShortcutsGeometry< TKSpace >::IdxDigitalSurface

defines a connected or not indexed digital surface.

Definition at line 139 of file ShortcutsGeometry.h.

◆ IdxSurfel

template<typename TKSpace >
typedef IdxDigitalSurface::Vertex DGtal::ShortcutsGeometry< TKSpace >::IdxSurfel

Definition at line 147 of file ShortcutsGeometry.h.

◆ IdxSurfelRange

template<typename TKSpace >
typedef std::vector< IdxSurfel > DGtal::ShortcutsGeometry< TKSpace >::IdxSurfelRange

Definition at line 154 of file ShortcutsGeometry.h.

◆ IdxSurfelSet

template<typename TKSpace >
typedef std::set< IdxSurfel > DGtal::ShortcutsGeometry< TKSpace >::IdxSurfelSet

Definition at line 151 of file ShortcutsGeometry.h.

◆ IdxVertex

template<typename TKSpace >
typedef IdxDigitalSurface::Vertex DGtal::ShortcutsGeometry< TKSpace >::IdxVertex

Definition at line 148 of file ShortcutsGeometry.h.

◆ ImplicitShape3D

template<typename TKSpace >
typedef ImplicitPolynomial3Shape<Space> DGtal::ShortcutsGeometry< TKSpace >::ImplicitShape3D

defines an implicit shape of the space, which is the zero-level set of a ScalarPolynomial.

Definition at line 116 of file ShortcutsGeometry.h.

◆ Integer

template<typename TKSpace >
typedef Space::Integer DGtal::ShortcutsGeometry< TKSpace >::Integer

Integer numbers.

Definition at line 94 of file ShortcutsGeometry.h.

◆ KSpace

template<typename TKSpace >
typedef TKSpace DGtal::ShortcutsGeometry< TKSpace >::KSpace

Digital cellular space.

Definition at line 90 of file ShortcutsGeometry.h.

◆ LightDigitalSurface

template<typename TKSpace >
typedef ::DGtal::DigitalSurface< LightSurfaceContainer > DGtal::ShortcutsGeometry< TKSpace >::LightDigitalSurface

defines a connected digital surface over a binary image.

Definition at line 133 of file ShortcutsGeometry.h.

◆ LightSurfaceContainer

template<typename TKSpace >
typedef LightImplicitDigitalSurface< KSpace, BinaryImage > DGtal::ShortcutsGeometry< TKSpace >::LightSurfaceContainer

defines a light container that represents a connected digital surface over a binary image.

Definition at line 131 of file ShortcutsGeometry.h.

◆ MeanCurvatureFunctor

template<typename TKSpace >
typedef sgf::ShapeMeanCurvatureFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::MeanCurvatureFunctor

Definition at line 163 of file ShortcutsGeometry.h.

◆ Mesh

template<typename TKSpace >
typedef ::DGtal::Mesh<RealPoint> DGtal::ShortcutsGeometry< TKSpace >::Mesh

Definition at line 194 of file ShortcutsGeometry.h.

◆ NormalFunctor

template<typename TKSpace >
typedef sgf::ShapeNormalVectorFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::NormalFunctor

Definition at line 162 of file ShortcutsGeometry.h.

◆ Point

template<typename TKSpace >
typedef Space::Point DGtal::ShortcutsGeometry< TKSpace >::Point

Point with integer coordinates.

Definition at line 96 of file ShortcutsGeometry.h.

◆ PolygonalSurface

template<typename TKSpace >
typedef ::DGtal::PolygonalSurface<RealPoint> DGtal::ShortcutsGeometry< TKSpace >::PolygonalSurface

Definition at line 196 of file ShortcutsGeometry.h.

◆ PositionFunctor

template<typename TKSpace >
typedef sgf::ShapePositionFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::PositionFunctor

Definition at line 161 of file ShortcutsGeometry.h.

◆ PrincipalCurvaturesAndDirectionsFunctor

template<typename TKSpace >
typedef sgf::ShapePrincipalCurvaturesAndDirectionsFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::PrincipalCurvaturesAndDirectionsFunctor

Definition at line 169 of file ShortcutsGeometry.h.

◆ RealPoint

template<typename TKSpace >
typedef Space::RealPoint DGtal::ShortcutsGeometry< TKSpace >::RealPoint

Point with floating-point coordinates.

Definition at line 102 of file ShortcutsGeometry.h.

◆ RealPoints

template<typename TKSpace >
typedef std::vector< RealPoint > DGtal::ShortcutsGeometry< TKSpace >::RealPoints

Definition at line 157 of file ShortcutsGeometry.h.

◆ RealVector

template<typename TKSpace >
typedef Space::RealVector DGtal::ShortcutsGeometry< TKSpace >::RealVector

Vector with floating-point coordinates.

Definition at line 100 of file ShortcutsGeometry.h.

◆ RealVectors

template<typename TKSpace >
typedef std::vector< RealVector > DGtal::ShortcutsGeometry< TKSpace >::RealVectors

Definition at line 156 of file ShortcutsGeometry.h.

◆ Scalar

template<typename TKSpace >
typedef RealVector::Component DGtal::ShortcutsGeometry< TKSpace >::Scalar

Floating-point numbers.

Definition at line 104 of file ShortcutsGeometry.h.

◆ ScalarPolynomial

template<typename TKSpace >
typedef MPolynomial< Space::dimension, Scalar > DGtal::ShortcutsGeometry< TKSpace >::ScalarPolynomial

defines a multi-variate polynomial : RealPoint -> Scalar

Definition at line 113 of file ShortcutsGeometry.h.

◆ Scalars

template<typename TKSpace >
typedef std::vector< Scalar > DGtal::ShortcutsGeometry< TKSpace >::Scalars

Definition at line 155 of file ShortcutsGeometry.h.

◆ ScalarStatistic

template<typename TKSpace >
typedef ::DGtal::Statistic<Scalar> DGtal::ShortcutsGeometry< TKSpace >::ScalarStatistic

Definition at line 159 of file ShortcutsGeometry.h.

◆ SCell

template<typename TKSpace >
typedef LightDigitalSurface::SCell DGtal::ShortcutsGeometry< TKSpace >::SCell

Definition at line 142 of file ShortcutsGeometry.h.

◆ SecondPrincipalCurvatureFunctor

template<typename TKSpace >
typedef sgf::ShapeSecondPrincipalCurvatureFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::SecondPrincipalCurvatureFunctor

Definition at line 166 of file ShortcutsGeometry.h.

◆ SecondPrincipalDirectionFunctor

template<typename TKSpace >
typedef sgf::ShapeSecondPrincipalDirectionFunctor<ImplicitShape3D> DGtal::ShortcutsGeometry< TKSpace >::SecondPrincipalDirectionFunctor

Definition at line 168 of file ShortcutsGeometry.h.

◆ Self

template<typename TKSpace >
typedef ShortcutsGeometry< TKSpace > DGtal::ShortcutsGeometry< TKSpace >::Self

Definition at line 81 of file ShortcutsGeometry.h.

◆ Space

template<typename TKSpace >
typedef KSpace::Space DGtal::ShortcutsGeometry< TKSpace >::Space

Digital space.

Definition at line 92 of file ShortcutsGeometry.h.

◆ Surfel

template<typename TKSpace >
typedef LightDigitalSurface::Surfel DGtal::ShortcutsGeometry< TKSpace >::Surfel

Definition at line 140 of file ShortcutsGeometry.h.

◆ Surfel2Index

template<typename TKSpace >
typedef std::map<Surfel, IdxSurfel> DGtal::ShortcutsGeometry< TKSpace >::Surfel2Index

Definition at line 197 of file ShortcutsGeometry.h.

◆ SurfelRange

template<typename TKSpace >
typedef std::vector< Surfel > DGtal::ShortcutsGeometry< TKSpace >::SurfelRange

Definition at line 152 of file ShortcutsGeometry.h.

◆ SurfelSet

template<typename TKSpace >
typedef KSpace::SurfelSet DGtal::ShortcutsGeometry< TKSpace >::SurfelSet

defines a set of surfels

Definition at line 128 of file ShortcutsGeometry.h.

◆ TriangulatedSurface

template<typename TKSpace >
typedef ::DGtal::TriangulatedSurface<RealPoint> DGtal::ShortcutsGeometry< TKSpace >::TriangulatedSurface

Definition at line 195 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalCurvatureEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalCurvatureFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueFirstPrincipalCurvatureEstimator

Definition at line 184 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalDirectionEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalDirectionFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueFirstPrincipalDirectionEstimator

Definition at line 188 of file ShortcutsGeometry.h.

◆ TrueGaussianCurvatureEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, GaussianCurvatureFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueGaussianCurvatureEstimator

Definition at line 182 of file ShortcutsGeometry.h.

◆ TrueMeanCurvatureEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, MeanCurvatureFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueMeanCurvatureEstimator

Definition at line 180 of file ShortcutsGeometry.h.

◆ TrueNormalEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, NormalFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueNormalEstimator

Definition at line 178 of file ShortcutsGeometry.h.

◆ TruePositionEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PositionFunctor > DGtal::ShortcutsGeometry< TKSpace >::TruePositionEstimator

Definition at line 176 of file ShortcutsGeometry.h.

◆ TruePrincipalCurvaturesAndDirectionsEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PrincipalCurvaturesAndDirectionsFunctor > DGtal::ShortcutsGeometry< TKSpace >::TruePrincipalCurvaturesAndDirectionsEstimator

Definition at line 192 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalCurvatureEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalCurvatureFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueSecondPrincipalCurvatureEstimator

Definition at line 186 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalDirectionEstimator

template<typename TKSpace >
typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalDirectionFunctor > DGtal::ShortcutsGeometry< TKSpace >::TrueSecondPrincipalDirectionEstimator

Definition at line 190 of file ShortcutsGeometry.h.

◆ Vector

template<typename TKSpace >
typedef Space::Vector DGtal::ShortcutsGeometry< TKSpace >::Vector

Vector with integer coordinates.

Definition at line 98 of file ShortcutsGeometry.h.

◆ Vertex

template<typename TKSpace >
typedef LightDigitalSurface::Vertex DGtal::ShortcutsGeometry< TKSpace >::Vertex

Definition at line 143 of file ShortcutsGeometry.h.

Constructor & Destructor Documentation

◆ ShortcutsGeometry() [1/3]

template<typename TKSpace >
DGtal::ShortcutsGeometry< TKSpace >::ShortcutsGeometry ( )
delete

Default constructor.

◆ ~ShortcutsGeometry()

template<typename TKSpace >
DGtal::ShortcutsGeometry< TKSpace >::~ShortcutsGeometry ( )
delete

Destructor.

◆ ShortcutsGeometry() [2/3]

template<typename TKSpace >
DGtal::ShortcutsGeometry< TKSpace >::ShortcutsGeometry ( const ShortcutsGeometry< TKSpace > &  other)
delete

Copy constructor.

Parameters
otherthe object to clone.

◆ ShortcutsGeometry() [3/3]

template<typename TKSpace >
DGtal::ShortcutsGeometry< TKSpace >::ShortcutsGeometry ( ShortcutsGeometry< TKSpace > &&  other)
delete

Move constructor.

Parameters
otherthe object to move.

Member Function Documentation

◆ BOOST_CONCEPT_ASSERT()

template<typename TKSpace >
DGtal::ShortcutsGeometry< TKSpace >::BOOST_CONCEPT_ASSERT ( (concepts::CCellularGridSpaceND< TKSpace >)  )
private

◆ defaultParameters()

template<typename TKSpace >
static Parameters DGtal::ShortcutsGeometry< TKSpace >::defaultParameters ( )
inlinestatic

◆ getATScalarFieldApproximation() [1/2]

template<typename TKSpace >
template<typename TAnyDigitalSurface >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation ( CountedPtr< TAnyDigitalSurface >  surface,
const SurfelRange surfels,
const Scalars input,
const Parameters params = parametersATApproximation() | parametersGeometryEstimation() 
)
inlinestatic

Given any digital surface, a surfel range surfels, and an input scalar field input, returns a piece-smooth approximation of input using Ambrosio-Tortorelli functional.

See also
moduleAT
Template Parameters
TAnyDigitalSurfaceeither kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
Parameters
[in]surfacethe digital surface
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • at-alpha [ 0.1 ]: parameter alpha in AT (data fit)
  • at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities)
  • at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities)
  • at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-max-iter [ 10 ]: maximum number of alternate minization in AT optimization
  • at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
[in]inputthe input scalar field (a vector of scalar values)
Returns
the piecewise-smooth approximation of input.
Note
Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1523 of file ShortcutsGeometry.h.

1528 {
1529 int verbose = params[ "verbose" ].as<int>();
1530 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1531 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1532 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1533 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1534 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1535 int max_iter = params[ "at-max-iter" ].as<int>();
1536 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1537 typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
1538 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1539 ATSolver2D< KSpace > at_solver( calculus, verbose );
1540 at_solver.initInputScalarFieldU2( input, surfels.cbegin(), surfels.cend() );
1541 at_solver.setUp( alpha_at, lambda_at );
1542 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1543 auto output = input;
1544 at_solver.getOutputScalarFieldU2( output, surfels.cbegin(), surfels.cend() );
1545 return output;
1546 }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence().

◆ getATScalarFieldApproximation() [2/2]

template<typename TKSpace >
template<typename TAnyDigitalSurface , typename CellRangeConstIterator >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation ( Scalars features,
CellRangeConstIterator  itB,
CellRangeConstIterator  itE,
CountedPtr< TAnyDigitalSurface >  surface,
const SurfelRange surfels,
const Scalars input,
const Parameters params = parametersATApproximation() | parametersGeometryEstimation() 
)
inlinestatic

Given any digital surface, a surfel range surfels, and an input scalar field input, returns a piece-smooth approximation of input using Ambrosio-Tortorelli functional. Given a range of pointels, linels or 2-cells [itB,itE), it also outputs the feature vector features, corresponding to 0-form v in AT (the average of v for linels/surfels).

See also
moduleAT
Template Parameters
TAnyDigitalSurfaceeither kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
CellRangeConstIteratorthe type of iterator for traversing a range of cells
Parameters
[out]featuresthe vector of scalar feature values (a scalar field where 1 means continuity and 0 discontinuity in the reconstruction), evaluated in the range[itB,itE).
[in]itBthe start of the range of cells.
[in]itEpast the end of the range of cells.
[in]surfacethe digital surface
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • at-alpha [ 0.1 ]: parameter alpha in AT (data fit)
  • at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities)
  • at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities)
  • at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-max-iter [ 10 ]: maximum number of alternate minization in AT optimization
  • at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
  • at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"|"Minimum"|"Maximum"
[in]inputthe input scalar field (a vector of scalar values)
Returns
the piecewise-smooth approximation of input.
Note
Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1587 of file ShortcutsGeometry.h.

1595 {
1596 int verbose = params[ "verbose" ].as<int>();
1597 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1598 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1599 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1600 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1601 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1602 int max_iter = params[ "at-max-iter" ].as<int>();
1603 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1604 std::string policy = params[ "at-v-policy" ].as<std::string>();
1605 typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
1606 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1607 ATSolver2D< KSpace > at_solver( calculus, verbose );
1608 at_solver.initInputScalarFieldU2( input, surfels.cbegin(), surfels.cend() );
1609 at_solver.setUp( alpha_at, lambda_at );
1610 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1611 auto output = input;
1612 at_solver.getOutputScalarFieldU2( output, surfels.cbegin(), surfels.cend() );
1613 auto p = ( policy == "Average" ) ? at_solver.Average
1614 : ( policy == "Minimum" ) ? at_solver.Minimum
1615 : at_solver.Maximum;
1616 at_solver.getOutputScalarFieldV0( features, itB, itE, p );
1617 return output;
1618 }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Average, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldV0(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Maximum, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Minimum, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence().

◆ getATVectorFieldApproximation() [1/2]

template<typename TKSpace >
template<typename TAnyDigitalSurface , typename VectorFieldInput >
static VectorFieldInput DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation ( CountedPtr< TAnyDigitalSurface >  surface,
const SurfelRange surfels,
const VectorFieldInput &  input,
const Parameters params = parametersATApproximation() | parametersGeometryEstimation() 
)
inlinestatic

Given any digital surface, a surfel range surfels, and an input vector field input, returns a piece-smooth approximation of input using Ambrosio-Tortorelli functional.

See also
moduleAT
Template Parameters
TAnyDigitalSurfaceeither kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
VectorFieldInputthe type of vector field for input values (RandomAccess container)
Parameters
[in]surfacethe digital surface
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • at-alpha [ 0.1 ]: parameter alpha in AT (data fit)
  • at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities)
  • at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities)
  • at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-max-iter [ 10 ]: maximum number of alternate minization in AT optimization
  • at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
[in]inputthe input vector field (a vector of vector values)
Returns
the piecewise-smooth approximation of input.
Note
Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1402 of file ShortcutsGeometry.h.

1407 {
1408 int verbose = params[ "verbose" ].as<int>();
1409 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1410 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1411 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1412 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1413 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1414 int max_iter = params[ "at-max-iter" ].as<int>();
1415 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1416 typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
1417 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1418 ATSolver2D< KSpace > at_solver( calculus, verbose );
1419 at_solver.initInputVectorFieldU2( input, surfels.cbegin(), surfels.cend() );
1420 at_solver.setUp( alpha_at, lambda_at );
1421 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1422 auto output = input;
1423 at_solver.getOutputVectorFieldU2( output, surfels.cbegin(), surfels.cend() );
1424 return output;
1425 }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence().

Referenced by main().

◆ getATVectorFieldApproximation() [2/2]

template<typename TKSpace >
template<typename TAnyDigitalSurface , typename VectorFieldInput , typename CellRangeConstIterator >
static VectorFieldInput DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation ( Scalars features,
CellRangeConstIterator  itB,
CellRangeConstIterator  itE,
CountedPtr< TAnyDigitalSurface >  surface,
const SurfelRange surfels,
const VectorFieldInput &  input,
const Parameters params = parametersATApproximation() | parametersGeometryEstimation() 
)
inlinestatic

Given any digital surface, a surfel range surfels, and an input vector field input, returns a piece-smooth approximation of input using Ambrosio-Tortorelli functional. Given a range of pointels, linels or 2-cells [itB,itE), it also outputs the feature vector features, corresponding to 0-form v in AT (the average of v for linels/surfels).

See also
moduleAT
Template Parameters
TAnyDigitalSurfaceeither kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
VectorFieldInputthe type of vector field for input values (RandomAccess container)
CellRangeConstIteratorthe type of iterator for traversing a range of cells
Parameters
[out]featuresthe vector of scalar feature values (a scalar field where 1 means continuity and 0 discontinuity in the reconstruction), evaluated in the range[itB,itE).
[in]itBthe start of the range of cells.
[in]itEpast the end of the range of cells.
[in]surfacethe digital surface
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • at-alpha [ 0.1 ]: parameter alpha in AT (data fit)
  • at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities)
  • at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities)
  • at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-max-iter [ 10 ]: maximum number of alternate minization in AT optimization
  • at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
  • at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"|"Minimum"|"Maximum"
[in]inputthe input vector field (a vector of vector values)
Returns
the piecewise-smooth approximation of input.
Note
Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1463 of file ShortcutsGeometry.h.

1471 {
1472 int verbose = params[ "verbose" ].as<int>();
1473 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1474 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1475 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1476 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1477 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1478 int max_iter = params[ "at-max-iter" ].as<int>();
1479 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1480 std::string policy = params[ "at-v-policy" ].as<std::string>();
1481 typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
1482 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1483 ATSolver2D< KSpace > at_solver( calculus, verbose );
1484 at_solver.initInputVectorFieldU2( input, surfels.cbegin(), surfels.cend() );
1485 at_solver.setUp( alpha_at, lambda_at );
1486 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1487 auto output = input;
1488 at_solver.getOutputVectorFieldU2( output, surfels.cbegin(), surfels.cend() );
1489 auto p = ( policy == "Average" ) ? at_solver.Average
1490 : ( policy == "Minimum" ) ? at_solver.Minimum
1491 : at_solver.Maximum;
1492 at_solver.getOutputScalarFieldV0( features, itB, itE, p );
1493 return output;
1494 }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Average, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldV0(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Maximum, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Minimum, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence().

◆ getCTrivialNormalVectors()

template<typename TKSpace >
template<typename TAnyDigitalSurface >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getCTrivialNormalVectors ( CountedPtr< TAnyDigitalSurface >  surface,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() 
)
inlinestatic

Given a digital surface surface, a sequence of surfels, and some parameters params, returns the convolved trivial normal vector estimations at the specified surfels, in the same order.

Template Parameters
TAnyDigitalSurfaceeither kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
Parameters
[in]surfacethe digital surface
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • t-ring [ 3.0]: the radius used when computing convolved trivial normals (it is a graph distance, not related to the grid step).
Returns
the vector containing the estimated normals, in the same order as surfels.

Definition at line 698 of file ShortcutsGeometry.h.

702 {
703 int verbose = params[ "verbose" ].as<int>();
704 Scalar t = params[ "t-ring" ].as<double>();
705 typedef typename TAnyDigitalSurface::DigitalSurfaceContainer SurfaceContainer;
706 typedef LpMetric<Space> Metric;
707 typedef functors::HatFunction<Scalar> Functor;
708 typedef functors::ElementaryConvolutionNormalVectorEstimator
709 < Surfel, CanonicSCellEmbedder<KSpace> > SurfelFunctor;
710 typedef LocalEstimatorFromSurfelFunctorAdapter
711 < SurfaceContainer, Metric, SurfelFunctor, Functor> NormalEstimator;
712 if ( verbose > 0 )
713 trace.info() << "- CTrivial normal t-ring=" << t << " (discrete)" << std::endl;
714 const Functor fct( 1.0, t );
715 const KSpace & K = surface->container().space();
716 Metric aMetric( 2.0 );
717 CanonicSCellEmbedder<KSpace> canonic_embedder( K );
718 std::vector< RealVector > n_estimations;
719 SurfelFunctor surfelFct( canonic_embedder, 1.0 );
720 NormalEstimator estimator;
721 estimator.attach( *surface);
722 estimator.setParams( aMetric, surfelFct, fct, t );
723 estimator.init( 1.0, surfels.begin(), surfels.end());
724 estimator.eval( surfels.begin(), surfels.end(),
725 std::back_inserter( n_estimations ) );
726 std::transform( n_estimations.cbegin(), n_estimations.cend(), n_estimations.begin(),
727 [] ( RealVector v ) { return -v; } );
728 return n_estimations;
729 }
LightDigitalSurface::Surfel Surfel
std::ostream & info()
Trace trace
Definition: Common.h:154
InHalfPlaneBySimple3x3Matrix< Point, double > Functor
KSpace K

References DGtal::Trace::info(), K, and DGtal::trace.

◆ getFirstPrincipalCurvatures()

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getFirstPrincipalCurvatures ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the first (smallest) principal curvatures at the specified surfels, in the same order.

Note
that the first principal curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the first principal curvatures, in the same order as surfels.

Definition at line 438 of file ShortcutsGeometry.h.

443 {
444 Scalars n_true_estimations;
446 int maxIter = params[ "projectionMaxIter" ].as<int>();
447 double accuracy = params[ "projectionAccuracy" ].as<double>();
448 double gamma = params[ "projectionGamma" ].as<double>();
449 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
450 true_estimator.attach( *shape );
451 true_estimator.setParams( K, FirstPrincipalCurvatureFunctor(),
452 maxIter, accuracy, gamma );
453 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
454 true_estimator.eval( surfels.begin(), surfels.end(),
455 std::back_inserter( n_true_estimations ) );
456 return n_true_estimations;
457 }
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalCurvatureFunctor > TrueFirstPrincipalCurvatureEstimator
sgf::ShapeFirstPrincipalCurvatureFunctor< ImplicitShape3D > FirstPrincipalCurvatureFunctor

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getFirstPrincipalDirections()

template<typename TKSpace >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getFirstPrincipalDirections ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the first principal directions (corresponding to the smallest principal curvature) at the specified surfels, in the same order.

Note
that the first principal direction is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the first principal directions, in the same order as surfels.

Definition at line 522 of file ShortcutsGeometry.h.

527 {
528 RealVectors n_true_estimations;
530 int maxIter = params[ "projectionMaxIter" ].as<int>();
531 double accuracy = params[ "projectionAccuracy" ].as<double>();
532 double gamma = params[ "projectionGamma" ].as<double>();
533 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
534 true_estimator.attach( *shape );
535 true_estimator.setParams( K, FirstPrincipalDirectionFunctor(),
536 maxIter, accuracy, gamma );
537 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
538 true_estimator.eval( surfels.begin(), surfels.end(),
539 std::back_inserter( n_true_estimations ) );
540 return n_true_estimations;
541 }
sgf::ShapeFirstPrincipalDirectionFunctor< ImplicitShape3D > FirstPrincipalDirectionFunctor
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalDirectionFunctor > TrueFirstPrincipalDirectionEstimator
std::vector< RealVector > RealVectors

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getGaussianCurvatures()

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getGaussianCurvatures ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the gaussian curvatures at the specified surfels, in the same order.

Note
that the gaussian curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the gaussian curvatures, in the same order as surfels.

Definition at line 397 of file ShortcutsGeometry.h.

402 {
403 Scalars n_true_estimations;
404 TrueGaussianCurvatureEstimator true_estimator;
405 int maxIter = params[ "projectionMaxIter" ].as<int>();
406 double accuracy = params[ "projectionAccuracy" ].as<double>();
407 double gamma = params[ "projectionGamma" ].as<double>();
408 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
409 true_estimator.attach( *shape );
410 true_estimator.setParams( K, GaussianCurvatureFunctor(), maxIter, accuracy, gamma );
411 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
412 true_estimator.eval( surfels.begin(), surfels.end(),
413 std::back_inserter( n_true_estimations ) );
414 return n_true_estimations;
415 }
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, GaussianCurvatureFunctor > TrueGaussianCurvatureEstimator
sgf::ShapeGaussianCurvatureFunctor< ImplicitShape3D > GaussianCurvatureFunctor

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getIIGaussianCurvatures() [1/3]

template<typename TKSpace >
template<typename TPointPredicate >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures ( const TPointPredicate &  shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given an arbitrary PointPredicate shape: Point -> boolean, a Khalimsky space K, a sequence of surfels, and some parameters params, returns the Gaussian curvature Integral Invariant (II) estimation at the specified surfels, in the same order.

Template Parameters
TPointPredicateany type of map Point -> boolean.
Parameters
[in]shapea function Point -> boolean telling if you are inside the shape.
[in]Kthe Khalimsky space where the shape and surfels live.
[in]surfelsthe sequence of surfels at which we compute the Gaussian curvatures
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated Gaussian curvatures, in the same order as surfels.
Note
The function is faster when surfels are in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1176 of file ShortcutsGeometry.h.

1182 {
1183 typedef functors::IIGaussianCurvature3DFunctor<Space> IIGaussianCurvFunctor;
1184 typedef IntegralInvariantCovarianceEstimator
1185 <KSpace, TPointPredicate, IIGaussianCurvFunctor> IIGaussianCurvEstimator;
1186
1187 Scalars mc_estimations;
1188 int verbose = params[ "verbose" ].as<int>();
1189 Scalar h = params[ "gridstep" ].as<Scalar>();
1190 Scalar r = params[ "r-radius" ].as<Scalar>();
1191 Scalar alpha = params[ "alpha" ].as<Scalar>();
1192 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1193 if ( verbose > 0 )
1194 {
1195 trace.info() << "- II Gaussian curvature alpha=" << alpha << std::endl;
1196 trace.info() << "- II Gaussian curvature r=" << (r*h) << " (continuous) "
1197 << r << " (discrete)" << std::endl;
1198 }
1199 IIGaussianCurvFunctor functor;
1200 functor.init( h, r*h );
1201 IIGaussianCurvEstimator ii_estimator( functor );
1202 ii_estimator.attach( K, shape );
1203 ii_estimator.setParams( r );
1204 ii_estimator.init( h, surfels.begin(), surfels.end() );
1205 ii_estimator.eval( surfels.begin(), surfels.end(),
1206 std::back_inserter( mc_estimations ) );
1207 return mc_estimations;
1208 }
TKSpace KSpace
Digital cellular space.

References DGtal::Trace::info(), K, and DGtal::trace.

◆ getIIGaussianCurvatures() [2/3]

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures ( CountedPtr< BinaryImage bimage,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given a digital shape bimage, a sequence of surfels, and some parameters vm, returns the Gaussian curvature Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]bimagethe characteristic function of the shape as a binary image (inside is true, outside is false).
[in]surfelsthe sequence of surfels at which we compute the Gaussian curvatures
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated Gaussian curvatures, in the same order as surfels.
Note
The function is faster when surfels are in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1105 of file ShortcutsGeometry.h.

1110 {
1111 auto K = getKSpace( bimage, params );
1112 return getIIGaussianCurvatures( *bimage, K, surfels, params );
1113 }
static Scalars getIIGaussianCurvatures(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static KSpace getKSpace(const Point &low, const Point &up, Parameters params=parametersKSpace())
Definition: Shortcuts.h:332

References DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures(), main(), and TEST_CASE().

◆ getIIGaussianCurvatures() [3/3]

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures ( CountedPtr< DigitizedImplicitShape3D dshape,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() | parametersDigitizedImplicitShape3D() 
)
inlinestatic

Given a digitized implicit shape dshape, a sequence of surfels, and some parameters params, returns the Gaussian curvature Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]dshapethe digitized implicit shape, which is an implicitly defined characteristic function.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
  • minAABB [ -10.0]: the min value of the AABB bounding box (domain)
  • maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
  • offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes and that you add noise.
  • closed [ 1]: specifies if the Khalimsky space is closed (!=0) or not (==0)
Returns
the vector containing the estimated Gaussian curvatures, in the same order as surfels.
Note
It is better to have surfels in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1141 of file ShortcutsGeometry.h.

1147 {
1148 auto K = getKSpace( params );
1149 return getIIGaussianCurvatures( *dshape, K, surfels, params );
1150 }

References DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

◆ getIIMeanCurvatures() [1/3]

template<typename TKSpace >
template<typename TPointPredicate >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures ( const TPointPredicate &  shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given an arbitrary PointPredicate shape: Point -> boolean, a Khalimsky space K, a sequence of surfels, and some parameters params, returns the mean curvature Integral Invariant (II) estimation at the specified surfels, in the same order.

Template Parameters
TPointPredicateany type of map Point -> boolean.
Parameters
[in]shapea function Point -> boolean telling if you are inside the shape.
[in]Kthe Khalimsky space where the shape and surfels live.
[in]surfelsthe sequence of surfels at which we compute the mean curvatures
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated mean curvatures, in the same order as surfels.
Note
The function is faster when surfels are in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1052 of file ShortcutsGeometry.h.

1058 {
1059 typedef functors::IIMeanCurvature3DFunctor<Space> IIMeanCurvFunctor;
1060 typedef IntegralInvariantVolumeEstimator
1061 <KSpace, TPointPredicate, IIMeanCurvFunctor> IIMeanCurvEstimator;
1062
1063 Scalars mc_estimations;
1064 int verbose = params[ "verbose" ].as<int>();
1065 Scalar h = params[ "gridstep" ].as<Scalar>();
1066 Scalar r = params[ "r-radius" ].as<Scalar>();
1067 Scalar alpha = params[ "alpha" ].as<Scalar>();
1068 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1069 if ( verbose > 0 )
1070 {
1071 trace.info() << "- II mean curvature alpha=" << alpha << std::endl;
1072 trace.info() << "- II mean curvature r=" << (r*h) << " (continuous) "
1073 << r << " (discrete)" << std::endl;
1074 }
1075 IIMeanCurvFunctor functor;
1076 functor.init( h, r*h );
1077 IIMeanCurvEstimator ii_estimator( functor );
1078 ii_estimator.attach( K, shape );
1079 ii_estimator.setParams( r );
1080 ii_estimator.init( h, surfels.begin(), surfels.end() );
1081 ii_estimator.eval( surfels.begin(), surfels.end(),
1082 std::back_inserter( mc_estimations ) );
1083 return mc_estimations;
1084 }

References DGtal::Trace::info(), K, and DGtal::trace.

◆ getIIMeanCurvatures() [2/3]

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures ( CountedPtr< BinaryImage bimage,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given a digital shape bimage, a sequence of surfels, and some parameters vm, returns the mean curvature Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]bimagethe characteristic function of the shape as a binary image (inside is true, outside is false).
[in]surfelsthe sequence of surfels at which we compute the mean curvatures
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated mean curvatures, in the same order as surfels.
Note
The function is faster when surfels are in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 981 of file ShortcutsGeometry.h.

986 {
987 auto K = getKSpace( bimage, params );
988 return getIIMeanCurvatures( *bimage, K, surfels, params );
989 }
static Scalars getIIMeanCurvatures(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())

References DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures(), and main().

◆ getIIMeanCurvatures() [3/3]

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures ( CountedPtr< DigitizedImplicitShape3D dshape,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() | parametersDigitizedImplicitShape3D() 
)
inlinestatic

Given a digitized implicit shape dshape, a sequence of surfels, and some parameters params, returns the mean curvature Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]dshapethe digitized implicit shape, which is an implicitly defined characteristic function.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
  • minAABB [ -10.0]: the min value of the AABB bounding box (domain)
  • maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
  • offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes and that you add noise.
  • closed [ 1]: specifies if the Khalimsky space is closed (!=0) or not (==0)
Returns
the vector containing the estimated mean curvatures, in the same order as surfels.
Note
It is better to have surfels in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1017 of file ShortcutsGeometry.h.

1023 {
1024 auto K = getKSpace( params );
1025 return getIIMeanCurvatures( *dshape, K, surfels, params );
1026 }

References DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

◆ getIINormalVectors() [1/3]

template<typename TKSpace >
template<typename TPointPredicate >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors ( const TPointPredicate &  shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given an arbitrary PointPredicate shape: Point -> boolean, a Khalimsky space K, a sequence of surfels, and some parameters params, returns the normal Integral Invariant (II) estimation at the specified surfels, in the same order.

Template Parameters
TPointPredicateany type of map Point -> boolean.
Parameters
[in]shapea function Point -> boolean telling if you are inside the shape.
[in]Kthe Khalimsky space where the shape and surfels live.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated normals, in the same order as surfels.
Note
Be careful, normals are reoriented with respect to Trivial normals. If you wish a more robust orientation, use getCTrivialNormalVectors.
It is better to have surfels in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 925 of file ShortcutsGeometry.h.

931 {
932 typedef functors::IINormalDirectionFunctor<Space> IINormalFunctor;
933 typedef IntegralInvariantCovarianceEstimator
934 <KSpace, TPointPredicate, IINormalFunctor> IINormalEstimator;
935
936 RealVectors n_estimations;
937 int verbose = params[ "verbose" ].as<int>();
938 Scalar h = params[ "gridstep" ].as<Scalar>();
939 Scalar r = params[ "r-radius" ].as<Scalar>();
940 Scalar alpha = params[ "alpha" ].as<Scalar>();
941 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
942 if ( verbose > 0 )
943 {
944 trace.info() << "- II normal alpha=" << alpha << std::endl;
945 trace.info() << "- II normal r=" << (r*h) << " (continuous) "
946 << r << " (discrete)" << std::endl;
947 }
948 IINormalFunctor functor;
949 functor.init( h, r*h );
950 IINormalEstimator ii_estimator( functor );
951 ii_estimator.attach( K, shape );
952 ii_estimator.setParams( r );
953 ii_estimator.init( h, surfels.begin(), surfels.end() );
954 ii_estimator.eval( surfels.begin(), surfels.end(),
955 std::back_inserter( n_estimations ) );
956 const RealVectors n_trivial = getTrivialNormalVectors( K, surfels );
957 orientVectors( n_estimations, n_trivial );
958 return n_estimations;
959 }
static RealVectors getTrivialNormalVectors(const KSpace &K, const SurfelRange &surfels)
static void orientVectors(RealVectors &v, const RealVectors &ref_v)

References DGtal::ShortcutsGeometry< TKSpace >::getTrivialNormalVectors(), DGtal::Trace::info(), K, DGtal::ShortcutsGeometry< TKSpace >::orientVectors(), and DGtal::trace.

◆ getIINormalVectors() [2/3]

template<typename TKSpace >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors ( CountedPtr< BinaryImage bimage,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given a digital shape bimage, a sequence of surfels, and some parameters params, returns the normal Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]bimagethe characteristic function of the shape as a binary image (inside is true, outside is false).
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated normals, in the same order as surfels.
Note
Be careful, normals are reoriented with respect to Trivial normals. If you wish a more robust orientation, use getCTrivialNormalVectors.
It is better to have surfels in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 848 of file ShortcutsGeometry.h.

853 {
854 auto K = getKSpace( bimage, params );
855 return getIINormalVectors( *bimage, K, surfels, params );
856 }
static RealVectors getIINormalVectors(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())

References DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors(), main(), and TEST_CASE().

◆ getIINormalVectors() [3/3]

template<typename TKSpace >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors ( CountedPtr< DigitizedImplicitShape3D dshape,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() | parametersDigitizedImplicitShape3D() 
)
inlinestatic

Given a digitized implicit shape dshape, a sequence of surfels, and some parameters params, returns the normal Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]dshapethe digitized implicit shape, which is an implicitly defined characteristic function.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
  • minAABB [ -10.0]: the min value of the AABB bounding box (domain)
  • maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
  • offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes and that you add noise.
  • closed [ 1]: specifies if the Khalimsky space is closed (!=0) or not (==0)
Returns
the vector containing the estimated normals, in the same order as surfels.
Note
Be careful, normals are reoriented with respect to Trivial normals. If you wish a more robust orientation, use getCTrivialNormalVectors.
It is better to have surfels in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 888 of file ShortcutsGeometry.h.

894 {
895 auto K = getKSpace( params );
896 return getIINormalVectors( *dshape, K, surfels, params );
897 }

References DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

◆ getIIPrincipalCurvaturesAndDirections() [1/3]

template<typename TKSpace >
template<typename TPointPredicate >
static CurvatureTensorQuantities DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections ( const TPointPredicate &  shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given an arbitrary PointPredicate shape: Point -> boolean, a Khalimsky space K, a sequence of surfels, and some parameters params, returns the principal curvatures and directions using Integral Invariant (II) estimation at the specified surfels, in the same order.

Template Parameters
TPointPredicateany type of map Point -> boolean.
Parameters
[in]shapea function Point -> boolean telling if you are inside the shape.
[in]Kthe Khalimsky space where the shape and surfels live.
[in]surfelsthe sequence of surfels at which we compute the Gaussian curvatures
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated principal curvatures and directions, in the same order as surfels.
Note
The function is faster when surfels are in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1302 of file ShortcutsGeometry.h.

1308 {
1309 typedef functors::IIPrincipalCurvaturesAndDirectionsFunctor<Space> IICurvFunctor;
1310 typedef IntegralInvariantCovarianceEstimator<KSpace, TPointPredicate, IICurvFunctor> IICurvEstimator;
1311
1312 CurvatureTensorQuantities mc_estimations;
1313 int verbose = params[ "verbose" ].as<int>();
1314 Scalar h = params[ "gridstep" ].as<Scalar>();
1315 Scalar r = params[ "r-radius" ].as<Scalar>();
1316 Scalar alpha = params[ "alpha" ].as<Scalar>();
1317 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1318 if ( verbose > 0 )
1319 {
1320 trace.info() << "- II principal curvatures and directions alpha=" << alpha << std::endl;
1321 trace.info() << "- II principal curvatures and directions r=" << (r*h) << " (continuous) "
1322 << r << " (discrete)" << std::endl;
1323 }
1324 IICurvFunctor functor;
1325 functor.init( h, r*h );
1326 IICurvEstimator ii_estimator( functor );
1327 ii_estimator.attach( K, shape );
1328 ii_estimator.setParams( r );
1329 ii_estimator.init( h, surfels.begin(), surfels.end() );
1330 ii_estimator.eval( surfels.begin(), surfels.end(),
1331 std::back_inserter( mc_estimations ) );
1332 return mc_estimations;
1333 }
std::vector< CurvatureTensorQuantity > CurvatureTensorQuantities

References DGtal::Trace::info(), K, and DGtal::trace.

◆ getIIPrincipalCurvaturesAndDirections() [2/3]

template<typename TKSpace >
static CurvatureTensorQuantities DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections ( CountedPtr< BinaryImage bimage,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() 
)
inlinestatic

Given a digital shape bimage, a sequence of surfels, and some parameters vm, returns the principal curvatures and directions using an Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]bimagethe characteristic function of the shape as a binary image (inside is true, outside is false).
[in]surfelsthe sequence of surfels at which we compute the Gaussian curvatures
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
Returns
the vector containing the estimated Gaussian curvatures, in the same order as surfels.
Note
The function is faster when surfels are in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1230 of file ShortcutsGeometry.h.

1235 {
1236 auto K = getKSpace( bimage, params );
1237 return getIIPrincipalCurvaturesAndDirections( *bimage, K, surfels, params );
1238 }
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())

References DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections(), and TEST_CASE().

◆ getIIPrincipalCurvaturesAndDirections() [3/3]

template<typename TKSpace >
static CurvatureTensorQuantities DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections ( CountedPtr< DigitizedImplicitShape3D dshape,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() | parametersKSpace() | parametersDigitizedImplicitShape3D() 
)
inlinestatic

Given a digital shape dshape, a sequence of surfels, and some parameters vm, returns the principal curvatures and directions using an Integral Invariant (II) estimation at the specified surfels, in the same order.

Parameters
[in]dshapethe digitized implicit shape, which is an implicitly defined characteristic function.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • gridstep [ 1.0]: the digitization gridstep (often denoted by h).
  • minAABB [ -10.0]: the min value of the AABB bounding box (domain)
  • maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
  • offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes adding some noise.
  • closed [ 1]: specifies if the Khalimsky space is closed (!=0) or not (==0)
Returns
the vector containing the estimated principal curvatures and directions, in the same order as surfels.
Note
It is better to have surfels in a specific order, as given for instance by a depth-first traversal (see getSurfelRange)

Definition at line 1267 of file ShortcutsGeometry.h.

1273 {
1274 auto K = getKSpace( params );
1275 return getIIPrincipalCurvaturesAndDirections( *dshape, K, surfels, params );
1276 }

References DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections(), DGtal::ShortcutsGeometry< TKSpace >::getKSpace(), and K.

◆ getKSpace() [1/6]

template<typename TKSpace >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( const Point low,
const Point up,
Parameters  params = parametersKSpace() 
)
inlinestatic

Builds a Khalimsky space that encompasses the lower and upper digital points. Note that digital points are cells of the Khalimsky space with maximal dimensions. A closed Khalimsky space adds lower dimensional cells all around its boundary to define a closed complex.

Parameters
[in]lowthe lowest point in the space
[in]upthe highest point in the space
[in]paramsthe parameters:
  • closed [1]: specifies if the Khalimsky space is closed (!=0) or not (==0).
Returns
the Khalimsky space.

Definition at line 332 of file Shortcuts.h.

334 {
335 int closed = params[ "closed" ].as<int>();
336 KSpace K;
337 if ( ! K.init( low, up, closed ) )
338 trace.error() << "[Shortcuts::getKSpace]"
339 << " Error building Khalimsky space K=" << K << std::endl;
340 return K;
341 }
std::ostream & error()

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors(), and DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections().

◆ getKSpace() [2/6]

template<typename TKSpace >
template<typename TDigitalSurfaceContainer >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >  surface)
inlinestatic
Template Parameters
TDigitalSurfaceContainereither kind of DigitalSurfaceContainer
Parameters
[in]surfacea smart pointer on a (light or not) digital surface (e.g. DigitalSurface or LightDigitalSurface).
Returns
the Khalimsky space associated to the given surface.

Definition at line 396 of file Shortcuts.h.

398 {
399 return surface->container().space();
400 }

◆ getKSpace() [3/6]

template<typename TKSpace >
template<typename TDigitalSurfaceContainer >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > >  surface)
inlinestatic
Template Parameters
TDigitalSurfaceContainereither kind of DigitalSurfaceContainer
Parameters
[in]surfacea smart pointer on any indexed digital surface.
Returns
the Khalimsky space associated to the given surface.

Definition at line 407 of file Shortcuts.h.

409 {
410 return surface->container().space();
411 }

◆ getKSpace() [4/6]

template<typename TKSpace >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( CountedPtr< BinaryImage bimage,
Parameters  params = parametersKSpace() 
)
inlinestatic

Builds a Khalimsky space that encompasses the domain of the given image. Note that digital points are cells of the Khalimsky space with maximal dimensions. A closed Khalimsky space adds lower dimensional cells all around its boundary to define a closed complex.

Parameters
[in]bimageany binary image
[in]paramsthe parameters:
  • closed [1]: specifies if the Khalimsky space is closed (!=0) or not (==0).
Returns
the Khalimsky space.

Definition at line 354 of file Shortcuts.h.

356 {
357 int closed = params[ "closed" ].as<int>();
358 KSpace K;
359 if ( ! K.init( bimage->domain().lowerBound(),
360 bimage->domain().upperBound(),
361 closed ) )
362 trace.error() << "[Shortcuts::getKSpace]"
363 << " Error building Khalimsky space K=" << K << std::endl;
364 return K;
365 }

◆ getKSpace() [5/6]

template<typename TKSpace >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( CountedPtr< GrayScaleImage gimage,
Parameters  params = parametersKSpace() 
)
inlinestatic

Builds a Khalimsky space that encompasses the domain of the given image. Note that digital points are cells of the Khalimsky space with maximal dimensions. A closed Khalimsky space adds lower dimensional cells all around its boundary to define a closed complex.

Parameters
[in]gimageany gray-scale image
[in]paramsthe parameters:
  • closed [1]: specifies if the Khalimsky space is closed (!=0) or not (==0).
Returns
the Khalimsky space.

Definition at line 378 of file Shortcuts.h.

380 {
381 int closed = params[ "closed" ].as<int>();
382 KSpace K;
383 if ( ! K.init( gimage->domain().lowerBound(),
384 gimage->domain().upperBound(),
385 closed ) )
386 trace.error() << "[Shortcuts::getKSpace]"
387 << " Error building Khalimsky space K=" << K << std::endl;
388 return K;
389 }

◆ getKSpace() [6/6]

template<typename TKSpace >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( Parameters  params = parametersKSpace() | parametersDigitizedImplicitShape3D())
inlinestatic

Builds a Khalimsky space that encompasses the bounding box specified by a digitization in params. It is useful when digitizing an implicit shape.

Parameters
[in]paramsthe parameters:
  • minAABB [-10.0]: the min value of the AABB bounding box (domain)
  • maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
  • offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes and that you add noise.
  • closed [1] : specifies if the Khalimsky space is closed (!=0) or not (==0).
Returns
the Khalimsky space.
See also
makeDigitizedImplicitShape3D

Definition at line 486 of file Shortcuts.h.

488 {
489 Scalar min_x = params[ "minAABB" ].as<Scalar>();
490 Scalar max_x = params[ "maxAABB" ].as<Scalar>();
491 Scalar h = params[ "gridstep" ].as<Scalar>();
492 Scalar offset = params[ "offset" ].as<Scalar>();
493 bool closed = params[ "closed" ].as<int>();
494 RealPoint p1( min_x - offset * h, min_x - offset * h, min_x - offset * h );
495 RealPoint p2( max_x + offset * h, max_x + offset * h, max_x + offset * h );
496 CountedPtr<DigitizedImplicitShape3D> dshape( new DigitizedImplicitShape3D() );
497 dshape->init( p1, p2, h );
498 Domain domain = dshape->getDomain();
499 KSpace K;
500 if ( ! K.init( domain.lowerBound(), domain.upperBound(), closed ) )
501 trace.error() << "[Shortcuts::getKSpace]"
502 << " Error building Khalimsky space K=" << K << std::endl
503 << "Note: if you use decimal values, check your locale for decimal point '.' or ','."
504 << std::endl;
505 return K;
506 }
const Point & lowerBound() const
const Point & upperBound() const
GaussDigitizer< Space, ImplicitShape3D > DigitizedImplicitShape3D
defines the digitization of an implicit shape.
Z2i::RealPoint RealPoint
Domain domain
HyperRectDomain< Space > Domain

◆ getMeanCurvatures()

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getMeanCurvatures ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the mean curvatures at the specified surfels, in the same order.

Note
that the mean curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the mean curvatures, in the same order as surfels.

Definition at line 357 of file ShortcutsGeometry.h.

362 {
363 Scalars n_true_estimations;
364 TrueMeanCurvatureEstimator true_estimator;
365 int maxIter = params[ "projectionMaxIter" ].as<int>();
366 double accuracy = params[ "projectionAccuracy" ].as<double>();
367 double gamma = params[ "projectionGamma" ].as<double>();
368 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
369 true_estimator.attach( *shape );
370 true_estimator.setParams( K, MeanCurvatureFunctor(), maxIter, accuracy, gamma );
371 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
372 true_estimator.eval( surfels.begin(), surfels.end(),
373 std::back_inserter( n_true_estimations ) );
374 return n_true_estimations;
375 }
sgf::ShapeMeanCurvatureFunctor< ImplicitShape3D > MeanCurvatureFunctor
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, MeanCurvatureFunctor > TrueMeanCurvatureEstimator

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getNormalVectors()

template<typename TKSpace >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getNormalVectors ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the normal vectors at the specified surfels, in the same order.

Note
that the normal vector is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the true normals, in the same order as surfels.

Definition at line 318 of file ShortcutsGeometry.h.

323 {
324 RealVectors n_true_estimations;
325 TrueNormalEstimator true_estimator;
326 int maxIter = params[ "projectionMaxIter" ].as<int>();
327 double accuracy = params[ "projectionAccuracy" ].as<double>();
328 double gamma = params[ "projectionGamma" ].as<double>();
329 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
330 true_estimator.attach( *shape );
331 true_estimator.setParams( K, NormalFunctor(), maxIter, accuracy, gamma );
332 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
333 true_estimator.eval( surfels.begin(), surfels.end(),
334 std::back_inserter( n_true_estimations ) );
335 return n_true_estimations;
336 }
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, NormalFunctor > TrueNormalEstimator
sgf::ShapeNormalVectorFunctor< ImplicitShape3D > NormalFunctor

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getPositions() [1/2]

template<typename TKSpace >
static RealPoints DGtal::ShortcutsGeometry< TKSpace >::getPositions ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the closest positions on the surface at the specified surfels, in the same order.

Note
The surfel centroids are iteratively projected onto the implicit surface through a damped Newton process.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels that we project onto the shape's surface
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the true normals, in the same order as surfels.

Definition at line 250 of file ShortcutsGeometry.h.

255 {
256 RealVectors n_true_estimations;
257 TruePositionEstimator true_estimator;
258 int maxIter = params[ "projectionMaxIter" ].as<int>();
259 double accuracy = params[ "projectionAccuracy" ].as<double>();
260 double gamma = params[ "projectionGamma" ].as<double>();
261 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
262 true_estimator.attach( *shape );
263 true_estimator.setParams( K, PositionFunctor(), maxIter, accuracy, gamma );
264 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
265 true_estimator.eval( surfels.begin(), surfels.end(),
266 std::back_inserter( n_true_estimations ) );
267 return n_true_estimations;
268 }
sgf::ShapePositionFunctor< ImplicitShape3D > PositionFunctor
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PositionFunctor > TruePositionEstimator

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getPositions() [2/2]

template<typename TKSpace >
static RealPoints DGtal::ShortcutsGeometry< TKSpace >::getPositions ( CountedPtr< ImplicitShape3D shape,
const RealPoints points,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given an implicit shape and a sequence of points, returns the closest positions on the surface at the specified points, in the same order.

Parameters
[in]shapethe implicit shape.
[in]pointsthe sequence of points that we project onto the shape's surface.
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the projected points.

Definition at line 284 of file ShortcutsGeometry.h.

288 {
289 RealPoints proj_points( points.size() );
290 int maxIter = params[ "projectionMaxIter" ].as<int>();
291 double accuracy = params[ "projectionAccuracy" ].as<double>();
292 double gamma = params[ "projectionGamma" ].as<double>();
293 for ( unsigned int i = 0; i < points.size(); ++i )
294 proj_points[ i ] = shape->nearestPoint( points[ i ], accuracy,
295 maxIter, gamma );
296 return proj_points;
297 }
std::vector< RealPoint > RealPoints

◆ getPrincipalCurvaturesAndDirections()

template<typename TKSpace >
static CurvatureTensorQuantities DGtal::ShortcutsGeometry< TKSpace >::getPrincipalCurvaturesAndDirections ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the principal curvatures and principal directions as a tuple (k1, k2, d1, d2) at the specified surfels, in the same order.

Note
that the second principal direction is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the principal curvatures and principal directions as a tuple (k1, k2, d1, d2), in the same order as surfels.

Definition at line 607 of file ShortcutsGeometry.h.

612 {
613 CurvatureTensorQuantities n_true_estimations;
615 int maxIter = params[ "projectionMaxIter" ].as<int>();
616 double accuracy = params[ "projectionAccuracy" ].as<double>();
617 double gamma = params[ "projectionGamma" ].as<double>();
618 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
619 true_estimator.attach( *shape );
620 true_estimator.setParams( K, PrincipalCurvaturesAndDirectionsFunctor(),
621 maxIter, accuracy, gamma );
622 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
623 true_estimator.eval( surfels.begin(), surfels.end(),
624 std::back_inserter( n_true_estimations ) );
625 return n_true_estimations;
626 }
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PrincipalCurvaturesAndDirectionsFunctor > TruePrincipalCurvaturesAndDirectionsEstimator
sgf::ShapePrincipalCurvaturesAndDirectionsFunctor< ImplicitShape3D > PrincipalCurvaturesAndDirectionsFunctor

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

◆ getScalarsAbsoluteDifference()

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getScalarsAbsoluteDifference ( const Scalars v1,
const Scalars v2 
)
inlinestatic

Computes the absolute difference between each element of the two vectors.

Parameters
[in]v1any vector of values.
[in]v2any vector of values.
Returns
the vector composed of elemenst |v1[i]-v2[i]|.

Definition at line 1691 of file ShortcutsGeometry.h.

1693 {
1694 Scalars result( v1.size() );
1695 std::transform( v2.cbegin(), v2.cend(), v1.cbegin(), result.begin(),
1696 [] ( Scalar val1, Scalar val2 )
1697 { return fabs( val1 - val2 ); } );
1698 return result;
1699 }

Referenced by main().

◆ getScalarsNormL1()

template<typename TKSpace >
static Scalar DGtal::ShortcutsGeometry< TKSpace >::getScalarsNormL1 ( const Scalars v1,
const Scalars v2 
)
inlinestatic

Computes the l1-norm of v1-v2, ie the average of the absolute differences of the two vectors.

Parameters
[in]v1any vector of values.
[in]v2any vector of values.
Returns
the normL1 of v1-v2, ie. 1/n sum_i |v1[i]-v2[i]|.

Definition at line 1724 of file ShortcutsGeometry.h.

1726 {
1727 Scalar sum = 0;
1728 for ( unsigned int i = 0; i < v1.size(); i++ )
1729 sum += fabs( v1[ i ] - v2[ i ] );
1730 return sum / v1.size();
1731 }

Referenced by main().

◆ getScalarsNormL2()

template<typename TKSpace >
static Scalar DGtal::ShortcutsGeometry< TKSpace >::getScalarsNormL2 ( const Scalars v1,
const Scalars v2 
)
inlinestatic

Computes the l2-norm of v1-v2, ie the square root of the mean-squared error of the two vectors.

Parameters
[in]v1any vector of values.
[in]v2any vector of values.
Returns
the normL2 of v1-v2, ie. sqrt( 1/n sum_i (v1[i]-v2[i])^2 ).

Definition at line 1708 of file ShortcutsGeometry.h.

1710 {
1711 Scalar sum = 0;
1712 for ( unsigned int i = 0; i < v1.size(); i++ )
1713 sum += ( v1[ i ] - v2[ i ] ) * ( v1[ i ] - v2[ i ] );
1714 return sqrt( sum / v1.size() );
1715 }

Referenced by main().

◆ getScalarsNormLoo()

template<typename TKSpace >
static Scalar DGtal::ShortcutsGeometry< TKSpace >::getScalarsNormLoo ( const Scalars v1,
const Scalars v2 
)
inlinestatic

Computes the loo-norm of v1-v2, ie the maximum of the absolute differences of the two vectors.

Parameters
[in]v1any vector of values.
[in]v2any vector of values.
Returns
the normLoo of v1-v2, ie. max_i |v1[i]-v2[i]|.

Definition at line 1740 of file ShortcutsGeometry.h.

1742 {
1743 Scalar loo = 0;
1744 for ( unsigned int i = 0; i < v1.size(); i++ )
1745 loo = std::max( loo, fabs( v1[ i ] - v2[ i ] ) );
1746 return loo;
1747 }

Referenced by main().

◆ getSecondPrincipalCurvatures()

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getSecondPrincipalCurvatures ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the second (greatest) principal curvatures at the specified surfels, in the same order.

Note
that the second principal curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the second principal curvatures, in the same order as surfels.

Definition at line 480 of file ShortcutsGeometry.h.

485 {
486 Scalars n_true_estimations;
488 int maxIter = params[ "projectionMaxIter" ].as<int>();
489 double accuracy = params[ "projectionAccuracy" ].as<double>();
490 double gamma = params[ "projectionGamma" ].as<double>();
491 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
492 true_estimator.attach( *shape );
493 true_estimator.setParams( K, SecondPrincipalCurvatureFunctor(),
494 maxIter, accuracy, gamma );
495 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
496 true_estimator.eval( surfels.begin(), surfels.end(),
497 std::back_inserter( n_true_estimations ) );
498 return n_true_estimations;
499 }
sgf::ShapeSecondPrincipalCurvatureFunctor< ImplicitShape3D > SecondPrincipalCurvatureFunctor
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalCurvatureFunctor > TrueSecondPrincipalCurvatureEstimator

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getSecondPrincipalDirections()

template<typename TKSpace >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getSecondPrincipalDirections ( CountedPtr< ImplicitShape3D shape,
const KSpace K,
const SurfelRange surfels,
const Parameters params = parametersShapeGeometry() 
)
inlinestatic

Given a space K, an implicit shape, a sequence of surfels, and a gridstep h, returns the second principal directions (corresponding to the greatest principal curvature) at the specified surfels, in the same order.

Note
that the second principal direction is approximated by projecting the surfel centroid onto the implicit 3D shape.
Parameters
[in]shapethe implicit shape.
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the second principal directions, in the same order as surfels.

Definition at line 564 of file ShortcutsGeometry.h.

569 {
570 RealVectors n_true_estimations;
572 int maxIter = params[ "projectionMaxIter" ].as<int>();
573 double accuracy = params[ "projectionAccuracy" ].as<double>();
574 double gamma = params[ "projectionGamma" ].as<double>();
575 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
576 true_estimator.attach( *shape );
577 true_estimator.setParams( K, SecondPrincipalDirectionFunctor(),
578 maxIter, accuracy, gamma );
579 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
580 true_estimator.eval( surfels.begin(), surfels.end(),
581 std::back_inserter( n_true_estimations ) );
582 return n_true_estimations;
583 }
sgf::ShapeSecondPrincipalDirectionFunctor< ImplicitShape3D > SecondPrincipalDirectionFunctor
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalDirectionFunctor > TrueSecondPrincipalDirectionEstimator

References DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::attach(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::eval(), DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::init(), K, and DGtal::TrueDigitalSurfaceLocalEstimator< TKSpace, TShape, TGeometricFunctor >::setParams().

Referenced by main().

◆ getStatistic()

template<typename TKSpace >
static ScalarStatistic DGtal::ShortcutsGeometry< TKSpace >::getStatistic ( const Scalars v)
inlinestatic

Computes the statistic of a vector of scalars

Parameters
[in]va vector of scalars
Returns
its statistic.

Definition at line 1648 of file ShortcutsGeometry.h.

1649 {
1650 ScalarStatistic stat;
1651 stat.addValues( v.begin(), v.end() );
1652 stat.terminate();
1653 return stat;
1654 }
::DGtal::Statistic< Scalar > ScalarStatistic

References DGtal::Statistic< TQuantity >::addValues(), and DGtal::Statistic< TQuantity >::terminate().

Referenced by main().

◆ getTrivialNormalVectors()

template<typename TKSpace >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getTrivialNormalVectors ( const KSpace K,
const SurfelRange surfels 
)
inlinestatic

Given a digital space K and a vector of surfels, returns the trivial normals at the specified surfels, in the same order.

Parameters
[in]Kthe Khalimsky space whose domain encompasses the digital shape.
[in]surfelsthe sequence of surfels at which we compute the normals
Returns
the vector containing the trivial normal vectors, in the same order as surfels.

Definition at line 666 of file ShortcutsGeometry.h.

668 {
669 std::vector< RealVector > result;
670 for ( auto s : surfels )
671 {
672 Dimension k = K.sOrthDir( s );
673 bool direct = K.sDirect( s, k );
674 RealVector t = RealVector::zero;
675 t[ k ] = direct ? -1.0 : 1.0;
676 result.push_back( t );
677 }
678 return result;
679 }
static Self zero
Static const for zero PointVector.
Definition: PointVector.h:1595
DGtal::uint32_t Dimension
Definition: Common.h:137

References K, and DGtal::PointVector< dim, TEuclideanRing, TContainer >::zero.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors().

◆ getVCMNormalVectors()

template<typename TKSpace >
template<typename TAnyDigitalSurface >
static RealVectors DGtal::ShortcutsGeometry< TKSpace >::getVCMNormalVectors ( CountedPtr< TAnyDigitalSurface >  surface,
const SurfelRange surfels,
const Parameters params = parametersGeometryEstimation() 
)
inlinestatic

Given a digital surface surface, a sequence of surfels, and some parameters params, returns the normal Voronoi Covariance Measure (VCM) estimation at the specified surfels, in the same order.

Template Parameters
TAnyDigitalSurfaceeither kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
Parameters
[in]surfacethe digital surface
[in]surfelsthe sequence of surfels at which we compute the normals
[in]paramsthe parameters:
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • t-ring [ 3.0]: the radius used when computing convolved trivial normals (it is a graph distance, not related to the grid step).
  • R-radius [ 10.0]: the constant for distance parameter R in R(h)=R h^alpha (VCM).
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • kernel [ "hat"]: the kernel integration function chi_r, either "hat" or "ball". )
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • surfelEmbedding [ 0]: the surfel -> point embedding for VCM estimator: 0: Pointels, 1: InnerSpel, 2: OuterSpel.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
Returns
the vector containing the estimated normals, in the same order as surfels.

Definition at line 754 of file ShortcutsGeometry.h.

758 {
759 typedef ExactPredicateLpSeparableMetric<Space,2> Metric;
760 typedef typename TAnyDigitalSurface::DigitalSurfaceContainer SurfaceContainer;
761 RealVectors n_estimations;
762 int verbose = params[ "verbose" ].as<int>();
763 std::string kernel = params[ "kernel" ].as<std::string>();
764 Scalar h = params[ "gridstep" ].as<Scalar>();
765 Scalar R = params[ "R-radius" ].as<Scalar>();
766 Scalar r = params[ "r-radius" ].as<Scalar>();
767 Scalar t = params[ "t-ring" ].as<Scalar>();
768 Scalar alpha = params[ "alpha" ].as<Scalar>();
769 int embedding = params[ "embedding" ].as<int>();
770 // Adjust parameters according to gridstep if specified.
771 if ( alpha != 1.0 ) R *= pow( h, alpha-1.0 );
772 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
773 Surfel2PointEmbedding embType = embedding == 0 ? Pointels :
774 embedding == 1 ? InnerSpel : OuterSpel;
775 if ( verbose > 0 )
776 {
777 trace.info() << "- VCM normal kernel=" << kernel << " emb=" << embedding
778 << " alpha=" << alpha << std::endl;
779 trace.info() << "- VCM normal r=" << (r*h) << " (continuous) "
780 << r << " (discrete)" << std::endl;
781 trace.info() << "- VCM normal R=" << (R*h) << " (continuous) "
782 << R << " (discrete)" << std::endl;
783 trace.info() << "- VCM normal t=" << t << " (discrete)" << std::endl;
784 }
785 if ( kernel == "hat" )
786 {
787 typedef functors::HatPointFunction<Point,Scalar> KernelFunction;
788 typedef VoronoiCovarianceMeasureOnDigitalSurface
789 < SurfaceContainer, Metric, KernelFunction > VCMOnSurface;
790 typedef functors::VCMNormalVectorFunctor<VCMOnSurface> NormalVFunctor;
791 typedef VCMDigitalSurfaceLocalEstimator
792 < SurfaceContainer, Metric, KernelFunction, NormalVFunctor> VCMNormalEstimator;
793 KernelFunction chi_r( 1.0, r );
794 VCMNormalEstimator estimator;
795 estimator.attach( *surface );
796 estimator.setParams( embType, R, r, chi_r, t, Metric(), verbose > 0 );
797 estimator.init( h, surfels.begin(), surfels.end() );
798 estimator.eval( surfels.begin(), surfels.end(),
799 std::back_inserter( n_estimations ) );
800 }
801 else if ( kernel == "ball" )
802 {
803 typedef functors::BallConstantPointFunction<Point,Scalar> KernelFunction;
804 typedef VoronoiCovarianceMeasureOnDigitalSurface
805 < SurfaceContainer, Metric, KernelFunction > VCMOnSurface;
806 typedef functors::VCMNormalVectorFunctor<VCMOnSurface> NormalVFunctor;
807 typedef VCMDigitalSurfaceLocalEstimator
808 < SurfaceContainer, Metric, KernelFunction, NormalVFunctor> VCMNormalEstimator;
809 KernelFunction chi_r( 1.0, r );
810 VCMNormalEstimator estimator;
811 estimator.attach( *surface );
812 estimator.setParams( embType, R, r, chi_r, t, Metric(), verbose > 0 );
813 estimator.init( h, surfels.begin(), surfels.end() );
814 estimator.eval( surfels.begin(), surfels.end(),
815 std::back_inserter( n_estimations ) );
816 }
817 else
818 {
819 trace.warning() << "[ShortcutsGeometry::getVCMNormalVectors] Unknown kernel: "
820 << kernel << std::endl;
821 }
822 return n_estimations;
823 }
std::ostream & warning()
Surfel2PointEmbedding
Possible embeddings for surfel as point(s)

References DGtal::Trace::info(), DGtal::InnerSpel, DGtal::OuterSpel, DGtal::Pointels, DGtal::R, DGtal::trace, and DGtal::Trace::warning().

Referenced by main().

◆ getVectorsAngleDeviation()

template<typename TKSpace >
static Scalars DGtal::ShortcutsGeometry< TKSpace >::getVectorsAngleDeviation ( const RealVectors v1,
const RealVectors v2 
)
inlinestatic

Computes the statistic that measures the angle differences between the two arrays of unit vectors.

Parameters
[in]v1the first array of unit vectors (normals)
[in]v2the second array of unit vectors (normals)
Returns
the vector of angle differences.

Definition at line 1663 of file ShortcutsGeometry.h.

1665 {
1666 Scalars v( v1.size() );
1667 if ( v1.size() == v2.size() )
1668 {
1669 auto outIt = v.begin();
1670 for ( auto it1 = v1.cbegin(), it2 = v2.cbegin(), itE1 = v1.cend();
1671 it1 != itE1; ++it1, ++it2 )
1672 {
1673 Scalar angle_error = acos( (*it1).dot( *it2 ) );
1674 *outIt++ = angle_error;
1675 }
1676 }
1677 else
1678 {
1679 trace.warning() << "[ShortcutsGeometry::getVectorsAngleDeviation]"
1680 << " v1.size()=" << v1.size() << " should be equal to "
1681 << " v2.size()=" << v2.size() << std::endl;
1682 }
1683 return v;
1684 }

References DGtal::trace, and DGtal::Trace::warning().

◆ operator=() [1/2]

template<typename TKSpace >
ShortcutsGeometry & DGtal::ShortcutsGeometry< TKSpace >::operator= ( const ShortcutsGeometry< TKSpace > &  other)
delete

Copy assignment operator.

Parameters
otherthe object to copy.
Returns
a reference on 'this'.

◆ operator=() [2/2]

template<typename TKSpace >
ShortcutsGeometry & DGtal::ShortcutsGeometry< TKSpace >::operator= ( ShortcutsGeometry< TKSpace > &&  other)
delete

Move assignment operator.

Parameters
otherthe object to move.
Returns
a reference on 'this'.

◆ orientVectors()

template<typename TKSpace >
static void DGtal::ShortcutsGeometry< TKSpace >::orientVectors ( RealVectors v,
const RealVectors ref_v 
)
inlinestatic

Orient v so that it points in the same direction as ref_v (scalar product is then non-negative afterwards).

Parameters
[in,out]vthe vectors to reorient.
[in]ref_vthe vectors having the reference orientation.

Definition at line 1635 of file ShortcutsGeometry.h.

1637 {
1638 std::transform( ref_v.cbegin(), ref_v.cend(), v.cbegin(), v.begin(),
1639 [] ( RealVector rw, RealVector w )
1640 { return rw.dot( w ) >= 0.0 ? w : -w; } );
1641 }

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors().

◆ parametersATApproximation()

template<typename TKSpace >
static Parameters DGtal::ShortcutsGeometry< TKSpace >::parametersATApproximation ( )
inlinestatic
Returns
the parameters and their default values which are used to compute Ambrosio-Tortorelli piecewise-smooth approximation of a function.
  • at-enabled [ 1 ]: 1 if AT is enabled (WITH_EIGEN), 0 otherwise.
  • at-alpha [ 0.1 ]: parameter alpha in AT (data fit)
  • at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities)
  • at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities)
  • at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
  • at-max-iter [ 10 ]: maximum number of alternate minization in AT optimization
  • at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
  • at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"|"Minimum"|"Maximum"
Note
Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1355 of file ShortcutsGeometry.h.

1356 {
1357#if defined(WITH_EIGEN)
1358 return Parameters
1359 ( "at-enabled", 1 )
1360 ( "at-alpha", 0.1 )
1361 ( "at-lambda", 0.025 )
1362 ( "at-epsilon", 0.25 )
1363 ( "at-epsilon-start", 2.0 )
1364 ( "at-epsilon-ratio", 2.0 )
1365 ( "at-max-iter", 10 )
1366 ( "at-diff-v-max", 0.0001 )
1367 ( "at-v-policy", "Maximum" );
1368#else // defined(WITH_EIGEN)
1369 return Parameters( "at-enabled", 0 );
1370#endif// defined(WITH_EIGEN)
1371 }

Referenced by DGtal::ShortcutsGeometry< TKSpace >::defaultParameters().

◆ parametersDigitizedImplicitShape3D()

template<typename TKSpace >
static Parameters DGtal::Shortcuts< TKSpace >::parametersDigitizedImplicitShape3D ( )
inlinestatic
Returns
the parameters and their default values which are used for digitization.
  • minAABB [-10.0]: the min value of the AABB bounding box (domain)
  • maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
  • offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes and that you add noise.

Definition at line 461 of file Shortcuts.h.

462 {
463 return Parameters
464 ( "minAABB", -10.0 )
465 ( "maxAABB", 10.0 )
466 ( "gridstep", 1.0 )
467 ( "offset", 5.0 );
468 }

◆ parametersGeometryEstimation()

template<typename TKSpace >
static Parameters DGtal::ShortcutsGeometry< TKSpace >::parametersGeometryEstimation ( )
inlinestatic
Returns
the parameters and their default values which are used to estimate the geometry of a digital surface.
  • verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
  • t-ring [ 3.0]: the radius used when computing convolved trivial normals (it is a graph distance, not related to the grid step).
  • R-radius [ 10.0]: the constant for distance parameter R in R(h)=R h^alpha (VCM).
  • r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
  • kernel [ "hat"]: the kernel integration function chi_r, either "hat" or "ball". )
  • alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
  • surfelEmbedding [ 0]: the surfel -> point embedding for VCM estimator: 0: Pointels, 1: InnerSpel, 2: OuterSpel.

Definition at line 644 of file ShortcutsGeometry.h.

645 {
646 return Parameters
647 ( "verbose", 1 )
648 ( "t-ring", 3.0 )
649 ( "kernel", "hat" )
650 ( "R-radius", 10.0 )
651 ( "r-radius", 3.0 )
652 ( "alpha", 0.33 )
653 ( "surfelEmbedding", 0 );
654 }

Referenced by DGtal::ShortcutsGeometry< TKSpace >::defaultParameters(), and TEST_CASE().

◆ parametersKSpace()

template<typename TKSpace >
static Parameters DGtal::Shortcuts< TKSpace >::parametersKSpace ( )
inlinestatic
Returns
the parameters and their default values which are used for digitization.
  • closed [1 ]: specifies if the Khalimsky space is closed (!=0) or not (==0).
  • gridsizex[1.0]: specifies the space between points along x.
  • gridsizey[1.0]: specifies the space between points along y.
  • gridsizez[1.0]: specifies the space between points along z.

Definition at line 311 of file Shortcuts.h.

312 {
313 return Parameters
314 ( "closed", 1 )
315 ( "gridsizex", 1.0 )
316 ( "gridsizey", 1.0 )
317 ( "gridsizez", 1.0 );
318 }

◆ parametersShapeGeometry()

template<typename TKSpace >
static Parameters DGtal::ShortcutsGeometry< TKSpace >::parametersShapeGeometry ( )
inlinestatic
Returns
the parameters and their default values which are used to approximate the geometry of continuous shape.
  • projectionMaxIter [ 20]: the maximum number of iteration for the projection.
  • projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
  • projectionGamma [ 0.5]: the damping coefficient of the projection.
  • gridstep [ 1.0]: the gridstep that defines the digitization (often called h).

Definition at line 222 of file ShortcutsGeometry.h.

223 {
224 return Parameters
225 ( "projectionMaxIter", 20 )
226 ( "projectionAccuracy", 0.0001 )
227 ( "projectionGamma", 0.5 )
228 ( "gridstep", 1.0 );
229 }

Referenced by DGtal::ShortcutsGeometry< TKSpace >::defaultParameters().


The documentation for this class was generated from the following file: