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 of 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 of 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 VoronoiMap of a domain, where sites are given through a range.
template<uint32_t p, typename PointRange>
static DistanceTransformation< Space, VoronoiPointPredicate, ExactPredicateLpSeparableMetric< Space, p > >	getDistanceTransformation (CountedPtr< Domain > domain, const PointRange &sites, const Parameters &params=parametersVoronoiMap())
	Computes the VoronoiMap of 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 direction of the closest site of 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 distance of the closest site of 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 >))

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.

Definition at line 78 of file ShortcutsGeometry.h.

Member Typedef Documentation

◆ Arc

template<typename TKSpace>

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

Definition at line 146 of file ShortcutsGeometry.h.

◆ ArcRange

template<typename TKSpace>

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

Definition at line 148 of file ShortcutsGeometry.h.

◆ Base

template<typename TKSpace>

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

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

◆ Cell

template<typename TKSpace>

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

Definition at line 143 of file ShortcutsGeometry.h.

◆ Cell2Index

template<typename TKSpace>

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

Definition at line 201 of file ShortcutsGeometry.h.

◆ CellRange

template<typename TKSpace>

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

Definition at line 155 of file ShortcutsGeometry.h.

◆ CNCComputer

template<typename TKSpace>

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

Definition at line 176 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantities

template<typename TKSpace>

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

Definition at line 174 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantity

template<typename TKSpace>

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

Definition at line 173 of file ShortcutsGeometry.h.

◆ DigitalSet

template<typename TKSpace>

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

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

◆ Domain

template<typename TKSpace>

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

An (hyper-)rectangular domain.

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

◆ Face

template<typename TKSpace>

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

Definition at line 147 of file ShortcutsGeometry.h.

◆ FirstPrincipalCurvatureFunctor

template<typename TKSpace>

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

Definition at line 167 of file ShortcutsGeometry.h.

◆ FirstPrincipalDirectionFunctor

template<typename TKSpace>

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

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

◆ GaussianCurvatureFunctor

template<typename TKSpace>

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

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

◆ IdxArc

template<typename TKSpace>

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

Definition at line 151 of file ShortcutsGeometry.h.

◆ IdxArcRange

template<typename TKSpace>

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

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

◆ IdxSurfel

template<typename TKSpace>

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

Definition at line 149 of file ShortcutsGeometry.h.

◆ IdxSurfelRange

template<typename TKSpace>

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

Definition at line 156 of file ShortcutsGeometry.h.

◆ IdxSurfelSet

template<typename TKSpace>

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

Definition at line 153 of file ShortcutsGeometry.h.

◆ IdxVertex

template<typename TKSpace>

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

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

◆ Integer

template<typename TKSpace>

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

Integer numbers.

Definition at line 96 of file ShortcutsGeometry.h.

◆ KSpace

template<typename TKSpace>

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

Digital cellular space.

Definition at line 92 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 135 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 133 of file ShortcutsGeometry.h.

◆ MeanCurvatureFunctor

template<typename TKSpace>

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

Definition at line 165 of file ShortcutsGeometry.h.

◆ Mesh

template<typename TKSpace>

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

Definition at line 197 of file ShortcutsGeometry.h.

◆ NormalFunctor

template<typename TKSpace>

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

Definition at line 164 of file ShortcutsGeometry.h.

◆ Point

template<typename TKSpace>

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

Point with integer coordinates.

Definition at line 98 of file ShortcutsGeometry.h.

◆ PolygonalSurface

template<typename TKSpace>

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

Definition at line 199 of file ShortcutsGeometry.h.

◆ PositionFunctor

template<typename TKSpace>

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

Definition at line 163 of file ShortcutsGeometry.h.

◆ PrincipalCurvaturesAndDirectionsFunctor

template<typename TKSpace>

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

Definition at line 171 of file ShortcutsGeometry.h.

◆ RealPoint

template<typename TKSpace>

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

Point with floating-point coordinates.

Definition at line 104 of file ShortcutsGeometry.h.

◆ RealPoints

template<typename TKSpace>

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

Definition at line 159 of file ShortcutsGeometry.h.

◆ RealVector

template<typename TKSpace>

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

Vector with floating-point coordinates.

Definition at line 102 of file ShortcutsGeometry.h.

