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.

typedef KSpace::Space	Space
	Digital space.

typedef Space::Integer	Integer
	Integer numbers.

typedef Space::Point	Point
	Point with integer coordinates.

typedef Space::Vector	Vector
	Vector with integer coordinates.

typedef Space::RealVector	RealVector
	Vector with floating-point coordinates.

typedef Space::RealPoint	RealPoint
	Point with floating-point coordinates.

typedef RealVector::Component	Scalar
	Floating-point numbers.

typedef HyperRectDomain< Space >	Domain
	An (hyper-)rectangular domain.

typedef unsigned char	GrayScale
	The type for 8-bits gray-scale elements.

typedef MPolynomial< Space::dimension, Scalar >	ScalarPolynomial
	defines a multi-variate polynomial : RealPoint -> Scalar

typedef ImplicitPolynomial3Shape< Space >	ImplicitShape3D

typedef GaussDigitizer< Space, ImplicitShape3D >	DigitizedImplicitShape3D
	defines the digitization of an implicit shape.

typedef ImageContainerBySTLVector< Domain, bool >	BinaryImage
	defines a black and white image with (hyper-)rectangular domain.

typedef ImageContainerBySTLVector< Domain, GrayScale >	GrayScaleImage
	defines a grey-level image with (hyper-)rectangular domain.

typedef ImageContainerBySTLVector< Domain, float >	FloatImage
	defines a float image with (hyper-)rectangular domain.

typedef ImageContainerBySTLVector< Domain, double >	DoubleImage
	defines a double image with (hyper-)rectangular domain.

typedef KSpace::SurfelSet	SurfelSet
	defines a set of surfels

typedef LightImplicitDigitalSurface< KSpace, BinaryImage >	LightSurfaceContainer

typedef ::DGtal::DigitalSurface< LightSurfaceContainer >	LightDigitalSurface
	defines a connected digital surface over a binary image.

typedef SetOfSurfels< KSpace, SurfelSet >	ExplicitSurfaceContainer
	defines a heavy container that represents any digital surface.

typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainer >	DigitalSurface
	defines an arbitrary digital surface over a binary image.

typedef IndexedDigitalSurface< ExplicitSurfaceContainer >	IdxDigitalSurface
	defines a connected or not indexed digital surface.

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< IdxSurfel >	IdxSurfelSet

typedef std::vector< Surfel >	SurfelRange

typedef std::vector< Cell >	CellRange

typedef std::vector< IdxSurfel >	IdxSurfelRange

typedef std::vector< Scalar >	Scalars

typedef std::vector< RealVector >	RealVectors

typedef std::vector< RealPoint >	RealPoints

typedef ::DGtal::Statistic< Scalar >	ScalarStatistic

typedef sgf::ShapePositionFunctor< ImplicitShape3D >	PositionFunctor

typedef sgf::ShapeNormalVectorFunctor< ImplicitShape3D >	NormalFunctor

typedef sgf::ShapeMeanCurvatureFunctor< ImplicitShape3D >	MeanCurvatureFunctor

typedef sgf::ShapeGaussianCurvatureFunctor< ImplicitShape3D >	GaussianCurvatureFunctor

typedef sgf::ShapeFirstPrincipalCurvatureFunctor< ImplicitShape3D >	FirstPrincipalCurvatureFunctor

typedef sgf::ShapeSecondPrincipalCurvatureFunctor< ImplicitShape3D >	SecondPrincipalCurvatureFunctor

typedef sgf::ShapeFirstPrincipalDirectionFunctor< ImplicitShape3D >	FirstPrincipalDirectionFunctor

typedef sgf::ShapeSecondPrincipalDirectionFunctor< ImplicitShape3D >	SecondPrincipalDirectionFunctor

typedef sgf::ShapePrincipalCurvaturesAndDirectionsFunctor< ImplicitShape3D >	PrincipalCurvaturesAndDirectionsFunctor

typedef functors::IIPrincipalCurvaturesAndDirectionsFunctor< Space >::Quantity	CurvatureTensorQuantity

typedef std::vector< CurvatureTensorQuantity >	CurvatureTensorQuantities

typedef CorrectedNormalCurrentComputer< RealPoint, RealVector >	CNCComputer

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PositionFunctor >	TruePositionEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, NormalFunctor >	TrueNormalEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, MeanCurvatureFunctor >	TrueMeanCurvatureEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, GaussianCurvatureFunctor >	TrueGaussianCurvatureEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalCurvatureFunctor >	TrueFirstPrincipalCurvatureEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalCurvatureFunctor >	TrueSecondPrincipalCurvatureEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalDirectionFunctor >	TrueFirstPrincipalDirectionEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalDirectionFunctor >	TrueSecondPrincipalDirectionEstimator

typedef TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PrincipalCurvaturesAndDirectionsFunctor >	TruePrincipalCurvaturesAndDirectionsEstimator

typedef ::DGtal::Mesh< RealPoint >	Mesh

typedef ::DGtal::TriangulatedSurface< RealPoint >	TriangulatedSurface

typedef ::DGtal::PolygonalSurface< RealPoint >	PolygonalSurface

typedef std::map< Surfel, IdxSurfel >	Surfel2Index

typedef std::map< Cell, IdxVertex >	Cell2Index

typedef DigitalSetByAssociativeContainer< Domain, std::unordered_set< typename Domain::Point > >	DigitalSet

typedef functors::NotPointPredicate< DigitalSet >	VoronoiPointPredicate

Public Types inherited from DGtal::Shortcuts< TKSpace >
typedef TKSpace	KSpace
	Digital cellular space.

typedef KSpace::Space	Space
	Digital space.

typedef Space::Integer	Integer
	Integer numbers.

typedef Space::Point	Point
	Point with integer coordinates.

typedef Space::Vector	Vector
	Vector with integer coordinates.

typedef Space::RealVector	RealVector
	Vector with floating-point coordinates.

typedef Space::RealPoint	RealPoint
	Point with floating-point coordinates.

typedef RealVector::Component	Scalar
	Floating-point numbers.

typedef HyperRectDomain< Space >	Domain
	An (hyper-)rectangular domain.

typedef unsigned char	GrayScale
	The type for 8-bits gray-scale elements.

typedef MPolynomial< Space::dimension, Scalar >	ScalarPolynomial
	defines a multi-variate polynomial : RealPoint -> Scalar

typedef ImplicitPolynomial3Shape< Space >	ImplicitShape3D

typedef GaussDigitizer< Space, ImplicitShape3D >	DigitizedImplicitShape3D
	defines the digitization of an implicit shape.

typedef ImageContainerBySTLVector< Domain, bool >	BinaryImage
	defines a black and white image with (hyper-)rectangular domain.

typedef ImageContainerBySTLVector< Domain, GrayScale >	GrayScaleImage
	defines a grey-level image with (hyper-)rectangular domain.

typedef ImageContainerBySTLVector< Domain, float >	FloatImage
	defines a float image with (hyper-)rectangular domain.

typedef ImageContainerBySTLVector< Domain, double >	DoubleImage
	defines a double image with (hyper-)rectangular domain.

typedef KSpace::SurfelSet	SurfelSet
	defines a set of surfels

typedef LightImplicitDigitalSurface< KSpace, BinaryImage >	LightSurfaceContainer

typedef ::DGtal::DigitalSurface< LightSurfaceContainer >	LightDigitalSurface
	defines a connected digital surface over a binary image.

typedef SetOfSurfels< KSpace, SurfelSet >	ExplicitSurfaceContainer
	defines a heavy container that represents any digital surface.

typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainer >	DigitalSurface
	defines an arbitrary digital surface over a binary image.

typedef IndexedDigitalSurface< ExplicitSurfaceContainer >	IdxDigitalSurface
	defines a connected or not indexed digital surface.

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< IdxSurfel >	IdxSurfelSet

typedef std::vector< SCell >	SCellRange

typedef std::vector< Cell >	CellRange

typedef CellRange	PointelRange

typedef SCellRange	SurfelRange

typedef std::vector< IdxSurfel >	IdxSurfelRange

typedef std::vector< Scalar >	Scalars

typedef std::vector< RealVector >	RealVectors

typedef std::vector< RealPoint >	RealPoints

typedef IdxVertex	Idx

typedef std::vector< IdxVertex >	IdxRange

typedef ::DGtal::Mesh< RealPoint >	Mesh

typedef ::DGtal::TriangulatedSurface< RealPoint >	TriangulatedSurface

typedef ::DGtal::PolygonalSurface< RealPoint >	PolygonalSurface

typedef ::DGtal::SurfaceMesh< RealPoint, RealPoint >	SurfaceMesh

typedef std::map< Surfel, IdxSurfel >	Surfel2Index

typedef std::map< Cell, IdxVertex >	Cell2Index

typedef ::DGtal::Color	Color

typedef std::vector< Color >	Colors

typedef GradientColorMap< Scalar >	ColorMap

typedef TickedColorMap< Scalar, ColorMap >	ZeroTickedColorMap

Public Member Functions
Standard services
	ShortcutsGeometry ()=delete

	~ShortcutsGeometry ()=delete

	ShortcutsGeometry (const ShortcutsGeometry &other)=delete

	ShortcutsGeometry (ShortcutsGeometry &&other)=delete

ShortcutsGeometry &	operator= (const ShortcutsGeometry &other)=delete

ShortcutsGeometry &	operator= (ShortcutsGeometry &&other)=delete

Public Member Functions inherited from DGtal::Shortcuts< TKSpace >
	Shortcuts ()=delete

	~Shortcuts ()=delete

	Shortcuts (const Shortcuts &other)=delete

	Shortcuts (Shortcuts &&other)=delete

Shortcuts &	operator= (const Shortcuts &other)=delete

