DGtal  1.3.beta
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 >:
[legend]

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

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

Definition at line 165 of file ShortcutsGeometry.h.

◆ 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

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

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

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

Definition at line 131 of file ShortcutsGeometry.h.

◆ 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

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

Definition at line 166 of file ShortcutsGeometry.h.

◆ 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

Definition at line 184 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalDirectionEstimator

Definition at line 188 of file ShortcutsGeometry.h.

◆ TrueGaussianCurvatureEstimator

Definition at line 182 of file ShortcutsGeometry.h.

◆ TrueMeanCurvatureEstimator

Definition at line 180 of file ShortcutsGeometry.h.

◆ TrueNormalEstimator

Definition at line 178 of file ShortcutsGeometry.h.

◆ TruePositionEstimator

Definition at line 176 of file ShortcutsGeometry.h.

◆ TruePrincipalCurvaturesAndDirectionsEstimator

Definition at line 192 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalCurvatureEstimator

Definition at line 186 of file ShortcutsGeometry.h.

◆ 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
Image restoration and inpainting with Ambrosio-Tortorelli functional
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
Image restoration and inpainting with Ambrosio-Tortorelli functional
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
Image restoration and inpainting with Ambrosio-Tortorelli functional
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().

◆ 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
Image restoration and inpainting with Ambrosio-Tortorelli functional
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 699 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  }

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 439 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  }

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().

◆ 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 523 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  }

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().

◆ 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 398 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  }

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().

◆ 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  }

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  }

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

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

◆ 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::Shortcuts< 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  }

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

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

◆ 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::Shortcuts< 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  }

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  }

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

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

◆ 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::Shortcuts< 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  }

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  }

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

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

◆ 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::Shortcuts< TKSpace >::getKSpace(), and K.

◆ getKSpace() [1/6]

template<typename TKSpace >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace
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  }

◆ getKSpace() [2/6]

template<typename TKSpace >
template<typename TDigitalSurfaceContainer >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( typename TDigitalSurfaceContainer  )
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 397 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 ( typename TDigitalSurfaceContainer  )
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 408 of file Shortcuts.h.

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

◆ getKSpace() [4/6]

template<typename TKSpace >
static KSpace DGtal::Shortcuts< TKSpace >::getKSpace
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
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
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  }

◆ 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 358 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  }

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().

◆ 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 319 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  }

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().

◆ 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 251 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  }

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().

◆ 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 285 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  }

References DGtal::ImplicitPolynomial3Shape< TSpace >::nearestPoint().

◆ 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 608 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  }

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  }

◆ 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  }

◆ 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  }

◆ 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  }

References max().

◆ 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 481 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  }

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().

◆ 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 565 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  }

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().

◆ 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  }

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

◆ 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 );
675  t[ k ] = direct ? -1.0 : 1.0;
676  result.push_back( t );
677  }
678  return result;
679  }

References K, DGtal::KhalimskySpaceND< dim, TInteger >::sDirect(), DGtal::KhalimskySpaceND< dim, TInteger >::sOrthDir(), 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 755 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  }

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

◆ 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().