◆ RealVectors

template<typename TKSpace>

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

Definition at line 158 of file ShortcutsGeometry.h.

◆ Scalar

template<typename TKSpace>

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

Floating-point numbers.

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

◆ Scalars

template<typename TKSpace>

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

Definition at line 157 of file ShortcutsGeometry.h.

◆ ScalarStatistic

template<typename TKSpace>

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

Definition at line 161 of file ShortcutsGeometry.h.

◆ SCell

template<typename TKSpace>

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

Definition at line 144 of file ShortcutsGeometry.h.

◆ SecondPrincipalCurvatureFunctor

template<typename TKSpace>

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

Definition at line 168 of file ShortcutsGeometry.h.

◆ SecondPrincipalDirectionFunctor

template<typename TKSpace>

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

Definition at line 170 of file ShortcutsGeometry.h.

◆ Self

template<typename TKSpace>

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

Definition at line 83 of file ShortcutsGeometry.h.

◆ Space

template<typename TKSpace>

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

Digital space.

Definition at line 94 of file ShortcutsGeometry.h.

◆ Surfel

template<typename TKSpace>

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

Definition at line 142 of file ShortcutsGeometry.h.

◆ Surfel2Index

template<typename TKSpace>

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

Definition at line 200 of file ShortcutsGeometry.h.

◆ SurfelRange

template<typename TKSpace>

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

Definition at line 154 of file ShortcutsGeometry.h.

◆ SurfelSet

template<typename TKSpace>

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

defines a set of surfels

Definition at line 130 of file ShortcutsGeometry.h.

◆ TriangulatedSurface

template<typename TKSpace>

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

Definition at line 198 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalCurvatureEstimator

template<typename TKSpace>

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

Definition at line 187 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalDirectionEstimator

template<typename TKSpace>

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

Definition at line 191 of file ShortcutsGeometry.h.

◆ TrueGaussianCurvatureEstimator

template<typename TKSpace>

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

Definition at line 185 of file ShortcutsGeometry.h.

◆ TrueMeanCurvatureEstimator

template<typename TKSpace>

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

Definition at line 183 of file ShortcutsGeometry.h.

◆ TrueNormalEstimator

template<typename TKSpace>

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

Definition at line 181 of file ShortcutsGeometry.h.

◆ TruePositionEstimator

template<typename TKSpace>

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

Definition at line 179 of file ShortcutsGeometry.h.

◆ TruePrincipalCurvaturesAndDirectionsEstimator

template<typename TKSpace>

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

Definition at line 195 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalCurvatureEstimator

template<typename TKSpace>

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

Definition at line 189 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalDirectionEstimator

template<typename TKSpace>

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

Definition at line 193 of file ShortcutsGeometry.h.

◆ Vector

template<typename TKSpace>

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

Vector with integer coordinates.

Definition at line 100 of file ShortcutsGeometry.h.

◆ Vertex

template<typename TKSpace>

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

Definition at line 145 of file ShortcutsGeometry.h.

◆ VoronoiPointPredicate

template<typename TKSpace>

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

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

Parameters DGtal::ShortcutsGeometry< TKSpace >::defaultParameters ( )

inlinestatic

Returns: the parameters used in ShortcutsGeometry.

Definition at line 215 of file ShortcutsGeometry.h.

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

◆ getATScalarFieldApproximation() [1/2]

template<typename TKSpace>

template<typename TAnyDigitalSurface>

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 minization in AT optimization at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
[in]	input	the input scalar field (a vector of scalar values)

Returns: the piecewise-smooth approximation of input.

Definition at line 1860 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;
      }

◆ getATScalarFieldApproximation() [2/2]

template<typename TKSpace>

template<typename TAnyDigitalSurface, typename CellRangeConstIterator>

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 minization in AT optimization at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"\|"Minimum"\|"Maximum"
[in]	input	the input scalar field (a vector of scalar values)

Returns: the piecewise-smooth approximation of input.

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

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 minization in AT optimization at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
[in]	input	the input vector field (a vector of vector values)

Returns: the piecewise-smooth approximation of input.

Definition at line 1737 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;
      }

◆ getATVectorFieldApproximation() [2/2]

template<typename TKSpace>