Shortcuts &	operator= (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	getCNCMeanCurvatures (CountedPtr< typename Base::SurfaceMesh > mesh, const typename Base::SurfaceMesh::Faces faces, const Parameters &params=parametersShapeGeometry())

static Scalars	getCNCMeanCurvatures (CountedPtr< typename Base::SurfaceMesh > mesh, const Parameters &params=parametersShapeGeometry())

template<typename T >
static Scalars	getCNCMeanCurvatures (T &digitalObject, const Parameters &params=parametersShapeGeometry())

static Scalars	getGaussianCurvatures (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())

static Scalars	getCNCGaussianCurvatures (CountedPtr< typename Base::SurfaceMesh > mesh, const typename Base::SurfaceMesh::Faces &faces, const Parameters &params=parametersShapeGeometry())

static Scalars	getCNCGaussianCurvatures (CountedPtr< typename Base::SurfaceMesh > mesh, const Parameters &params=parametersShapeGeometry())

template<typename T >
static Scalars	getCNCGaussianCurvatures (T &digitalObject, 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())

static std::tuple< Scalars, Scalars, RealVectors, RealVectors >	getCNCPrincipalCurvaturesAndDirections (CountedPtr< typename Base::SurfaceMesh > mesh, const typename Base::SurfaceMesh::Faces &faces, const Parameters &params=parametersShapeGeometry())

static std::tuple< Scalars, Scalars, RealVectors, RealVectors >	getCNCPrincipalCurvaturesAndDirections (CountedPtr< typename Base::SurfaceMesh > mesh, const Parameters &params=parametersShapeGeometry())

template<typename T >
static std::tuple< Scalars, Scalars, RealVectors, RealVectors >	getCNCPrincipalCurvaturesAndDirections (T &digitalObject, 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)

VoronoiMap services
static Parameters	parametersVoronoiMap ()

template<uint32_t p, typename PointRange >
static VoronoiMap< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > >	getVoronoiMap (Domain domain, const PointRange &sites, const Parameters &params=parametersVoronoiMap())
	Computes the VoronoiMap on a domain, where sites are given through a range.

template<uint32_t p, typename PointRange >
static VoronoiMap< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > >	getVoronoiMap (CountedPtr< Domain > domain, const PointRange &sites, const Parameters &params=parametersVoronoiMap())
	Computes the VoronoiMap on a domain, where sites are given through a range.

template<uint32_t p, typename PointRange >
static DistanceTransformation< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > >	getDistanceTransformation (Domain domain, const PointRange &sites, const Parameters &params=parametersVoronoiMap())
	Computes the Distance Transformation on a domain, where sites are given through a range.

template<uint32_t p, typename PointRangeSites , typename PointRange >
static std::vector< Vector >	getDirectionToClosestSite (const PointRange &points, const PointRangeSites &sites, const Parameters &params=parametersVoronoiMap())
	Computes the vector to the closest site from a range of points.

template<uint32_t p, typename PointRangeSites , typename PointRange >
static std::vector< typename ExactPredicateLpSeparableMetric< Space, p >::Value >	getDistanceToClosestSite (const PointRange &points, const PointRangeSites &sites, const Parameters &params=parametersVoronoiMap())
	Computes the distances to the closest site from a range of points.

template<uint32_t p, typename PointRangeSites , typename PointRange >
static std::vector< typename ExactPredicateLpSeparableMetric< Space, p >::Value >	getRawDistanceToClosestSite (const PointRange &points, const PointRangeSites &sites, const Parameters &params=parametersVoronoiMap())
	Computes the raw distances to the closest site from a range of points.

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< ImplicitShape3D >	makeImplicitShape3D (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 KSpace &	refKSpace (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)

template<typename TDigitalSurfaceContainer >
static const KSpace &	refKSpace (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)

static CanonicCellEmbedder< KSpace >	getCellEmbedder (const KSpace &K)

static CanonicSCellEmbedder< KSpace >	getSCellEmbedder (const KSpace &K)

static Parameters	parametersDigitizedImplicitShape3D ()

static KSpace	getKSpace (Parameters params=parametersKSpace()\|parametersDigitizedImplicitShape3D())

static CountedPtr< DigitizedImplicitShape3D >	makeDigitizedImplicitShape3D (CountedPtr< ImplicitShape3D > shape, Parameters params=parametersDigitizedImplicitShape3D())

static Parameters	parametersBinaryImage ()

static CountedPtr< BinaryImage >	makeBinaryImage (Domain shapeDomain)

static CountedPtr< BinaryImage >	makeBinaryImage (CountedPtr< DigitizedImplicitShape3D > shape_digitization, Parameters params=parametersBinaryImage())

static CountedPtr< BinaryImage >	makeBinaryImage (CountedPtr< DigitizedImplicitShape3D > shape_digitization, Domain shapeDomain, Parameters params=parametersBinaryImage())

static CountedPtr< BinaryImage >	makeBinaryImage (CountedPtr< BinaryImage > bimage, Parameters params=parametersBinaryImage())

static CountedPtr< BinaryImage >	makeBinaryImage (std::string input, Parameters params=parametersBinaryImage())

template<typename T , typename __U = std::enable_if_t<std::is_arithmetic_v<T>>>
static CountedPtr< BinaryImage >	makeBinaryImage (const std::vector< T > &values, const Domain &d)

template<typename T , template< class... > class C1, template< class... > class C2, template< class... > class C3>
static CountedPtr< BinaryImage >	makeBinaryImage (const C1< C2< C3< T > > > &values, std::optional< Domain > override_domain=std::nullopt)

template<typename T , std::enable_if_t<!is_double_nested_container< T >::value, int > = 0>
static CountedPtr< BinaryImage >	makeBinaryImage (const std::vector< T > &positions, std::optional< Domain > override_domain=std::nullopt)

static CountedPtr< BinaryImage >	makeBinaryImage (CountedPtr< GrayScaleImage > gray_scale_image, Parameters params=parametersBinaryImage())

static bool	saveBinaryImage (CountedPtr< BinaryImage > bimage, std::string output)

static Parameters	parametersGrayScaleImage ()

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (Domain aDomain)

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (std::string input)

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (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< GrayScaleImage >	makeGrayScaleImage (CountedPtr< FloatImage > fimage, Parameters params=parametersGrayScaleImage())

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (CountedPtr< DoubleImage > fimage, Parameters params=parametersGrayScaleImage())

template<typename T , typename __U = std::enable_if_t<std::is_arithmetic_v<T>>>
static CountedPtr< GrayScaleImage >	makeGrayScaleImage (const std::vector< T > &values, const Domain &d)

template<typename T , template< class... > class C1, template< class... > class C2, template< class... > class C3>
static CountedPtr< GrayScaleImage >	makeGrayScaleImage (const C1< C2< C3< T > > > &values, std::optional< Domain > override_domain=std::nullopt)

template<typename T , typename U , std::enable_if_t<!is_double_nested_container< T >::value, int > = 0>
static CountedPtr< GrayScaleImage >	makeGrayScaleImage (const std::vector< T > &positions, const std::vector< U > &values, std::optional< Domain > override_domain=std::nullopt)

static CountedPtr< FloatImage >	makeFloatImage (Domain aDomain)

static CountedPtr< FloatImage >	makeFloatImage (std::string input)

static CountedPtr< FloatImage >	makeFloatImage (CountedPtr< ImplicitShape3D > shape, Parameters params=parametersDigitizedImplicitShape3D())

static CountedPtr< DoubleImage >	makeDoubleImage (Domain aDomain)

static CountedPtr< DoubleImage >	makeDoubleImage (std::string input)

static CountedPtr< DoubleImage >	makeDoubleImage (CountedPtr< ImplicitShape3D > shape, Parameters params=parametersDigitizedImplicitShape3D())

static Parameters	parametersDigitalSurface ()

template<typename TDigitalSurfaceContainer >
static CanonicCellEmbedder< KSpace >	getCellEmbedder (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)

template<typename TDigitalSurfaceContainer >
static CanonicSCellEmbedder< KSpace >	getSCellEmbedder (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)

template<typename TDigitalSurfaceContainer >
static CanonicCellEmbedder< KSpace >	getCellEmbedder (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)

template<typename TDigitalSurfaceContainer >
static CanonicSCellEmbedder< KSpace >	getSCellEmbedder (CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface)

static CountedPtr< LightDigitalSurface >	makeLightDigitalSurface (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< DigitalSurface >	makeDigitalSurface (CountedPtr< TPointPredicate > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())

static CountedPtr< DigitalSurface >	makeDigitalSurface (CountedPtr< IdxDigitalSurface > idx_surface, const Parameters &params=parametersDigitalSurface())

static CountedPtr< IdxDigitalSurface >	makeIdxDigitalSurface (CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())

template<typename TSurfelRange >
static CountedPtr< IdxDigitalSurface >	makeIdxDigitalSurface (const TSurfelRange &surfels, ConstAlias< KSpace > K, const Parameters &params=parametersDigitalSurface())

template<typename TDigitalSurfaceContainer >
static CountedPtr< IdxDigitalSurface >	makeIdxDigitalSurface (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Parameters &params=parametersDigitalSurface())

static CountedPtr< IdxDigitalSurface >	makeIdxDigitalSurface (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< TriangulatedSurface >	makeTriangulatedSurface (CountedPtr< Mesh > aMesh)

static CountedPtr< Mesh >	makeMesh (CountedPtr< TriangulatedSurface > triSurf, const Color &aColor=Color::White)

static CountedPtr< Mesh >	makeMesh (CountedPtr< PolygonalSurface > polySurf, const Color &aColor=Color::White)

template<typename TContainer >
static CountedPtr< TriangulatedSurface >	makeTriangulatedSurface (Surfel2Index &s2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< TriangulatedSurface >	makeTriangulatedSurface (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

static CountedPtr< TriangulatedSurface >	makeTriangulatedSurface (CountedPtr< PolygonalSurface > polySurf, const Parameters &params=parametersMesh())

static CountedPtr< PolygonalSurface >	makePolygonalSurface (CountedPtr< Mesh > aMesh)

static CountedPtr< PolygonalSurface >	makePolygonalSurface (CountedPtr< GrayScaleImage > gray_scale_image, const Parameters &params=parametersKSpace()\|parametersBinaryImage()\|parametersDigitalSurface())

static CountedPtr< TriangulatedSurface >	makeTriangulatedSurface (CountedPtr< GrayScaleImage > gray_scale_image, const Parameters &params=parametersKSpace()\|parametersBinaryImage()\|parametersDigitalSurface())

template<typename TContainer >
static CountedPtr< PolygonalSurface >	makeDualPolygonalSurface (Surfel2Index &s2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< PolygonalSurface >	makeDualPolygonalSurface (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< PolygonalSurface >	makeDualPolygonalSurface (CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< PolygonalSurface >	makePrimalPolygonalSurface (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< PolygonalSurface >	makePrimalPolygonalSurface (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< PolygonalSurface >	makePrimalPolygonalSurface (CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< SurfaceMesh >	makePrimalSurfaceMesh (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< SurfaceMesh >	makePrimalSurfaceMesh (CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)

template<typename TContainer >
static CountedPtr< SurfaceMesh >	makePrimalSurfaceMesh (CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface)

static CountedPtr< SurfaceMesh >	makeSurfaceMesh (const std::string &path)

template<typename TPoint , typename TVector >
static bool	saveOBJ (CountedPtr< ::DGtal::SurfaceMesh< TPoint, TVector > > surf, const std::string &objfile)

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 , typename TVector >
static bool	saveOBJ (CountedPtr< ::DGtal::SurfaceMesh< TPoint, TVector > > surf, 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 >))

Static Private Member Functions
template<typename TEstimator , typename TFunctor , typename TPointPredicate >
static std::vector< typename TEstimator::Quantity >	getIICurvatureEstimation (const char *description, const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params)

static Domain::Dimension	getIIParallelSplitAxis (const Parameters &params)

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

TKSpace any 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 82 of file ShortcutsGeometry.h.

Member Typedef Documentation

◆ Arc

template<typename TKSpace >

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

Definition at line 150 of file ShortcutsGeometry.h.

◆ ArcRange

template<typename TKSpace >

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

Definition at line 152 of file ShortcutsGeometry.h.

◆ Base

template<typename TKSpace >

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

Definition at line 86 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 126 of file ShortcutsGeometry.h.

◆ Cell

template<typename TKSpace >

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

Definition at line 147 of file ShortcutsGeometry.h.

◆ Cell2Index

template<typename TKSpace >

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

Definition at line 205 of file ShortcutsGeometry.h.

◆ CellRange

template<typename TKSpace >

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

Definition at line 159 of file ShortcutsGeometry.h.

◆ CNCComputer

template<typename TKSpace >

typedef CorrectedNormalCurrentComputer<RealPoint, RealVector> DGtal::ShortcutsGeometry< TKSpace >::CNCComputer

Definition at line 180 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantities

template<typename TKSpace >

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

Definition at line 178 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantity

template<typename TKSpace >

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

Definition at line 177 of file ShortcutsGeometry.h.

◆ DigitalSet

template<typename TKSpace >

typedef DigitalSetByAssociativeContainer<Domain, std::unordered_set<typename Domain::Point> > DGtal::ShortcutsGeometry< TKSpace >::DigitalSet

Definition at line 207 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 143 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 124 of file ShortcutsGeometry.h.

◆ Domain

template<typename TKSpace >

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

An (hyper-)rectangular domain.

Definition at line 112 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 132 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 141 of file ShortcutsGeometry.h.

◆ Face

template<typename TKSpace >

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

Definition at line 151 of file ShortcutsGeometry.h.

◆ FirstPrincipalCurvatureFunctor

template<typename TKSpace >

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

Definition at line 171 of file ShortcutsGeometry.h.

◆ FirstPrincipalDirectionFunctor

template<typename TKSpace >

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

Definition at line 173 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 130 of file ShortcutsGeometry.h.

◆ GaussianCurvatureFunctor

template<typename TKSpace >

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

Definition at line 170 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 114 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 128 of file ShortcutsGeometry.h.

◆ IdxArc

template<typename TKSpace >

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

Definition at line 155 of file ShortcutsGeometry.h.

◆ IdxArcRange

template<typename TKSpace >

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

Definition at line 156 of file ShortcutsGeometry.h.

◆ IdxDigitalSurface

template<typename TKSpace >

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

defines a connected or not indexed digital surface.

Definition at line 145 of file ShortcutsGeometry.h.

◆ IdxSurfel

template<typename TKSpace >

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

Definition at line 153 of file ShortcutsGeometry.h.

◆ IdxSurfelRange

template<typename TKSpace >

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

Definition at line 160 of file ShortcutsGeometry.h.

◆ IdxSurfelSet

template<typename TKSpace >

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

Definition at line 157 of file ShortcutsGeometry.h.

◆ IdxVertex

template<typename TKSpace >

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

Definition at line 154 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 122 of file ShortcutsGeometry.h.

◆ Integer

template<typename TKSpace >

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

Integer numbers.

Definition at line 100 of file ShortcutsGeometry.h.

◆ KSpace

template<typename TKSpace >

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

Digital cellular space.

Definition at line 96 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 139 of file ShortcutsGeometry.h.

◆ LightSurfaceContainer

template<typename TKSpace >

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

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

Definition at line 137 of file ShortcutsGeometry.h.

◆ MeanCurvatureFunctor

template<typename TKSpace >

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

Definition at line 169 of file ShortcutsGeometry.h.

◆ Mesh

template<typename TKSpace >

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

Definition at line 201 of file ShortcutsGeometry.h.

◆ NormalFunctor

template<typename TKSpace >

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

Definition at line 168 of file ShortcutsGeometry.h.

◆ Point

template<typename TKSpace >

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

Point with integer coordinates.

Definition at line 102 of file ShortcutsGeometry.h.

◆ PolygonalSurface

template<typename TKSpace >

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

Definition at line 203 of file ShortcutsGeometry.h.

◆ PositionFunctor

template<typename TKSpace >

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

Definition at line 167 of file ShortcutsGeometry.h.

◆ PrincipalCurvaturesAndDirectionsFunctor

template<typename TKSpace >

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

Definition at line 175 of file ShortcutsGeometry.h.

◆ RealPoint

template<typename TKSpace >

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

Point with floating-point coordinates.

Definition at line 108 of file ShortcutsGeometry.h.

◆ RealPoints

template<typename TKSpace >

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

Definition at line 163 of file ShortcutsGeometry.h.

◆ RealVector

template<typename TKSpace >

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

Vector with floating-point coordinates.

Definition at line 106 of file ShortcutsGeometry.h.

◆ RealVectors

template<typename TKSpace >

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

Definition at line 162 of file ShortcutsGeometry.h.

◆ Scalar

template<typename TKSpace >

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

Floating-point numbers.

Definition at line 110 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 119 of file ShortcutsGeometry.h.

◆ Scalars

template<typename TKSpace >

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

Definition at line 161 of file ShortcutsGeometry.h.

◆ ScalarStatistic

template<typename TKSpace >

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

Definition at line 165 of file ShortcutsGeometry.h.

◆ SCell

template<typename TKSpace >

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

Definition at line 148 of file ShortcutsGeometry.h.

◆ SecondPrincipalCurvatureFunctor

template<typename TKSpace >

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

Definition at line 172 of file ShortcutsGeometry.h.

◆ SecondPrincipalDirectionFunctor

template<typename TKSpace >

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

Definition at line 174 of file ShortcutsGeometry.h.

◆ Self

template<typename TKSpace >

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

Definition at line 87 of file ShortcutsGeometry.h.

◆ Space

template<typename TKSpace >

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

Digital space.

Definition at line 98 of file ShortcutsGeometry.h.

◆ Surfel

template<typename TKSpace >

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

Definition at line 146 of file ShortcutsGeometry.h.

◆ Surfel2Index

template<typename TKSpace >

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

Definition at line 204 of file ShortcutsGeometry.h.

◆ SurfelRange

template<typename TKSpace >

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

Definition at line 158 of file ShortcutsGeometry.h.

◆ SurfelSet

template<typename TKSpace >

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

defines a set of surfels

Definition at line 134 of file ShortcutsGeometry.h.

◆ TriangulatedSurface

template<typename TKSpace >

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

Definition at line 202 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalCurvatureEstimator

template<typename TKSpace >

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

Definition at line 191 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalDirectionEstimator

template<typename TKSpace >

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

Definition at line 195 of file ShortcutsGeometry.h.

◆ TrueGaussianCurvatureEstimator

template<typename TKSpace >

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

Definition at line 189 of file ShortcutsGeometry.h.

◆ TrueMeanCurvatureEstimator

template<typename TKSpace >

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

Definition at line 187 of file ShortcutsGeometry.h.

◆ TrueNormalEstimator

template<typename TKSpace >

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

Definition at line 185 of file ShortcutsGeometry.h.

◆ TruePositionEstimator

template<typename TKSpace >

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

Definition at line 183 of file ShortcutsGeometry.h.

◆ TruePrincipalCurvaturesAndDirectionsEstimator

template<typename TKSpace >

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

Definition at line 199 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalCurvatureEstimator

template<typename TKSpace >

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

Definition at line 193 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalDirectionEstimator

template<typename TKSpace >

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

Definition at line 197 of file ShortcutsGeometry.h.

◆ Vector

template<typename TKSpace >

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

Vector with integer coordinates.

Definition at line 104 of file ShortcutsGeometry.h.

◆ Vertex

template<typename TKSpace >

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

Definition at line 149 of file ShortcutsGeometry.h.

◆ VoronoiPointPredicate

template<typename TKSpace >

typedef functors::NotPointPredicate<DigitalSet> DGtal::ShortcutsGeometry< TKSpace >::VoronoiPointPredicate

Definition at line 208 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

other the object to clone.

◆ ShortcutsGeometry() [3/3]

template<typename TKSpace >

DGtal::ShortcutsGeometry< TKSpace >::ShortcutsGeometry ( ShortcutsGeometry< TKSpace > && other )

delete

Move constructor.

Parameters

other the 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

Returns: the parameters used in ShortcutsGeometry.

Definition at line 219 of file ShortcutsGeometry.h.

      {
        return parametersShapeGeometry()
          | parametersGeometryEstimation()
          | parametersATApproximation()
          | parametersVoronoiMap();
      }

References DGtal::ShortcutsGeometry< TKSpace >::parametersATApproximation(), DGtal::ShortcutsGeometry< TKSpace >::parametersGeometryEstimation(), DGtal::ShortcutsGeometry< TKSpace >::parametersShapeGeometry(), and DGtal::ShortcutsGeometry< TKSpace >::parametersVoronoiMap().

Referenced by main(), and precompute().

◆ 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: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

TAnyDigitalSurface either kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 minimization 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]	input	the input scalar field (a vector of scalar values)

Returns: the piecewise-smooth approximation of input.

Definition at line 1902 of file ShortcutsGeometry.h.

      {
        (void)surface; //param not used FIXME: JOL
 
        int      verbose   = params[ "verbose"          ].as<int>();
        Scalar   alpha_at  = params[ "at-alpha"         ].as<Scalar>();
        Scalar   lambda_at = params[ "at-lambda"        ].as<Scalar>();
        Scalar   epsilon1  = params[ "at-epsilon-start" ].as<Scalar>();
        Scalar   epsilon2  = params[ "at-epsilon"       ].as<Scalar>();
        Scalar   epsilonr  = params[ "at-epsilon-ratio" ].as<Scalar>();
        int      max_iter  = params[ "at-max-iter"      ].as<int>();
        Scalar   diff_v_max= params[ "at-diff-v-max"    ].as<Scalar>();
        typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
        const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
        ATSolver2D< KSpace > at_solver( calculus, verbose );
        at_solver.initInputScalarFieldU2( input, surfels.cbegin(), surfels.cend() );
        at_solver.setUp( alpha_at, lambda_at );
        at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
        auto output = input;
        at_solver.getOutputScalarFieldU2( output, surfels.cbegin(), surfels.cend() );
        return output;
      }

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

◆ 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: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

TAnyDigitalSurface	either kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
CellRangeConstIterator	the type of iterator for traversing a range of cells

Parameters

[out]	features	the 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]	itB	the start of the range of cells.
[in]	itE	past the end of the range of cells.
[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 minimization 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 outputting feature vector v onto cells: "Average"\|"Minimum"\|"Maximum"
[in]	input	the input scalar field (a vector of scalar values)

Returns: the piecewise-smooth approximation of input.

Definition at line 1967 of file ShortcutsGeometry.h.

      {
        (void)surface; //param not used FIXME: JOL
 
        int      verbose   = params[ "verbose"          ].as<int>();
        Scalar   alpha_at  = params[ "at-alpha"         ].as<Scalar>();
        Scalar   lambda_at = params[ "at-lambda"        ].as<Scalar>();
        Scalar   epsilon1  = params[ "at-epsilon-start" ].as<Scalar>();
        Scalar   epsilon2  = params[ "at-epsilon"       ].as<Scalar>();
        Scalar   epsilonr  = params[ "at-epsilon-ratio" ].as<Scalar>();
        int      max_iter  = params[ "at-max-iter"      ].as<int>();
        Scalar   diff_v_max= params[ "at-diff-v-max"    ].as<Scalar>();
        std::string policy = params[ "at-v-policy"      ].as<std::string>();
        typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
        const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
        ATSolver2D< KSpace > at_solver( calculus, verbose );
        at_solver.initInputScalarFieldU2( input, surfels.cbegin(), surfels.cend() );
        at_solver.setUp( alpha_at, lambda_at );
        at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
        auto output = input;
        at_solver.getOutputScalarFieldU2( output, surfels.cbegin(), surfels.cend() );
        auto p = ( policy == "Average" ) ? at_solver.Average
          :      ( policy == "Minimum" ) ? at_solver.Minimum
          :                                at_solver.Maximum;
        at_solver.getOutputScalarFieldV0( features, itB, itE, p );
        return output;
      }

◆ 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: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

TAnyDigitalSurface	either kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
VectorFieldInput	the type of vector field for input values (RandomAccess container)

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 minimization 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]	input	the input vector field (a vector of vector values)

Returns: the piecewise-smooth approximation of input.

Definition at line 1779 of file ShortcutsGeometry.h.

      {
        (void)surface; //param not used. FIXME: JOL
 
        int      verbose   = params[ "verbose"          ].as<int>();
        Scalar   alpha_at  = params[ "at-alpha"         ].as<Scalar>();
        Scalar   lambda_at = params[ "at-lambda"        ].as<Scalar>();
        Scalar   epsilon1  = params[ "at-epsilon-start" ].as<Scalar>();
        Scalar   epsilon2  = params[ "at-epsilon"       ].as<Scalar>();
        Scalar   epsilonr  = params[ "at-epsilon-ratio" ].as<Scalar>();
        int      max_iter  = params[ "at-max-iter"      ].as<int>();
        Scalar   diff_v_max= params[ "at-diff-v-max"    ].as<Scalar>();
        typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
        const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
        ATSolver2D< KSpace > at_solver( calculus, verbose );
        at_solver.initInputVectorFieldU2( input, surfels.cbegin(), surfels.cend() );
        at_solver.setUp( alpha_at, lambda_at );
        at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
        auto output = input;
        at_solver.getOutputVectorFieldU2( output, surfels.cbegin(), surfels.cend() );
        return output;
      }

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

◆ 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: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

TAnyDigitalSurface	either kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.
VectorFieldInput	the type of vector field for input values (RandomAccess container)
CellRangeConstIterator	the type of iterator for traversing a range of cells

Parameters

[out]	features	the 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]	itB	the start of the range of cells.
[in]	itE	past the end of the range of cells.
[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 minimization 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 outputting feature vector v onto cells: "Average"\|"Minimum"\|"Maximum"
[in]	input	the input vector field (a vector of vector values)

Returns: the piecewise-smooth approximation of input.

Definition at line 1841 of file ShortcutsGeometry.h.

      {
        (void)surface; //param not used FIXME: JOL
 
        int      verbose   = params[ "verbose"          ].as<int>();
        Scalar   alpha_at  = params[ "at-alpha"         ].as<Scalar>();
        Scalar   lambda_at = params[ "at-lambda"        ].as<Scalar>();
        Scalar   epsilon1  = params[ "at-epsilon-start" ].as<Scalar>();
        Scalar   epsilon2  = params[ "at-epsilon"       ].as<Scalar>();
        Scalar   epsilonr  = params[ "at-epsilon-ratio" ].as<Scalar>();
        int      max_iter  = params[ "at-max-iter"      ].as<int>();
        Scalar   diff_v_max= params[ "at-diff-v-max"    ].as<Scalar>();
        std::string policy = params[ "at-v-policy"      ].as<std::string>();
        typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
        const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
        ATSolver2D< KSpace > at_solver( calculus, verbose );
        at_solver.initInputVectorFieldU2( input, surfels.cbegin(), surfels.cend() );
        at_solver.setUp( alpha_at, lambda_at );
        at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
        auto output = input;
        at_solver.getOutputVectorFieldU2( output, surfels.cbegin(), surfels.cend() );
        auto p = ( policy == "Average" ) ? at_solver.Average
          :      ( policy == "Minimum" ) ? at_solver.Minimum
          :                                at_solver.Maximum;
        at_solver.getOutputScalarFieldV0( features, itB, itE, p );
        return output;
      }

◆ getCNCGaussianCurvatures() [1/3]

template<typename TKSpace >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getCNCGaussianCurvatures	(	CountedPtr< typename Base::SurfaceMesh >	mesh,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute gaussian curvature at each face using CorrectedNormalCurrent method.

This overloads compute curvature for each face of the mesh.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Parameters

mesh	The surface mesh
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of the mesh, in then the order given by the mesh

Definition at line 591 of file ShortcutsGeometry.h.

      {
        std::vector<typename Base::SurfaceMesh::Face> allFaces(mesh->nbFaces());
        std::iota(allFaces.begin(), allFaces.end(), 0);
 
        return getCNCGaussianCurvatures(mesh, allFaces, params);
      }

References DGtal::ShortcutsGeometry< TKSpace >::getCNCGaussianCurvatures().

◆ getCNCGaussianCurvatures() [2/3]

template<typename TKSpace >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getCNCGaussianCurvatures	(	CountedPtr< typename Base::SurfaceMesh >	mesh,
		const typename Base::SurfaceMesh::Faces &	faces,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute gaussian curvature at each face using CorrectedNormalCurrent method.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Parameters

mesh	The surface mesh
faces	The faces to compute curvature at
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of the mesh, in the same order faces

Definition at line 544 of file ShortcutsGeometry.h.

      {
        bool unit_u = params["unit_u"].as<int>();
        double radius = params["r-radius"].as<double>();
        double alpha  = params["alpha"].as<double>();
        double h      = params["gridstep"].as<double>();
        if ( alpha != 1.0 ) radius *= pow( h, alpha-1.0 );
 
        CNCComputer computer(*mesh, unit_u);
 
        const auto& mu0 = computer.computeMu0();
        const auto& mu2 = computer.computeMu2();
 
        Scalars curvatures(faces.size());
        for (size_t i = 0; i < faces.size(); ++i)
        {
          const auto center = mesh->faceCentroid(faces[i]);
          const auto area = mu0.measure(center, radius, faces[i]);
          const auto lmu2 = mu2.measure(center, radius, faces[i]);
          curvatures[i] = CNCComputer::GaussianCurvature(area, lmu2);
        }
 
        return curvatures;
      }

References DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::computeMu0(), DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::computeMu2(), and DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::GaussianCurvature().

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

◆ getCNCGaussianCurvatures() [3/3]

template<typename TKSpace >

template<typename T >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getCNCGaussianCurvatures	(	T &	digitalObject,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute mean curvature at each face using CorrectedNormalCurrent method.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Template Parameters

T	Any digital object convertible to surface mesh via Shortcuts::makePrimalSurfaceMesh

Parameters

digitalObject	A digital object
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of the triangulated surface object

Definition at line 620 of file ShortcutsGeometry.h.

      {
        CountedPtr<typename Base::SurfaceMesh> mesh = Base::makePrimalSurfaceMesh(digitalObject);
        return getCNCGaussianCurvatures(mesh, params);
      }

References DGtal::ShortcutsGeometry< TKSpace >::getCNCGaussianCurvatures(), and DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh().

◆ getCNCMeanCurvatures() [1/3]

template<typename TKSpace >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getCNCMeanCurvatures	(	CountedPtr< typename Base::SurfaceMesh >	mesh,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute mean curvature at each face using CorrectedNormalCurrent method.

This overloads compute curvature for each face of the mesh.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Parameters

mesh	The surface mesh
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of mesh, in the the order given by the mesh

Definition at line 450 of file ShortcutsGeometry.h.

      {
        std::vector<typename Base::SurfaceMesh::Face> allFaces(mesh->nbFaces());
        std::iota(allFaces.begin(), allFaces.end(), 0);
 
        return getCNCMeanCurvatures(mesh, allFaces, params);
      }

References DGtal::ShortcutsGeometry< TKSpace >::getCNCMeanCurvatures().

◆ getCNCMeanCurvatures() [2/3]

template<typename TKSpace >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getCNCMeanCurvatures	(	CountedPtr< typename Base::SurfaceMesh >	mesh,
		const typename Base::SurfaceMesh::Faces	faces,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute mean curvature at each face using CorrectedNormalCurrent method.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Parameters

mesh	The surface mesh
faces	The faces to compute curvature at
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of the mesh, in the same order faces

Definition at line 403 of file ShortcutsGeometry.h.

      {
        bool unit_u = params["unit_u"].as<int>();
        double radius = params["r-radius"].as<double>();
        double alpha  = params["alpha"].as<double>();
        double h      = params["gridstep"].as<double>();
        if ( alpha != 1.0 ) radius *= pow( h, alpha-1.0 );
 
        CNCComputer computer(*mesh, unit_u);
 
        const auto& mu0 = computer.computeMu0();
        const auto& mu1 = computer.computeMu1();
 
        Scalars curvatures(faces.size());
        for (size_t i = 0; i < faces.size(); ++i)
        {
          const auto center = mesh->faceCentroid(faces[i]);
          const auto area = mu0.measure(center, radius, faces[i]);
          const auto lmu1 = mu1.measure(center, radius, faces[i]);
          curvatures[i] = CNCComputer::meanCurvature(area, lmu1);
        }
 
        return curvatures;
      }

References DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::computeMu0(), DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::computeMu1(), and DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::meanCurvature().

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

◆ getCNCMeanCurvatures() [3/3]

template<typename TKSpace >

template<typename T >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getCNCMeanCurvatures	(	T &	digitalObject,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute mean curvature at each face using CorrectedNormalCurrent method.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Template Parameters

Any	digital object convertible to surface mesh via Shortcuts::makePrimalSurfaceMesh

Parameters

digitalObject	A digital object
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of the triangulated surface object

Definition at line 479 of file ShortcutsGeometry.h.

      {
        CountedPtr<typename Base::SurfaceMesh> mesh = Base::makePrimalSurfaceMesh(digitalObject);
        return getCNCMeanCurvatures(mesh, params);
      }

References DGtal::ShortcutsGeometry< TKSpace >::getCNCMeanCurvatures(), and DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh().

◆ getCNCPrincipalCurvaturesAndDirections() [1/3]

template<typename TKSpace >

static std::tuple< Scalars, Scalars, RealVectors, RealVectors > DGtal::ShortcutsGeometry< TKSpace >::getCNCPrincipalCurvaturesAndDirections	(	CountedPtr< typename Base::SurfaceMesh >	mesh,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute principal curvature at each face using CorrectedNormalCurrent method.

This overloads compute curvature for each face of the mesh.

Note: If no normals are provided for the faces, the normals will be computed (and set) using vertex normals if they exist and positions otherwise.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Parameters

[in,out]	mesh	The surface mesh. The mesh will be modified if no face normals are provided.
[in]	params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The principal curvatures for each face of the mesh, in the same order as mesh faces. The result is a 4-element tuples: [first curvatures, second curvatures, first directions, second directions].

Definition at line 929 of file ShortcutsGeometry.h.

        {
          std::vector<typename Base::SurfaceMesh::Face> allFaces(mesh->nbFaces());
          std::iota(allFaces.begin(), allFaces.end(), 0);
 
          return getCNCPrincipalCurvaturesAndDirections(mesh, allFaces, params);
        }

References DGtal::ShortcutsGeometry< TKSpace >::getCNCPrincipalCurvaturesAndDirections().

◆ getCNCPrincipalCurvaturesAndDirections() [2/3]

template<typename TKSpace >

static std::tuple< Scalars, Scalars, RealVectors, RealVectors > DGtal::ShortcutsGeometry< TKSpace >::getCNCPrincipalCurvaturesAndDirections	(	CountedPtr< typename Base::SurfaceMesh >	mesh,
		const typename Base::SurfaceMesh::Faces &	faces,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute principal curvature at each face using CorrectedNormalCurrent method.

Note: If no normals are provided for the faces, the normals will be computed (and set) using vertex normals if they exist and positions otherwise.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Parameters

[in,out]	mesh	The surface mesh. The mesh will be modified if no face normals are provided.
[in]	faces	The faces to compute curvature at
[in]	params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The principal curvatures for each face of the mesh, in the same order as faces. The result is a 4-element tuples: [first curvatures, second curvatures, first directions, second directions].

Definition at line 861 of file ShortcutsGeometry.h.

        {
          bool unit_u = params["unit_u"].as<int>();
          double radius = params["r-radius"].as<double>();
          double alpha  = params["alpha"].as<double>();
          double h      = params["gridstep"].as<double>();
          if ( alpha != 1.0 ) radius *= pow( h, alpha-1.0 );
 
          CNCComputer computer(*mesh, unit_u);
 
          const auto& mu0  = computer.computeMu0();
          const auto& muxy = computer.computeMuXY();
 
          if (mesh->faceNormals().size() == 0)
          {
            // Try to use vertex normals if any
            if (mesh->vertexNormals().size() == 0)
              mesh->computeFaceNormalsFromPositions();
            else
              mesh->computeFaceNormalsFromVertexNormals();
          }
 
          const auto& normals = mesh->faceNormals();
 
          Scalars k1(faces.size()), k2(faces.size());
          RealVectors d1(faces.size()), d2(faces.size());
 
          for (size_t i = 0; i < faces.size(); ++i)
          {
            const auto center = mesh->faceCentroid(faces[i]);
            const auto area  = mu0 .measure(center, radius, faces[i]);
            const auto lmuxy = muxy.measure(center, radius, faces[i]);
            std::tie(k1[i], k2[i], d1[i], d2[i]) =
                CNCComputer::principalCurvatures(area, lmuxy, normals[faces[i]]);
          }
 
          return std::make_tuple(k1, k2, d1, d2);
        }

References DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::computeMu0(), DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::computeMuXY(), and DGtal::CorrectedNormalCurrentComputer< TRealPoint, TRealVector >::principalCurvatures().

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

◆ getCNCPrincipalCurvaturesAndDirections() [3/3]

template<typename TKSpace >

template<typename T >

static std::tuple< Scalars, Scalars, RealVectors, RealVectors > DGtal::ShortcutsGeometry< TKSpace >::getCNCPrincipalCurvaturesAndDirections	(	T &	digitalObject,
		const Parameters &	params = `parametersShapeGeometry()`
	)

inlinestatic

Given a SurfaceMesh, compute principal curvature at each face using CorrectedNormalCurrent method.

Warning: In this code, only triangles with barycenters strictly inside the sphere are considered.

Template Parameters

T	Any digital object convertible to surface mesh via Shortcuts::makePrimalSurfaceMesh

Parameters

digitalObject	A digital object
params	unit_u: Whether the computed normals should be normalized or not 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, CNC)." gridstep [ 1.0]: the digitization gridstep (often denoted by h).

Returns: The curvatures for each face of the triangulated surface object

Definition at line 960 of file ShortcutsGeometry.h.

        {
          CountedPtr<typename Base::SurfaceMesh> mesh = Base::makePrimalSurfaceMesh(digitalObject);
          return getCNCPrincipalCurvaturesAndDirections(mesh, params);
        }

References DGtal::ShortcutsGeometry< TKSpace >::getCNCPrincipalCurvaturesAndDirections(), and DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh().

◆ 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

TAnyDigitalSurface either kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 1047 of file ShortcutsGeometry.h.

        {
          int    verbose = params[ "verbose"  ].as<int>();
          Scalar       t = params[ "t-ring"   ].as<double>();
          typedef typename TAnyDigitalSurface::DigitalSurfaceContainer  SurfaceContainer;
          typedef LpMetric<Space>                                       Metric;
          typedef functors::HatFunction<Scalar>                         Functor;
          typedef functors::ElementaryConvolutionNormalVectorEstimator
            < Surfel, CanonicSCellEmbedder<KSpace> >                    SurfelFunctor;
          typedef LocalEstimatorFromSurfelFunctorAdapter
            < SurfaceContainer, Metric, SurfelFunctor, Functor>         NormalEstimator;
          if ( verbose > 0 )
            trace.info() << "- CTrivial normal t-ring=" << t << " (discrete)" << std::endl;
          const Functor fct( 1.0, t );
          const KSpace &  K = surface->container().space();
          Metric    aMetric( 2.0 );
          CanonicSCellEmbedder<KSpace> canonic_embedder( K );
          std::vector< RealVector >    n_estimations;
          SurfelFunctor                surfelFct( canonic_embedder, 1.0 );
          NormalEstimator              estimator;
          estimator.attach( *surface);
          estimator.setParams( aMetric, surfelFct, fct, t );
          estimator.init( 1.0, surfels.begin(), surfels.end());
          estimator.eval( surfels.begin(), surfels.end(),
                          std::back_inserter( n_estimations ) );
          std::transform( n_estimations.cbegin(), n_estimations.cend(), n_estimations.begin(),
                          [] ( RealVector v ) { return -v; } );
          return n_estimations;
        }

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

◆ getDirectionToClosestSite()

template<typename TKSpace >

template<uint32_t p, typename PointRangeSites , typename PointRange >

static std::vector< Vector > DGtal::ShortcutsGeometry< TKSpace >::getDirectionToClosestSite	(	const PointRange &	points,
		const PointRangeSites &	sites,
		const Parameters &	params = `parametersVoronoiMap()`
	)

inlinestatic

Computes the vector to the closest site from a range of points.

Template Parameters

p	The exponent in the Lp metric
PointRange	The range of point
PointRangeSites	The range of sites

Parameters

points	The one to compute the closest site of
sites	The list of sites
params	Parameters

Returns: A vector of direction to the closest in the same order as 'points'.

Definition at line 2278 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using VoroMap = VoronoiMap<Space, VoronoiPointPredicate, Metric>;
 
        // Compute domain of points
        Point pmin = *points.begin();
        Point pmax = pmin;
 
        size_t pCount = 0;
        for (auto it = points.begin(); it != points.end(); ++it)
        {
          pCount ++;
          for (size_t i = 0; i < Space::dimension; ++i)
          {
            pmin[i] = std::min(pmin[i], (*it)[i] - 1);
            pmax[i] = std::max(pmax[i], (*it)[i] + 1);
          }
        }
 
        for (auto it = sites.begin(); it != sites.end(); ++it)
        {
          for (size_t i = 0; i < Space::dimension; ++i)
          {
            pmin[i] = std::min(pmin[i], (*it)[i] - 1);
            pmax[i] = std::max(pmax[i], (*it)[i] + 1);
          }
        }
 
        Domain domain(pmin, pmax);
 
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
 
        typename VoroMap::PeriodicitySpec specs = {false, false, false};
        if (params["toroidal-x"].as<int>()) specs[0] = true;
        if (params["toroidal-y"].as<int>()) specs[1] = true;
        if (params["toroidal-z"].as<int>()) specs[2] = true;
 
        auto map = VoroMap(domain, predicate, metric, specs);
 
        std::vector<Vector> directions(pCount);
        size_t i = 0;
        for (auto it = points.begin(); it != points.end(); ++it)
        {
          directions[i++] = map(*it);
        }
        return directions;
      }

References domain, and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::insert().

◆ getDistanceToClosestSite()

template<typename TKSpace >

template<uint32_t p, typename PointRangeSites , typename PointRange >

static std::vector< typename ExactPredicateLpSeparableMetric< Space, p >::Value > DGtal::ShortcutsGeometry< TKSpace >::getDistanceToClosestSite	(	const PointRange &	points,
		const PointRangeSites &	sites,
		const Parameters &	params = `parametersVoronoiMap()`
	)

inlinestatic

Computes the distances to the closest site from a range of points.

Template Parameters

p	The exponent in the Lp metric
PointRange	The range of point
PointRangeSites	The range of sites

Parameters

points	The one to compute the closest site of
sites	The list of sites
params	Parameters

Returns: A vector of distances to the closest in the same order as 'points'.

Definition at line 2348 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using DTMap = DistanceTransformation<Space, VoronoiPointPredicate, Metric>;
 
        // Compute domain of points
        Point pmin = *points.begin();
        Point pmax = pmin;
 
        size_t pCount = 0;
        for (auto it = points.begin(); it != points.end(); ++it)
        {
          pCount ++;
          for (size_t i = 0; i < Space::dimension; ++i)
          {
            pmin[i] = std::min(pmin[i], (*it)[i] - 1);
            pmax[i] = std::max(pmax[i], (*it)[i] + 1);
          }
        }
 
        for (auto it = sites.begin(); it != sites.end(); ++it)
        {
          for (size_t i = 0; i < Space::dimension; ++i)
          {
            pmin[i] = std::min(pmin[i], (*it)[i] - 1);
            pmax[i] = std::max(pmax[i], (*it)[i] + 1);
          }
        }
 
        Domain domain(pmin, pmax);
 
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename DTMap::PeriodicitySpec specs = {false, false, false};
        if (params["toroidal-x"].as<int>()) specs[0] = true;
        if (params["toroidal-y"].as<int>()) specs[1] = true;
        if (params["toroidal-z"].as<int>()) specs[2] = true;
 
        auto map = DTMap(domain, predicate, metric, specs);
 
        std::vector<typename Metric::Value> directions(pCount);
        size_t i = 0;
        for (auto it = points.begin(); it != points.end(); ++it)
        {
          directions[i++] = map(*it);
        }
        return directions;
      }

References domain, and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::insert().

◆ getDistanceTransformation()

template<typename TKSpace >

template<uint32_t p, typename PointRange >

static DistanceTransformation< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > > DGtal::ShortcutsGeometry< TKSpace >::getDistanceTransformation	(	Domain	domain,
		const PointRange &	sites,
		const Parameters &	params = `parametersVoronoiMap()`
	)

inlinestatic

Computes the Distance Transformation on a domain, where sites are given through a range.

Note: This overload returns a distance transformation, ie. where operator() returns the distance to the closest site for the considered Lp metric.

Template Parameters

p	The exponent in the Lp metric
PointRange	An iterable of points (std::vector, DGtal::DigitalSet*, ...)

Parameters

domain	The associated domain on which the VoronoiMap is computed
sites	The list of sites
params	the parameters

Returns: The DistanceTransformation within a domain with prescribed sites

Definition at line 2241 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using DTMap = DistanceTransformation<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename DTMap::PeriodicitySpec specs = {false, false, false};
        if (params["toroidal-x"].as<int>()) specs[0] = true;
        if (params["toroidal-y"].as<int>()) specs[1] = true;
        if (params["toroidal-z"].as<int>()) specs[2] = true;
 
        // Do not return a pointer here for two reasons:
        //  - The distance transform will not be passed anywhere else
        //  - The operator() is less accessible with pointers.
        return DTMap(domain, predicate, metric, specs);
      }

References domain, and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::insert().

◆ 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 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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 646 of file ShortcutsGeometry.h.

      {
        Scalars n_true_estimations;
        TrueFirstPrincipalCurvatureEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, FirstPrincipalCurvatureFunctor(),
                                  maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 730 of file ShortcutsGeometry.h.

      {
        RealVectors n_true_estimations;
        TrueFirstPrincipalDirectionEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, FirstPrincipalDirectionFunctor(),
                                  maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 506 of file ShortcutsGeometry.h.

      {
        Scalars                n_true_estimations;
        TrueGaussianCurvatureEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, GaussianCurvatureFunctor(), maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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

◆ getIICurvatureEstimation()

template<typename TKSpace >

template<typename TEstimator , typename TFunctor , typename TPointPredicate >

static std::vector< typename TEstimator::Quantity > DGtal::ShortcutsGeometry< TKSpace >::getIICurvatureEstimation	(	const char *	description,
		const TPointPredicate &	shape,
		const KSpace &	K,
		const SurfelRange &	surfels,
		const Parameters &	params
	)

inlinestaticprivate

Definition at line 2531 of file ShortcutsGeometry.h.

      {
        using Quantities = std::vector<typename TEstimator::Quantity>;
        Quantities estimations;
        int      verbose          = params[ "verbose"          ].as<int>();
        int      ii_thread_number = params[ "ii-thread-number" ].as<int>();
        auto     ii_split_axis    = getIIParallelSplitAxis( params );
        Scalar   h                = params[ "gridstep"         ].as<Scalar>();
        Scalar   r                = params[ "r-radius"         ].as<Scalar>();
        Scalar   alpha            = params[ "alpha"            ].as<Scalar>();
        if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
        if ( verbose > 0 )
          {
            trace.info() << "- II " << description << " alpha=" << alpha << std::endl;
            trace.info() << "- II " << description << " r=" << (r*h)  << " (continuous) "
                         << r << " (discrete)" << std::endl;
          }
        TFunctor functor;
        functor.init( h, r*h );
#ifdef DGTAL_WITH_OPENMP
        if ( ii_thread_number != 1 )
          {
            if ( verbose > 0 )
              trace.info() << "- II " << description
                           << " uses ParallelIIEstimator with thread request="
                         << ii_thread_number << " and split axis="
                         << ii_split_axis << std::endl;
            typedef AxisDomainSplitter<Domain>                           Splitter;
            typedef ParallelIIEstimator<TEstimator, Splitter>            ParallelEstimator;
            Splitter splitter( ii_split_axis );
            ParallelEstimator ii_estimator( splitter, ii_thread_number, functor );
            ii_estimator.attach( K, shape );
            ii_estimator.setParams( r );
            ii_estimator.init( h, surfels.begin(), surfels.end() );
            ii_estimator.eval( surfels.begin(), surfels.end(),
                               std::back_inserter( estimations ) );
            return estimations;
          }
#else
        if ( ( ii_thread_number != 1 ) && ( verbose > 0 ) )
          trace.warning() << "- II " << description
                          << " requested parallel execution but DGtal was built without OpenMP; "
                          << "falling back to the sequential estimator."
                          << std::endl;
#endif
        TEstimator ii_estimator( functor );
        ii_estimator.attach( K, shape );
        ii_estimator.setParams( r );
        ii_estimator.init( h, surfels.begin(), surfels.end() );
        ii_estimator.eval( surfels.begin(), surfels.end(),
                           std::back_inserter( estimations ) );
        return estimations;
      }

References DGtal::ShortcutsGeometry< TKSpace >::getIIParallelSplitAxis(), DGtal::Trace::info(), K, splitter, DGtal::trace, and DGtal::Trace::warning().

◆ 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

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the Gaussian curvatures
[in]	params	the 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 1583 of file ShortcutsGeometry.h.

        {
          typedef functors::IIGaussianCurvature3DFunctor<Space> IIGaussianCurvFunctor;
          typedef IntegralInvariantCovarianceEstimator
            <KSpace, TPointPredicate, IIGaussianCurvFunctor>    IIGaussianCurvEstimator;
          return getIICurvatureEstimation<IIGaussianCurvEstimator, IIGaussianCurvFunctor>
            ( "Gaussian curvature", shape, K, surfels, params );
        }

References K.

◆ 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]	bimage	the characteristic function of the shape as a binary image (inside is true, outside is false).
[in]	surfels	the sequence of surfels at which we compute the Gaussian curvatures
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1506 of file ShortcutsGeometry.h.

      {
        auto K =  getKSpace( bimage, params );
        return getIIGaussianCurvatures( *bimage, K, surfels, params );
      }

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

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures(), and 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]	dshape	the digitized implicit shape, which is an implicitly defined characteristic function.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1548 of file ShortcutsGeometry.h.

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

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

◆ getIIMeanCurvatures() [1/3]

template<typename TKSpace >

template<typename TPointPredicate >

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

inlinestatic

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

Template Parameters

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the mean curvatures
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1467 of file ShortcutsGeometry.h.

        {
          typedef functors::IIMeanCurvature3DFunctor<Space> IIMeanCurvFunctor;
          typedef IntegralInvariantVolumeEstimator
            <KSpace, TPointPredicate, IIMeanCurvFunctor>    IIMeanCurvEstimator;
          return getIICurvatureEstimation<IIMeanCurvEstimator, IIMeanCurvFunctor>
            ( "mean curvature", shape, K, surfels, params );
        }

References K.

◆ 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]	bimage	the characteristic function of the shape as a binary image (inside is true, outside is false).
[in]	surfels	the sequence of surfels at which we compute the mean curvatures
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1384 of file ShortcutsGeometry.h.

      {
        auto K =  getKSpace( bimage, params );
        return getIIMeanCurvatures( *bimage, K, surfels, params );
      }

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

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

◆ getIIMeanCurvatures() [3/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	dshape	the digitized implicit shape, which is an implicitly defined characteristic function.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1426 of file ShortcutsGeometry.h.

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

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

◆ getIINormalVectors() [1/3]

template<typename TKSpace >

template<typename TPointPredicate >

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

inlinestatic

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

Template Parameters

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1292 of file ShortcutsGeometry.h.

        {
          typedef functors::IINormalDirectionFunctor<Space> IINormalFunctor;
          typedef IntegralInvariantCovarianceEstimator
            <KSpace, TPointPredicate, IINormalFunctor>          IINormalEstimator;
 
          RealVectors n_estimations;
          int        verbose          = params[ "verbose"          ].as<int>();
          int        ii_thread_number = params[ "ii-thread-number" ].as<int>();
          auto       ii_split_axis    = getIIParallelSplitAxis( params );
          Scalar     h                = params[ "gridstep"         ].as<Scalar>();
          Scalar     r                = params[ "r-radius"         ].as<Scalar>();
          Scalar     alpha            = params[ "alpha"            ].as<Scalar>();
          if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
          if ( verbose > 0 )
            {
              trace.info() << "- II normal alpha=" << alpha << std::endl;
              trace.info() << "- II normal r=" << (r*h)  << " (continuous) "
                           << r << " (discrete)" << std::endl;
            }
          IINormalFunctor     functor;
          functor.init( h, r*h );
          bool use_parallel = false;
#ifdef DGTAL_WITH_OPENMP
          if ( ii_thread_number != 1 )
            {
              use_parallel = true;
              if ( verbose > 0 )
                trace.info() << "- II normal uses ParallelIIEstimator with thread request="
                             << ii_thread_number << " and split axis="
                             << ii_split_axis << std::endl;
              typedef AxisDomainSplitter<Domain>                Splitter;
              typedef ParallelIIEstimator<IINormalEstimator, Splitter> ParallelEstimator;
              Splitter splitter( ii_split_axis );
              ParallelEstimator ii_estimator( splitter, ii_thread_number, functor );
              ii_estimator.attach( K, shape );
              ii_estimator.setParams( r );
              ii_estimator.init( h, surfels.begin(), surfels.end() );
              ii_estimator.eval( surfels.begin(), surfels.end(),
                                 std::back_inserter( n_estimations ) );
            }
#else
          if ( ( ii_thread_number != 1 ) && ( verbose > 0 ) )
            trace.warning() << "- II normal requested parallel execution but DGtal was built without OpenMP; "
                            << "falling back to the sequential estimator."
                            << std::endl;
#endif
          if ( ! use_parallel )
            {
              IINormalEstimator ii_estimator( functor );
              ii_estimator.attach( K, shape );
              ii_estimator.setParams( r );
              ii_estimator.init( h, surfels.begin(), surfels.end() );
              ii_estimator.eval( surfels.begin(), surfels.end(),
                                 std::back_inserter( n_estimations ) );
            }
          const RealVectors n_trivial = getTrivialNormalVectors( K, surfels );
          orientVectors( n_estimations, n_trivial );
          return n_estimations;
        }

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

◆ 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]	bimage	the characteristic function of the shape as a binary image (inside is true, outside is false).
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1203 of file ShortcutsGeometry.h.

      {
        auto K =  getKSpace( bimage, params );
        return getIINormalVectors( *bimage, K, surfels, params );
      }

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

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

◆ 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]	dshape	the digitized implicit shape, which is an implicitly defined characteristic function.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1249 of file ShortcutsGeometry.h.

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

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

◆ getIIParallelSplitAxis()

template<typename TKSpace >

static Domain::Dimension DGtal::ShortcutsGeometry< TKSpace >::getIIParallelSplitAxis ( const Parameters & params )

inlinestaticprivate

Definition at line 2596 of file ShortcutsGeometry.h.

      {
        const auto requested_axis = params[ "ii-split-axis" ].as<int>();
        if ( requested_axis <= 0 ) return 0;
        if ( requested_axis >= static_cast<int>( Domain::dimension ) )
          return static_cast<typename Domain::Dimension>( Domain::dimension - 1 );
        return static_cast<typename Domain::Dimension>( requested_axis );
      }

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

◆ 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

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the Gaussian curvatures
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1707 of file ShortcutsGeometry.h.

      {
        typedef functors::IIPrincipalCurvaturesAndDirectionsFunctor<Space> IICurvFunctor;
        typedef IntegralInvariantCovarianceEstimator<KSpace, TPointPredicate, IICurvFunctor> IICurvEstimator;
        return getIICurvatureEstimation<IICurvEstimator, IICurvFunctor>
          ( "principal curvatures and directions", shape, K, surfels, params );
      }

References K.

◆ 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]	bimage	the characteristic function of the shape as a binary image (inside is true, outside is false).
[in]	surfels	the sequence of surfels at which we compute the Gaussian curvatures
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1623 of file ShortcutsGeometry.h.

      {
        auto K =  getKSpace( bimage, params );
        return getIIPrincipalCurvaturesAndDirections( *bimage, K, surfels, params );
      }

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

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections(), and 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]	dshape	the digitized implicit shape, which is an implicitly defined characteristic function.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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)." ii-thread-number[ 1]: number of threads for II curvature estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available. ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators. 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 1666 of file ShortcutsGeometry.h.

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

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

◆ getKSpace() [1/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	low	the lowest point in the space
[in]	up	the highest point in the space
[in]	params	the parameters: closed [1]: specifies if the Khalimsky space is closed (!=0) or not (==0).

Returns: the Khalimsky space.

Definition at line 329 of file Shortcuts.h.

      {
        int closed  = params[ "closed"  ].as<int>();
        KSpace K;
        if ( ! K.init( low, up, closed ) )
          trace.error() << "[Shortcuts::getKSpace]"
                        << " Error building Khalimsky space K=" << K << std::endl;
        return K;
      }

◆ getKSpace() [2/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface )

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

[in] surface a 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 393 of file Shortcuts.h.

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

◆ getKSpace() [3/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static KSpace DGtal::Shortcuts< TKSpace >::getKSpace ( CountedPtr< ::DGtal::IndexedDigitalSurface< TDigitalSurfaceContainer > > surface )

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

[in] surface a smart pointer on any indexed digital surface.

Returns: the Khalimsky space associated to the given surface.

Definition at line 404 of file Shortcuts.h.

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

◆ getKSpace() [4/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	bimage	any binary image
[in]	params	the parameters: closed [1]: specifies if the Khalimsky space is closed (!=0) or not (==0).

Returns: the Khalimsky space.

Definition at line 351 of file Shortcuts.h.

      {
        int closed  = params[ "closed"  ].as<int>();
        KSpace K;
        if ( ! K.init( bimage->domain().lowerBound(),
                       bimage->domain().upperBound(),
                       closed ) )
          trace.error() << "[Shortcuts::getKSpace]"
                        << " Error building Khalimsky space K=" << K << std::endl;
        return K;
      }

◆ getKSpace() [5/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	gimage	any gray-scale image
[in]	params	the parameters: closed [1]: specifies if the Khalimsky space is closed (!=0) or not (==0).

Returns: the Khalimsky space.

Definition at line 375 of file Shortcuts.h.

      {
        int closed  = params[ "closed"  ].as<int>();
        KSpace K;
        if ( ! K.init( gimage->domain().lowerBound(),
                       gimage->domain().upperBound(),
                       closed ) )
          trace.error() << "[Shortcuts::getKSpace]"
                        << " Error building Khalimsky space K=" << K << std::endl;
        return K;
      }

◆ getKSpace() [6/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]

params

the 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 483 of file Shortcuts.h.

      {
        Scalar min_x  = params[ "minAABB"  ].as<Scalar>();
        Scalar max_x  = params[ "maxAABB"  ].as<Scalar>();
        Scalar h      = params[ "gridstep" ].as<Scalar>();
        Scalar offset = params[ "offset"   ].as<Scalar>();
        bool   closed = params[ "closed"   ].as<int>();
        RealPoint p1( min_x - offset * h, min_x - offset * h, min_x - offset * h );
        RealPoint p2( max_x + offset * h, max_x + offset * h, max_x + offset * h );
        CountedPtr<DigitizedImplicitShape3D> dshape( new DigitizedImplicitShape3D() );
        dshape->init( p1, p2, h );
        Domain domain = dshape->getDomain();
        KSpace K;
        if ( ! K.init( domain.lowerBound(), domain.upperBound(), closed ) )
          trace.error() << "[Shortcuts::getKSpace]"
                        << " Error building Khalimsky space K=" << K << std::endl
                        << "Note: if you use decimal values, check your locale for decimal point '.' or ','."
                        << std::endl;
        return K;
      }

◆ 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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 368 of file ShortcutsGeometry.h.

      {
        Scalars                n_true_estimations;
        TrueMeanCurvatureEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, MeanCurvatureFunctor(), maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 329 of file ShortcutsGeometry.h.

      {
        RealVectors         n_true_estimations;
        TrueNormalEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, NormalFunctor(), maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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

Referenced by main().

◆ getPositions() [1/2]

template<typename TKSpace >

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

inlinestatic

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

Note: The surfel centroids are iteratively projected onto the implicit surface through a damped Newton process.

Parameters

[in]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels that we project onto the shape's surface
[in]	params	the 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 261 of file ShortcutsGeometry.h.

      {
        RealVectors         n_true_estimations;
        TruePositionEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, PositionFunctor(), maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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]	shape	the implicit shape.
[in]	points	the sequence of points that we project onto the shape's surface.
[in]	params	the 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 295 of file ShortcutsGeometry.h.

      {
        RealPoints proj_points( points.size() );
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        for ( unsigned int i = 0; i < points.size(); ++i )
          proj_points[ i ] = shape->nearestPoint( points[ i ], accuracy,
                                                  maxIter, gamma );
        return proj_points;
      }

◆ 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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 815 of file ShortcutsGeometry.h.

      {
        CurvatureTensorQuantities n_true_estimations;
        TruePrincipalCurvaturesAndDirectionsEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, PrincipalCurvaturesAndDirectionsFunctor(),
                                  maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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

◆ getRawDistanceToClosestSite()

template<typename TKSpace >

template<uint32_t p, typename PointRangeSites , typename PointRange >

static std::vector< typename ExactPredicateLpSeparableMetric< Space, p >::Value > DGtal::ShortcutsGeometry< TKSpace >::getRawDistanceToClosestSite	(	const PointRange &	points,
		const PointRangeSites &	sites,
		const Parameters &	params = `parametersVoronoiMap()`
	)

inlinestatic

Computes the raw distances to the closest site from a range of points.

Raw distance means that we are computing an exact representation of the distance (e.g. dropping the 1/p exponent for Lp metric).

Template Parameters

p	The exponent in the Lp metric
PointRange	The range of point
PointRangeSites	The range of sites

Parameters

points	The one to compute the closest site of
sites	The list of sites
params	Parameters

Returns: A vector of raw distances (eg. squared values for L2 metric) to the closest in the same order as 'points'.

Definition at line 2420 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using DTMap = DistanceTransformation<Space, VoronoiPointPredicate, Metric>;
 
        // Compute domain of points
        Point pmin = *points.begin();
        Point pmax = pmin;
 
        size_t pCount = 0;
        for (auto it = points.begin(); it != points.end(); ++it)
        {
          pCount ++;
          for (size_t i = 0; i < Space::dimension; ++i)
          {
            pmin[i] = std::min(pmin[i], (*it)[i] - 1);
            pmax[i] = std::max(pmax[i], (*it)[i] + 1);
          }
        }
 
        for (auto it = sites.begin(); it != sites.end(); ++it)
        {
          for (size_t i = 0; i < Space::dimension; ++i)
          {
            pmin[i] = std::min(pmin[i], (*it)[i] - 1);
            pmax[i] = std::max(pmax[i], (*it)[i] + 1);
          }
        }
 
        Domain domain(pmin, pmax);
 
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename DTMap::PeriodicitySpec specs = {false, false, false};
        if (params["toroidal-x"].as<int>()) specs[0] = true;
        if (params["toroidal-y"].as<int>()) specs[1] = true;
        if (params["toroidal-z"].as<int>()) specs[2] = true;
 
        auto map = DTMap(domain, predicate, metric, specs);
 
        std::vector<typename Metric::Value> directions(pCount);
        size_t i = 0;
        for (auto it = points.begin(); it != points.end(); ++it)
        {
          directions[i++] = map(*it);
        }
        return directions;
      }

References domain, and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::insert().

◆ 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]	v1	any vector of values.
[in]	v2	any vector of values.

Returns: the vector composed of elements |v1[i]-v2[i]|.

Definition at line 2071 of file ShortcutsGeometry.h.

      {
        Scalars result( v1.size() );
        std::transform( v2.cbegin(), v2.cend(), v1.cbegin(), result.begin(),
                        [] ( Scalar val1, Scalar val2 )
                        { return fabs( val1 - val2 ); } );
        return result;
      }

◆ 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]	v1	any vector of values.
[in]	v2	any vector of values.

Returns: the normL1 of v1-v2, ie. 1/n sum_i |v1[i]-v2[i]|.

Definition at line 2104 of file ShortcutsGeometry.h.

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

◆ 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]	v1	any vector of values.
[in]	v2	any vector of values.

Returns: the normL2 of v1-v2, ie. sqrt( 1/n sum_i (v1[i]-v2[i])^2 ).

Definition at line 2088 of file ShortcutsGeometry.h.

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

◆ 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]	v1	any vector of values.
[in]	v2	any vector of values.

Returns: the normLoo of v1-v2, ie. max_i |v1[i]-v2[i]|.

Definition at line 2120 of file ShortcutsGeometry.h.

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

◆ 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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 688 of file ShortcutsGeometry.h.

      {
        Scalars n_true_estimations;
        TrueSecondPrincipalCurvatureEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, SecondPrincipalCurvatureFunctor(),
                                  maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 772 of file ShortcutsGeometry.h.

      {
        RealVectors n_true_estimations;
        TrueSecondPrincipalDirectionEstimator true_estimator;
        int     maxIter = params[ "projectionMaxIter"  ].as<int>();
        double accuracy = params[ "projectionAccuracy" ].as<double>();
        double    gamma = params[ "projectionGamma"    ].as<double>();
        Scalar gridstep = params[ "gridstep"           ].as<Scalar>();
        true_estimator.attach( *shape );
        true_estimator.setParams( K, SecondPrincipalDirectionFunctor(),
                                  maxIter, accuracy, gamma );
        true_estimator.init( gridstep, surfels.begin(), surfels.end() );
        true_estimator.eval( surfels.begin(), surfels.end(),
                             std::back_inserter( n_true_estimations ) );
        return n_true_estimations;
      }

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] v a vector of scalars

Returns: its statistic.

Definition at line 2028 of file ShortcutsGeometry.h.

      {
        ScalarStatistic stat;
        stat.addValues( v.begin(), v.end() );
        stat.terminate();
        return stat;
      }

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]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the 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 1015 of file ShortcutsGeometry.h.

      {
        std::vector< RealVector > result;
        for ( auto s : surfels )
          {
            Dimension  k = K.sOrthDir( s );
            bool  direct = K.sDirect( s, k );
            RealVector t = RealVector::zero;
            t[ k ]       = direct ? -1.0 : 1.0;
            result.push_back( t );
          }
        return result;
      }

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

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

◆ getVCMNormalVectors()

template<typename TKSpace >

template<typename TAnyDigitalSurface >

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

inlinestatic

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

Template Parameters

TAnyDigitalSurface either kind of DigitalSurface, like ShortcutsGeometry::LightDigitalSurface or ShortcutsGeometry::DigitalSurface.

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the 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 1103 of file ShortcutsGeometry.h.

        {
          typedef ExactPredicateLpSeparableMetric<Space,2> Metric;
          typedef typename TAnyDigitalSurface::DigitalSurfaceContainer SurfaceContainer;
          RealVectors n_estimations;
          int        verbose = params[ "verbose"   ].as<int>();
          std::string kernel = params[ "kernel"    ].as<std::string>();
          Scalar      h      = params[ "gridstep"  ].as<Scalar>();
          Scalar      R      = params[ "R-radius"  ].as<Scalar>();
          Scalar      r      = params[ "r-radius"  ].as<Scalar>();
          Scalar      t      = params[ "t-ring"    ].as<Scalar>();
          Scalar      alpha  = params[ "alpha"     ].as<Scalar>();
          int      embedding = params[ "embedding" ].as<int>();
          // Adjust parameters according to gridstep if specified.
          if ( alpha != 1.0 ) R *= pow( h, alpha-1.0 );
          if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
          Surfel2PointEmbedding embType = embedding == 0 ? Pointels :
            embedding == 1 ? InnerSpel : OuterSpel;
          if ( verbose > 0 )
            {
              trace.info() << "- VCM normal kernel=" << kernel << " emb=" << embedding
                           << " alpha=" << alpha << std::endl;
              trace.info() << "- VCM normal r=" << (r*h)  << " (continuous) "
                           << r << " (discrete)" << std::endl;
              trace.info() << "- VCM normal R=" << (R*h)  << " (continuous) "
                           << R << " (discrete)" << std::endl;
              trace.info() << "- VCM normal t=" << t << " (discrete)" << std::endl;
            }
          if ( kernel == "hat" )
            {
              typedef functors::HatPointFunction<Point,Scalar>             KernelFunction;
              typedef VoronoiCovarianceMeasureOnDigitalSurface
                < SurfaceContainer, Metric, KernelFunction >               VCMOnSurface;
              typedef functors::VCMNormalVectorFunctor<VCMOnSurface>       NormalVFunctor;
              typedef VCMDigitalSurfaceLocalEstimator
                < SurfaceContainer, Metric, KernelFunction, NormalVFunctor> VCMNormalEstimator;
              KernelFunction chi_r( 1.0, r );
              VCMNormalEstimator estimator;
              estimator.attach( *surface );
              estimator.setParams( embType, R, r, chi_r, t, Metric(), verbose > 0 );
              estimator.init( h, surfels.begin(), surfels.end() );
              estimator.eval( surfels.begin(), surfels.end(),
                              std::back_inserter( n_estimations ) );
            }
          else if ( kernel == "ball" )
            {
              typedef functors::BallConstantPointFunction<Point,Scalar>    KernelFunction;
              typedef VoronoiCovarianceMeasureOnDigitalSurface
                < SurfaceContainer, Metric, KernelFunction >               VCMOnSurface;
              typedef functors::VCMNormalVectorFunctor<VCMOnSurface>       NormalVFunctor;
              typedef VCMDigitalSurfaceLocalEstimator
                < SurfaceContainer, Metric, KernelFunction, NormalVFunctor> VCMNormalEstimator;
              KernelFunction chi_r( 1.0, r );
              VCMNormalEstimator estimator;
              estimator.attach( *surface );
              estimator.setParams( embType, R, r, chi_r, t, Metric(), verbose > 0 );
              estimator.init( h, surfels.begin(), surfels.end() );
              estimator.eval( surfels.begin(), surfels.end(),
                              std::back_inserter( n_estimations ) );
            }
          else
            {
              trace.warning() << "[ShortcutsGeometry::getVCMNormalVectors] Unknown kernel: "
                              << kernel << std::endl;
            }
          return n_estimations;
        }

References DGtal::Trace::info(), DGtal::InnerSpel, DGtal::OuterSpel, DGtal::Pointels, DGtal::R, surface, 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]	v1	the first array of unit vectors (normals)
[in]	v2	the second array of unit vectors (normals)

Returns: the vector of angle differences.

Definition at line 2043 of file ShortcutsGeometry.h.

      {
        Scalars v( v1.size() );
        if ( v1.size() == v2.size() )
          {
            auto outIt = v.begin();
            for ( auto it1 = v1.cbegin(), it2 = v2.cbegin(), itE1 = v1.cend();
                  it1 != itE1; ++it1, ++it2 )
              {
                Scalar angle_error = acos( (*it1).dot( *it2 ) );
                *outIt++ = angle_error;
              }
          }
        else
          {
            trace.warning() << "[ShortcutsGeometry::getVectorsAngleDeviation]"
                            << " v1.size()=" << v1.size() << " should be equal to "
                            << " v2.size()=" << v2.size() << std::endl;
          }
        return v;
      }

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

◆ getVoronoiMap() [1/2]

template<typename TKSpace >

template<uint32_t p, typename PointRange >

static VoronoiMap< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > > DGtal::ShortcutsGeometry< TKSpace >::getVoronoiMap	(	CountedPtr< Domain >	domain,
		const PointRange &	sites,
		const Parameters &	params = `parametersVoronoiMap()`
	)

inlinestatic

Computes the VoronoiMap on a domain, where sites are given through a range.

Template Parameters

p	The exponent in the Lp metric
PointRange	An iterable of points (std::vector, DGtal::DigitalSet*, ...)

Parameters

domain	The associated domain on which the VoronoiMap is computed
sites	The list of sites
params	the parameters

Returns: The VoronoiMap within a domain with prescribed sites

Definition at line 2202 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using VoroMap = VoronoiMap<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(*domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename VoroMap::PeriodicitySpec specs = {false, false, false};
        if (params["toroidal-x"].as<int>()) specs[0] = true;
        if (params["toroidal-y"].as<int>()) specs[1] = true;
        if (params["toroidal-z"].as<int>()) specs[2] = true;
 
        // Do not return a pointer here for two reasons:
        //  - The distance transform will not be passed anywhere else
        //  - The operator() is less accessible with pointers.
        return VoroMap(*domain, predicate, metric, specs);
      }

References domain, and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::insert().

◆ getVoronoiMap() [2/2]

template<typename TKSpace >

template<uint32_t p, typename PointRange >

static VoronoiMap< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > > DGtal::ShortcutsGeometry< TKSpace >::getVoronoiMap	(	Domain	domain,
		const PointRange &	sites,
		const Parameters &	params = `parametersVoronoiMap()`
	)

inlinestatic

Computes the VoronoiMap on a domain, where sites are given through a range.

Template Parameters

p	The exponent in the Lp metric
PointRange	An iterable of points (std::vector, DGtal::DigitalSet*, ...)

Parameters

domain	The associated domain on which the VoronoiMap is computed
sites	The list of sites
params	the parameters

Returns: The VoronoiMap within a domain with prescribed sites

Definition at line 2165 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using VoroMap = VoronoiMap<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename VoroMap::PeriodicitySpec specs = {false, false, false};
        if (params["toroidal-x"].as<int>()) specs[0] = true;
        if (params["toroidal-y"].as<int>()) specs[1] = true;
        if (params["toroidal-z"].as<int>()) specs[2] = true;
 
 
        // Do not return a pointer here for two reasons:
        //  - The distance transform will not be passed anywhere else
        //  - The operator() is less accessible with pointers.
        return VoroMap(domain, predicate, metric, specs);
      }

References domain, and DGtal::DigitalSetByAssociativeContainer< TDomain, TContainer >::insert().

◆ operator=() [1/2]

template<typename TKSpace >

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

delete

Copy assignment operator.

Parameters

other the 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

other the 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]	v	the vectors to reorient.
[in]	ref_v	the vectors having the reference orientation.

Definition at line 2015 of file ShortcutsGeometry.h.

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

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, 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 minimization 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 outputting feature vector v onto cells: "Average"|"Minimum"|"Maximum"

Definition at line 1739 of file ShortcutsGeometry.h.

      {
        return Parameters
          ( "at-enabled",        1 )
          ( "at-alpha",          0.1 )
          ( "at-lambda",         0.025 )
          ( "at-epsilon",        0.25 )
          ( "at-epsilon-start",  2.0 )
          ( "at-epsilon-ratio",  2.0 )
          ( "at-max-iter",      10 )
          ( "at-diff-v-max",     0.0001 )
          ( "at-v-policy",   "Maximum" );
      }

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 458 of file Shortcuts.h.

      {
        return Parameters
          ( "minAABB",  -10.0 )
          ( "maxAABB",   10.0 )
          ( "gridstep",   1.0 )
          ( "offset",     5.0 );
      }

◆ 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)."
ii-thread-number[ 1]: number of threads for II estimators; 1 keeps the sequential estimator, any other value requests the parallel estimator when OpenMP support is available.
ii-split-axis [ 0]: main axis used by AxisDomainSplitter for parallel II estimators.
surfelEmbedding [ 0]: the surfel -> point embedding for VCM estimator: 0: Pointels, 1: InnerSpel, 2: OuterSpel.
unit_u [0]: Use unit normals for (CNC) curvature computations.

Definition at line 990 of file ShortcutsGeometry.h.

      {
        return Parameters
          ( "verbose",           1 )
          ( "t-ring",          3.0 )
          ( "kernel",        "hat" )
          ( "R-radius",       10.0 )
          ( "r-radius",        3.0 )
          ( "alpha",          0.33 )
          ( "ii-thread-number", 1 )
          ( "ii-split-axis",    0 )
          ( "surfelEmbedding",   0 )
          ( "unit_u"         ,   0 );
      }

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

◆ 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 308 of file Shortcuts.h.

      {
        return Parameters
          ( "closed",    1   )
          ( "gridsizex", 1.0 )
          ( "gridsizey", 1.0 )
          ( "gridsizez", 1.0 );
      }

◆ 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 233 of file ShortcutsGeometry.h.

      {
        return Parameters
          ( "projectionMaxIter",  20 )
          ( "projectionAccuracy", 0.0001 )
          ( "projectionGamma",    0.5 )
          ( "gridstep",           1.0 );
      }

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

◆ parametersVoronoiMap()

template<typename TKSpace >

static Parameters DGtal::ShortcutsGeometry< TKSpace >::parametersVoronoiMap ( )

inlinestatic

Returns: the parameters and their default values which are used in VoronoiMap and DistanceTransformation

Definition at line 2140 of file ShortcutsGeometry.h.

                                               {
        return Parameters
          // Toricity might be moved elsewhere as this is quite a general parameter
          ( "toroidal-x" , false )
          ( "toroidal-y" , false )
          ( "toroidal-z" , false );
      }

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

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

ShortcutsGeometry.h

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Detailed Description

Member Typedef Documentation

◆ Arc

◆ ArcRange

◆ Base

◆ BinaryImage

◆ Cell

◆ Cell2Index

◆ CellRange

◆ CNCComputer

◆ CurvatureTensorQuantities

◆ CurvatureTensorQuantity

◆ DigitalSet

◆ DigitalSurface

◆ DigitizedImplicitShape3D

◆ Domain

◆ DoubleImage

◆ ExplicitSurfaceContainer

◆ Face

◆ FirstPrincipalCurvatureFunctor

◆ FirstPrincipalDirectionFunctor

◆ FloatImage

◆ GaussianCurvatureFunctor

◆ GrayScale

◆ GrayScaleImage

◆ IdxArc

◆ IdxArcRange

◆ IdxDigitalSurface

◆ IdxSurfel

◆ IdxSurfelRange

◆ IdxSurfelSet

◆ IdxVertex

◆ ImplicitShape3D

◆ Integer

◆ KSpace

◆ LightDigitalSurface

◆ LightSurfaceContainer

◆ MeanCurvatureFunctor

◆ Mesh

◆ NormalFunctor

◆ Point

◆ PolygonalSurface

◆ PositionFunctor

◆ PrincipalCurvaturesAndDirectionsFunctor

◆ RealPoint

◆ RealPoints

◆ RealVector

◆ RealVectors

◆ Scalar

◆ ScalarPolynomial

◆ Scalars

◆ ScalarStatistic

◆ SCell

◆ SecondPrincipalCurvatureFunctor

◆ SecondPrincipalDirectionFunctor

◆ Self

◆ Space

◆ Surfel

◆ Surfel2Index

◆ SurfelRange

◆ SurfelSet

◆ TriangulatedSurface

◆ TrueFirstPrincipalCurvatureEstimator

◆ TrueFirstPrincipalDirectionEstimator

◆ TrueGaussianCurvatureEstimator

◆ TrueMeanCurvatureEstimator

◆ TrueNormalEstimator

◆ TruePositionEstimator

◆ TruePrincipalCurvaturesAndDirectionsEstimator

◆ TrueSecondPrincipalCurvatureEstimator

◆ TrueSecondPrincipalDirectionEstimator

◆ Vector

◆ Vertex

◆ VoronoiPointPredicate

Constructor & Destructor Documentation