◆ 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:
DGtal::ShortcutsGeometry::getIINormalVectors
static RealVectors getIINormalVectors(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
Definition: ShortcutsGeometry.h:848
DGtal::PointVector::zero
static Self zero
Static const for zero PointVector.
Definition: PointVector.h:1595
DGtal::ShortcutsGeometry::TrueSecondPrincipalCurvatureEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalCurvatureFunctor > TrueSecondPrincipalCurvatureEstimator
Definition: ShortcutsGeometry.h:186
DGtal::ShortcutsGeometry::PositionFunctor
sgf::ShapePositionFunctor< ImplicitShape3D > PositionFunctor
Definition: ShortcutsGeometry.h:161
DGtal::ShortcutsGeometry::TruePrincipalCurvaturesAndDirectionsEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PrincipalCurvaturesAndDirectionsFunctor > TruePrincipalCurvaturesAndDirectionsEstimator
Definition: ShortcutsGeometry.h:192
max
int max(int a, int b)
Definition: testArithmeticalDSS.cpp:1108
DGtal::Trace::error
std::ostream & error()
DGtal::HyperRectDomain::upperBound
const Point & upperBound() const
DGtal::KhalimskySpaceND::init
bool init(const Point &lower, const Point &upper, bool isClosed)
Specifies the upper and lower bounds for the maximal cells in this space.
DGtal::InnerSpel
@ InnerSpel
Definition: VoronoiCovarianceMeasureOnDigitalSurface.h:58
DGtal::ShortcutsGeometry::TrueSecondPrincipalDirectionEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalDirectionFunctor > TrueSecondPrincipalDirectionEstimator
Definition: ShortcutsGeometry.h:190
DGtal::ShortcutsGeometry::Surfel
LightDigitalSurface::Surfel Surfel
Definition: ShortcutsGeometry.h:140
DGtal::trace
Trace trace
Definition: Common.h:154
DGtal::ShortcutsGeometry::CurvatureTensorQuantities
std::vector< CurvatureTensorQuantity > CurvatureTensorQuantities
Definition: ShortcutsGeometry.h:172
K
KSpace K
Definition: testCubicalComplex.cpp:62
DGtal::Dimension
DGtal::uint32_t Dimension
Definition: Common.h:137
DGtal::ShortcutsGeometry::getIIMeanCurvatures
static Scalars getIIMeanCurvatures(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
Definition: ShortcutsGeometry.h:981
DGtal::ShortcutsGeometry::getIIGaussianCurvatures
static Scalars getIIGaussianCurvatures(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
Definition: ShortcutsGeometry.h:1105
DGtal::ShortcutsGeometry::parametersATApproximation
static Parameters parametersATApproximation()
Definition: ShortcutsGeometry.h:1355
Functor
InHalfPlaneBySimple3x3Matrix< Point, double > Functor
Definition: testConvexHull2DReverse.cpp:51
DGtal::Surfel2PointEmbedding
Surfel2PointEmbedding
Possible embeddings for surfel as point(s)
Definition: VoronoiCovarianceMeasureOnDigitalSurface.h:58
DGtal::ShortcutsGeometry::KSpace
TKSpace KSpace
Digital cellular space.
Definition: ShortcutsGeometry.h:90
DGtal::ShortcutsGeometry::GaussianCurvatureFunctor
sgf::ShapeGaussianCurvatureFunctor< ImplicitShape3D > GaussianCurvatureFunctor
Definition: ShortcutsGeometry.h:164
DGtal::ShortcutsGeometry::parametersGeometryEstimation
static Parameters parametersGeometryEstimation()
Definition: ShortcutsGeometry.h:644
DGtal::ProbingMode::R
@ R
DGtal::KhalimskySpaceND::sDirect
bool sDirect(const SCell &p, Dimension k) const
Return 'true' if the direct orientation of [p] along [k] is in the positive coordinate direction.
DGtal::ShortcutsGeometry::RealPoints
std::vector< RealPoint > RealPoints
Definition: ShortcutsGeometry.h:157
DGtal::Trace::info
std::ostream & info()
DGtal::ShortcutsGeometry::TrueMeanCurvatureEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, MeanCurvatureFunctor > TrueMeanCurvatureEstimator
Definition: ShortcutsGeometry.h:180
Domain
HyperRectDomain< Space > Domain
Definition: testSimpleRandomAccessRangeFromPoint.cpp:44
DGtal::ShortcutsGeometry::Scalar
RealVector::Component Scalar
Floating-point numbers.
Definition: ShortcutsGeometry.h:104
DGtal::OuterSpel
@ OuterSpel
Definition: VoronoiCovarianceMeasureOnDigitalSurface.h:58
DGtal::ShortcutsGeometry::PrincipalCurvaturesAndDirectionsFunctor
sgf::ShapePrincipalCurvaturesAndDirectionsFunctor< ImplicitShape3D > PrincipalCurvaturesAndDirectionsFunctor
Definition: ShortcutsGeometry.h:169
DGtal::ShortcutsGeometry::MeanCurvatureFunctor
sgf::ShapeMeanCurvatureFunctor< ImplicitShape3D > MeanCurvatureFunctor
Definition: ShortcutsGeometry.h:163
DGtal::ShortcutsGeometry::Scalars
std::vector< Scalar > Scalars
Definition: ShortcutsGeometry.h:155
DGtal::Pointels
@ Pointels
Definition: VoronoiCovarianceMeasureOnDigitalSurface.h:58
DGtal::ShortcutsGeometry::orientVectors
static void orientVectors(RealVectors &v, const RealVectors &ref_v)
Definition: ShortcutsGeometry.h:1635
DGtal::KhalimskySpaceND::sOrthDir
Dimension sOrthDir(const SCell &s) const
Given a signed surfel [s], returns its orthogonal direction (ie, the coordinate where the surfel is c...
DGtal::Shortcuts::getKSpace
static KSpace getKSpace(const Point &low, const Point &up, Parameters params=parametersKSpace())
Definition: Shortcuts.h:332
DGtal::ShortcutsGeometry::DigitizedImplicitShape3D
GaussDigitizer< Space, ImplicitShape3D > DigitizedImplicitShape3D
defines the digitization of an implicit shape.
Definition: ShortcutsGeometry.h:118
domain
Domain domain
Definition: testProjection.cpp:88
DGtal::ShortcutsGeometry::NormalFunctor
sgf::ShapeNormalVectorFunctor< ImplicitShape3D > NormalFunctor
Definition: ShortcutsGeometry.h:162
DGtal::ShortcutsGeometry::getIIPrincipalCurvaturesAndDirections
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
Definition: ShortcutsGeometry.h:1230
DGtal::PointVector
Aim: Implements basic operations that will be used in Point and Vector classes.
Definition: PointVector.h:165
DGtal::ShortcutsGeometry::TrueFirstPrincipalDirectionEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalDirectionFunctor > TrueFirstPrincipalDirectionEstimator
Definition: ShortcutsGeometry.h:188
DGtal::ShortcutsGeometry::TrueGaussianCurvatureEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, GaussianCurvatureFunctor > TrueGaussianCurvatureEstimator
Definition: ShortcutsGeometry.h:182
DGtal::ShortcutsGeometry::ScalarStatistic
::DGtal::Statistic< Scalar > ScalarStatistic
Definition: ShortcutsGeometry.h:159
DGtal::ShortcutsGeometry::RealVectors
std::vector< RealVector > RealVectors
Definition: ShortcutsGeometry.h:156
DGtal::Trace::warning
std::ostream & warning()
DGtal::ShortcutsGeometry::TruePositionEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PositionFunctor > TruePositionEstimator
Definition: ShortcutsGeometry.h:176
DGtal::ShortcutsGeometry::FirstPrincipalCurvatureFunctor
sgf::ShapeFirstPrincipalCurvatureFunctor< ImplicitShape3D > FirstPrincipalCurvatureFunctor
Definition: ShortcutsGeometry.h:165
DGtal::ShortcutsGeometry::TrueNormalEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, NormalFunctor > TrueNormalEstimator
Definition: ShortcutsGeometry.h:178
DGtal::ShortcutsGeometry::SecondPrincipalCurvatureFunctor
sgf::ShapeSecondPrincipalCurvatureFunctor< ImplicitShape3D > SecondPrincipalCurvatureFunctor
Definition: ShortcutsGeometry.h:166
DGtal::ShortcutsGeometry::SecondPrincipalDirectionFunctor
sgf::ShapeSecondPrincipalDirectionFunctor< ImplicitShape3D > SecondPrincipalDirectionFunctor
Definition: ShortcutsGeometry.h:168
DGtal::ShortcutsGeometry::TrueFirstPrincipalCurvatureEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalCurvatureFunctor > TrueFirstPrincipalCurvatureEstimator
Definition: ShortcutsGeometry.h:184
DGtal::ShortcutsGeometry::parametersShapeGeometry
static Parameters parametersShapeGeometry()
Definition: ShortcutsGeometry.h:222
DGtal::ShortcutsGeometry::getTrivialNormalVectors
static RealVectors getTrivialNormalVectors(const KSpace &K, const SurfelRange &surfels)
Definition: ShortcutsGeometry.h:666
DGtal::HyperRectDomain::lowerBound
const Point & lowerBound() const
DGtal::ShortcutsGeometry::FirstPrincipalDirectionFunctor
sgf::ShapeFirstPrincipalDirectionFunctor< ImplicitShape3D > FirstPrincipalDirectionFunctor
Definition: ShortcutsGeometry.h:167
DGtal::KhalimskySpaceND
Aim: This class is a model of CCellularGridSpaceND. It represents the cubical grid as a cell complex,...
Definition: KhalimskySpaceND.h:64