template<typename TAnyDigitalSurface, typename VectorFieldInput, typename CellRangeConstIterator>

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 minization in AT optimization at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"\|"Minimum"\|"Maximum"
[in]	input	the input vector field (a vector of vector values)

Returns: the piecewise-smooth approximation of input.

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

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 thn 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);
      }

◆ getCNCGaussianCurvatures() [2/3]

template<typename TKSpace>

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

      {
        using Face = typename Base::SurfaceMesh::Face;
 
        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;
      }

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

◆ getCNCGaussianCurvatures() [3/3]

template<typename TKSpace>

template<typename T>

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);
      }

◆ getCNCMeanCurvatures() [1/3]

template<typename TKSpace>

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 448 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);
      }

◆ getCNCMeanCurvatures() [2/3]

template<typename TKSpace>

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

      {
        using Face = typename Base::SurfaceMesh::Face;
 
        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;
      }

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

◆ getCNCMeanCurvatures() [3/3]

template<typename TKSpace>

template<typename T>

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

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

◆ getCNCPrincipalCurvaturesAndDirections() [1/3]

template<typename TKSpace>

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 931 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);
        }

◆ getCNCPrincipalCurvaturesAndDirections() [2/3]

template<typename TKSpace>

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.

        {
          using Face = typename Base::SurfaceMesh::Face;
 
          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);
        }

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

◆ getCNCPrincipalCurvaturesAndDirections() [3/3]

template<typename TKSpace>

template<typename T>

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

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

◆ getCTrivialNormalVectors()

template<typename TKSpace>

template<typename TAnyDigitalSurface>

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 1041 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;
        }

◆ getDirectionToClosestSite()

template<typename TKSpace>

template<uint32_t p, typename PointRangeSites, typename PointRange>

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

inlinestatic

Computes the direction of the closest site of 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 2274 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using Map = 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 Map::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 = Map(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;
      }

◆ getDistanceToClosestSite()

template<typename TKSpace>

template<uint32_t p, typename PointRangeSites, typename PointRange>

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

inlinestatic

Computes the distance of the closest site of 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 2344 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using Map = 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 Map::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 = Map(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;
      }

◆ getDistanceTransformation() [1/2]

template<typename TKSpace>

template<uint32_t p, typename PointRange>

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

inlinestatic

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

Note: : This overloads return a distance transformation, ie. where operator() returns the distance to the closest site.

Template Parameters

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

Parameters

domain	The associated space to compute VoronoiMap on
sites	The list of sites
params	the parameters

Returns: The DistanceTransformation within a domain with prescribed sites

Definition at line 2238 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using Map = DistanceTransformation<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(*domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename Map::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 Map(*domain, predicate, metric, specs);
      }

◆ getDistanceTransformation() [2/2]

template<typename TKSpace>

template<uint32_t p, typename PointRange>

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

inlinestatic

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

Note: : This overloads return a distance transformation, ie. where operator() returns the distance to the closest site.

Template Parameters

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

Parameters

domain	The associated space to compute VoronoiMap on
sites	The list of sites
params	the parameters

Returns: The DistanceTransformation within a domain with prescribed sites

Definition at line 2199 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using Map = DistanceTransformation<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename Map::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 Map(domain, predicate, metric, specs);
      }

◆ getFirstPrincipalCurvatures()

template<typename TKSpace>

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

◆ getFirstPrincipalDirections()

template<typename TKSpace>

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

◆ getGaussianCurvatures()

template<typename TKSpace>

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 504 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;
      }

◆ getIIGaussianCurvatures() [1/3]

template<typename TKSpace>

template<typename TPointPredicate>

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

        {
          typedef functors::IIGaussianCurvature3DFunctor<Space> IIGaussianCurvFunctor;
          typedef IntegralInvariantCovarianceEstimator
            <KSpace, TPointPredicate, IIGaussianCurvFunctor>    IIGaussianCurvEstimator;
 
          Scalars  mc_estimations;
          int      verbose = params[ "verbose"   ].as<int>();
          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 Gaussian curvature alpha=" << alpha << std::endl;
              trace.info() << "- II Gaussian curvature r=" << (r*h)  << " (continuous) "
                           << r << " (discrete)" << std::endl;
            }
          IIGaussianCurvFunctor   functor;
          functor.init( h, r*h );
          IIGaussianCurvEstimator 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( mc_estimations ) );
          return mc_estimations;
        }

◆ getIIGaussianCurvatures() [2/3]

template<typename TKSpace>

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)." 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 1448 of file ShortcutsGeometry.h.

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

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::getIIGaussianCurvatures(), and DGtal::ShortcutsGeometry< Z3i::KSpace >::getIIGaussianCurvatures().

◆ getIIGaussianCurvatures() [3/3]

template<typename TKSpace>

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)." 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 1484 of file ShortcutsGeometry.h.

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

◆ getIIMeanCurvatures() [1/3]

template<typename TKSpace>

template<typename TPointPredicate>

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)." 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 1395 of file ShortcutsGeometry.h.

        {
          typedef functors::IIMeanCurvature3DFunctor<Space> IIMeanCurvFunctor;
          typedef IntegralInvariantVolumeEstimator
            <KSpace, TPointPredicate, IIMeanCurvFunctor>    IIMeanCurvEstimator;
 
          Scalars  mc_estimations;
          int      verbose = params[ "verbose"   ].as<int>();
          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 mean curvature alpha=" << alpha << std::endl;
              trace.info() << "- II mean curvature r=" << (r*h)  << " (continuous) "
                           << r << " (discrete)" << std::endl;
            }
          IIMeanCurvFunctor   functor;
          functor.init( h, r*h );
          IIMeanCurvEstimator 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( mc_estimations ) );
          return mc_estimations;
        }

◆ getIIMeanCurvatures() [2/3]

template<typename TKSpace>

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)." 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 1324 of file ShortcutsGeometry.h.

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

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::getIIMeanCurvatures(), and DGtal::ShortcutsGeometry< Z3i::KSpace >::getIIMeanCurvatures().

◆ getIIMeanCurvatures() [3/3]

template<typename TKSpace>

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)." 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 1360 of file ShortcutsGeometry.h.

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

◆ getIINormalVectors() [1/3]

template<typename TKSpace>

template<typename TPointPredicate>

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)." 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 1268 of file ShortcutsGeometry.h.

        {
          typedef functors::IINormalDirectionFunctor<Space> IINormalFunctor;
          typedef IntegralInvariantCovarianceEstimator
            <KSpace, TPointPredicate, IINormalFunctor>          IINormalEstimator;
 
          RealVectors n_estimations;
          int        verbose = params[ "verbose"   ].as<int>();
          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 );
          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;
        }

◆ getIINormalVectors() [2/3]

template<typename TKSpace>

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)." 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 1191 of file ShortcutsGeometry.h.

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

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::getIINormalVectors(), and DGtal::ShortcutsGeometry< Z3i::KSpace >::getIINormalVectors().

◆ getIINormalVectors() [3/3]

template<typename TKSpace>

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)." 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 1231 of file ShortcutsGeometry.h.

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

◆ getIIPrincipalCurvaturesAndDirections() [1/3]

template<typename TKSpace>

template<typename TPointPredicate>

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)." 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 1645 of file ShortcutsGeometry.h.

      {
        typedef functors::IIPrincipalCurvaturesAndDirectionsFunctor<Space> IICurvFunctor;
        typedef IntegralInvariantCovarianceEstimator<KSpace, TPointPredicate, IICurvFunctor>    IICurvEstimator;
 
        CurvatureTensorQuantities  mc_estimations;
        int      verbose = params[ "verbose"   ].as<int>();
        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 principal curvatures and directions alpha=" << alpha << std::endl;
          trace.info() << "- II principal curvatures and directions r=" << (r*h)  << " (continuous) "
          << r << " (discrete)" << std::endl;
        }
        IICurvFunctor   functor;
        functor.init( h, r*h );
        IICurvEstimator 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( mc_estimations ) );
        return mc_estimations;
      }

◆ getIIPrincipalCurvaturesAndDirections() [2/3]

template<typename TKSpace>

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)." 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 1573 of file ShortcutsGeometry.h.

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

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::getIIPrincipalCurvaturesAndDirections(), and DGtal::ShortcutsGeometry< Z3i::KSpace >::getIIPrincipalCurvaturesAndDirections().

◆ getIIPrincipalCurvaturesAndDirections() [3/3]

template<typename TKSpace>

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)." 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 1610 of file ShortcutsGeometry.h.

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

◆ getKSpace() [1/6]

template<typename TKSpace>

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>

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>

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>

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>

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>

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>

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 364 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;
      }

◆ getNormalVectors()

template<typename TKSpace>

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 325 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;
      }

◆ getPositions() [1/2]

template<typename TKSpace>

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 257 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;
      }

◆ getPositions() [2/2]

template<typename TKSpace>

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 291 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>

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

◆ getScalarsAbsoluteDifference()

template<typename TKSpace>

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 elemenst |v1[i]-v2[i]|.

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

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 2062 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>

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 2046 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>

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 2078 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>

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

◆ getSecondPrincipalDirections()

template<typename TKSpace>

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

◆ getStatistic()

template<typename TKSpace>

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

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

◆ getTrivialNormalVectors()

template<typename TKSpace>

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 1009 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;
      }

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::getIINormalVectors().

◆ getVCMNormalVectors()

template<typename TKSpace>

template<typename TAnyDigitalSurface>

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 1097 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;
        }

◆ getVectorsAngleDeviation()

template<typename TKSpace>

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 2001 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;
      }

◆ getVoronoiMap() [1/2]

template<typename TKSpace>

template<uint32_t p, typename PointRange>

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

inlinestatic

Computes the VoronoiMap of 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 space to compute VoronoiMap on
sites	The list of sites
params	the parameters

Returns: The VoronoiMap within a domain with prescribed sites

Definition at line 2160 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using Map = VoronoiMap<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(*domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename Map::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 Map(*domain, predicate, metric, specs);
      }

◆ getVoronoiMap() [2/2]

template<typename TKSpace>

template<uint32_t p, typename PointRange>

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

inlinestatic

Computes the VoronoiMap of 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 space to compute VoronoiMap on
sites	The list of sites
params	the parameters

Returns: The VoronoiMap within a domain with prescribed sites

Definition at line 2123 of file ShortcutsGeometry.h.

      {
        using Metric = ExactPredicateLpSeparableMetric<Space, p>;
        using Map = VoronoiMap<Space, VoronoiPointPredicate, Metric>;
        DigitalSet set(domain); set.insert(sites.begin(), sites.end());
        VoronoiPointPredicate predicate(set);
        Metric metric;
 
        typename Map::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 Map(domain, predicate, metric, specs);
      }

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

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 1973 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< Z3i::KSpace >::getIINormalVectors().

◆ parametersATApproximation()

template<typename TKSpace>

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 minization in AT optimization
at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"|"Minimum"|"Maximum"

Definition at line 1697 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< Z3i::KSpace >::defaultParameters().

◆ parametersDigitizedImplicitShape3D()

template<typename TKSpace>

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>

Parameters DGtal::ShortcutsGeometry< TKSpace >::parametersGeometryEstimation ( )

inlinestatic

Returns

the parameters and their default values which are used to estimate the geometry of a digital surface.

verbose [ 1]: verbose trace mode 0: silent, 1: verbose.
t-ring [ 3.0]: the radius used when computing convolved trivial normals (it is a graph distance, not related to the grid step).
R-radius [ 10.0]: the constant for distance parameter R in R(h)=R h^alpha (VCM).
r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial).
kernel [ "hat"]: the kernel integration function chi_r, either "hat" or "ball". )
alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)."
surfelEmbedding [ 0]: the surfel -> point embedding for VCM estimator: 0: Pointels, 1: InnerSpel, 2: OuterSpel.
unit_u [0]: Use unit normals for (CNC) curvature computations.

Definition at line 986 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 )
          ( "surfelEmbedding",   0 )
          ( "unit_u"         ,   0 );
      }

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::defaultParameters().

◆ parametersKSpace()

template<typename TKSpace>

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>

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

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

Referenced by DGtal::ShortcutsGeometry< Z3i::KSpace >::defaultParameters().

◆ parametersVoronoiMap()

template<typename TKSpace>

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

inlinestatic

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

Definition at line 2098 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< Z3i::KSpace >::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

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

◆ ShortcutsGeometry() [1/3]