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

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	getGaussianCurvatures (CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())

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

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

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

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

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

Geometry estimation services
static Parameters	parametersGeometryEstimation ()

static RealVectors	getTrivialNormalVectors (const KSpace &K, const SurfelRange &surfels)

template<typename TAnyDigitalSurface >
static RealVectors	getCTrivialNormalVectors (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation())

template<typename TAnyDigitalSurface >
static RealVectors	getVCMNormalVectors (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation())

static RealVectors	getIINormalVectors (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace())

static RealVectors	getIINormalVectors (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace()\|parametersDigitizedImplicitShape3D())

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

static Scalars	getIIMeanCurvatures (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace())

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

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

static Scalars	getIIGaussianCurvatures (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace())

static Scalars	getIIGaussianCurvatures (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace()\|parametersDigitizedImplicitShape3D())

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

static CurvatureTensorQuantities	getIIPrincipalCurvaturesAndDirections (CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace())

static CurvatureTensorQuantities	getIIPrincipalCurvaturesAndDirections (CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()\|parametersKSpace()\|parametersDigitizedImplicitShape3D())

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

AT approximation services
static Parameters	parametersATApproximation ()

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

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

template<typename TAnyDigitalSurface >
static Scalars	getATScalarFieldApproximation (CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Scalars &input, const Parameters &params=parametersATApproximation()\|parametersGeometryEstimation())

template<typename TAnyDigitalSurface , typename CellRangeConstIterator >
static Scalars	getATScalarFieldApproximation (Scalars &features, CellRangeConstIterator itB, CellRangeConstIterator itE, CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Scalars &input, const Parameters &params=parametersATApproximation()\|parametersGeometryEstimation())

Error measure services
static void	orientVectors (RealVectors &v, const RealVectors &ref_v)

static ScalarStatistic	getStatistic (const Scalars &v)

static Scalars	getVectorsAngleDeviation (const RealVectors &v1, const RealVectors &v2)

static Scalars	getScalarsAbsoluteDifference (const Scalars &v1, const Scalars &v2)

static Scalar	getScalarsNormL2 (const Scalars &v1, const Scalars &v2)

static Scalar	getScalarsNormL1 (const Scalars &v1, const Scalars &v2)

static Scalar	getScalarsNormLoo (const Scalars &v1, const Scalars &v2)

Static Public Member Functions inherited from DGtal::Shortcuts< TKSpace >
static Parameters	defaultParameters ()

static std::map< std::string, std::string >	getPolynomialList ()

static Parameters	parametersImplicitShape3D ()

static CountedPtr< 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())

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

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)

template<typename TPoint >
static bool	saveOBJ (CountedPtr< ::DGtal::PolygonalSurface< TPoint > > polysurf, const std::string &objfile)

template<typename TPoint >
static bool	saveOFF (CountedPtr< ::DGtal::PolygonalSurface< TPoint > > polysurf, std::string off_file, const Color &face_color=DGtal::Color::None)

template<typename TPoint >
static bool	saveOBJ (CountedPtr< ::DGtal::TriangulatedSurface< TPoint > > trisurf, const std::string &objfile)

template<typename TPoint >
static bool	saveOBJ (CountedPtr< ::DGtal::PolygonalSurface< TPoint > > polysurf, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)

template<typename TPoint >
static bool	saveOBJ (CountedPtr< ::DGtal::TriangulatedSurface< TPoint > > trisurf, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)

template<typename TPoint >
static bool	saveOFF (CountedPtr< ::DGtal::TriangulatedSurface< TPoint > > trisurf, std::string off_file, const Color &face_color=DGtal::Color::None)

static Parameters	parametersUtilities ()

template<typename TValue >
static IdxRange	getRangeMatch (const std::vector< TValue > &s1, const std::vector< TValue > &s2, bool perfect=false)

template<typename TValue >
static std::vector< TValue >	getMatchedRange (const std::vector< TValue > &range, const IdxRange &match)

static ColorMap	getColorMap (Scalar min, Scalar max, const Parameters &params=parametersUtilities())

static ZeroTickedColorMap	getZeroTickedColorMap (Scalar min, Scalar max, const Parameters &params=parametersUtilities())

template<typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool	outputSurfelsAsObj (std::ostream &output, const SurfelRange &surfels, const TCellEmbedder &embedder)

template<typename TAnyDigitalSurface >
static bool	outputPrimalDigitalSurfaceAsObj (std::ostream &output, CountedPtr< TAnyDigitalSurface > surface)

template<typename TAnyDigitalSurface , typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool	outputPrimalDigitalSurfaceAsObj (std::ostream &output, CountedPtr< TAnyDigitalSurface > surface, const TCellEmbedder &embedder)

static bool	outputPrimalIdxDigitalSurfaceAsObj (std::ostream &output, CountedPtr< IdxDigitalSurface > surface)

template<typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool	outputPrimalIdxDigitalSurfaceAsObj (std::ostream &output, CountedPtr< IdxDigitalSurface > surface, const TCellEmbedder &embedder)

template<typename TDigitalSurfaceContainer >
static bool	outputDualDigitalSurfaceAsObj (std::ostream &output, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Parameters &params=parametersMesh())

template<typename TDigitalSurfaceContainer , typename TCellEmbedder = CanonicCellEmbedder< KSpace >>
static bool	outputDualDigitalSurfaceAsObj (std::ostream &output, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const TCellEmbedder &embedder, const Parameters &params=parametersMesh())

template<typename TSCellMap , typename TValueWriter >
static bool	outputSCellMapAsCSV (std::ostream &output, const KSpace &K, const TSCellMap &anyMap, const TValueWriter &writer)

template<typename TCellMap , typename TValueWriter >
static bool	outputCellMapAsCSV (std::ostream &output, const KSpace &K, const TCellMap &anyMap, const TValueWriter &writer)

static CellRange	getPrimalCells (const KSpace &K, const SCell &s, const Dimension k)

static CellRange	getPrimalVertices (const KSpace &K, const SCell &s)

static CellRange	getPrimalVertices (const KSpace &K, const Surfel &s, bool ccw)

Private Member Functions
	BOOST_CONCEPT_ASSERT ((concepts::CCellularGridSpaceND< TKSpace >))

Detailed Description

template<typename TKSpace>
class DGtal::ShortcutsGeometry< TKSpace >

Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface in a few lines. The drawback is that you use specific types or objects, which could lead to faster code or more compact data structures.

Description of template class 'ShortcutsGeometry'

Template Parameters

TKSpace any cellular grid space, a model of concepts::CCellularGridSpaceND like KhalimskySpaceND.

Examples: geometry/meshes/curvature-comparator-ii-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-XY-3d.cpp, geometry/meshes/vol-curvature-measures-icnc-3d.cpp, and geometry/meshes/vol-curvature-measures-icnc-XY-3d.cpp.

Definition at line 74 of file ShortcutsGeometry.h.

Member Typedef Documentation

◆ Arc

template<typename TKSpace >

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

Definition at line 142 of file ShortcutsGeometry.h.

◆ ArcRange

template<typename TKSpace >

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

Definition at line 144 of file ShortcutsGeometry.h.

◆ Base

template<typename TKSpace >

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

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

◆ Cell

template<typename TKSpace >

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

Definition at line 139 of file ShortcutsGeometry.h.

◆ Cell2Index

template<typename TKSpace >

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

Definition at line 196 of file ShortcutsGeometry.h.

◆ CellRange

template<typename TKSpace >

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

Definition at line 151 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantities

template<typename TKSpace >

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

Definition at line 170 of file ShortcutsGeometry.h.

◆ CurvatureTensorQuantity

template<typename TKSpace >

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

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

◆ Domain

template<typename TKSpace >

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

An (hyper-)rectangular domain.

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

◆ Face

template<typename TKSpace >

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

Definition at line 143 of file ShortcutsGeometry.h.

◆ FirstPrincipalCurvatureFunctor

template<typename TKSpace >

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

Definition at line 163 of file ShortcutsGeometry.h.

◆ FirstPrincipalDirectionFunctor

template<typename TKSpace >

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

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

◆ GaussianCurvatureFunctor

template<typename TKSpace >

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

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

◆ IdxArc

template<typename TKSpace >

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

Definition at line 147 of file ShortcutsGeometry.h.

◆ IdxArcRange

template<typename TKSpace >

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

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

◆ IdxSurfel

template<typename TKSpace >

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

Definition at line 145 of file ShortcutsGeometry.h.

◆ IdxSurfelRange

template<typename TKSpace >

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

Definition at line 152 of file ShortcutsGeometry.h.

◆ IdxSurfelSet

template<typename TKSpace >

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

Definition at line 149 of file ShortcutsGeometry.h.

◆ IdxVertex

template<typename TKSpace >

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

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

◆ Integer

template<typename TKSpace >

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

Integer numbers.

Definition at line 92 of file ShortcutsGeometry.h.

◆ KSpace

template<typename TKSpace >

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

Digital cellular space.

Definition at line 88 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 131 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 129 of file ShortcutsGeometry.h.

◆ MeanCurvatureFunctor

template<typename TKSpace >

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

Definition at line 161 of file ShortcutsGeometry.h.

◆ Mesh

template<typename TKSpace >

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

Definition at line 192 of file ShortcutsGeometry.h.

◆ NormalFunctor

template<typename TKSpace >

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

Definition at line 160 of file ShortcutsGeometry.h.

◆ Point

template<typename TKSpace >

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

Point with integer coordinates.

Definition at line 94 of file ShortcutsGeometry.h.

◆ PolygonalSurface

template<typename TKSpace >

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

Definition at line 194 of file ShortcutsGeometry.h.

◆ PositionFunctor

template<typename TKSpace >

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

Definition at line 159 of file ShortcutsGeometry.h.

◆ PrincipalCurvaturesAndDirectionsFunctor

template<typename TKSpace >

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

Definition at line 167 of file ShortcutsGeometry.h.

◆ RealPoint

template<typename TKSpace >

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

Point with floating-point coordinates.

Definition at line 100 of file ShortcutsGeometry.h.

◆ RealPoints

template<typename TKSpace >

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

Definition at line 155 of file ShortcutsGeometry.h.

◆ RealVector

template<typename TKSpace >

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

Vector with floating-point coordinates.

Definition at line 98 of file ShortcutsGeometry.h.

◆ RealVectors

template<typename TKSpace >

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

Definition at line 154 of file ShortcutsGeometry.h.

◆ Scalar

template<typename TKSpace >

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

Floating-point numbers.

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

◆ Scalars

template<typename TKSpace >

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

Definition at line 153 of file ShortcutsGeometry.h.

◆ ScalarStatistic

template<typename TKSpace >

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

Definition at line 157 of file ShortcutsGeometry.h.

◆ SCell

template<typename TKSpace >

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

Definition at line 140 of file ShortcutsGeometry.h.

◆ SecondPrincipalCurvatureFunctor

template<typename TKSpace >

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

Definition at line 164 of file ShortcutsGeometry.h.

◆ SecondPrincipalDirectionFunctor

template<typename TKSpace >

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

Definition at line 166 of file ShortcutsGeometry.h.

◆ Self

template<typename TKSpace >

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

Definition at line 79 of file ShortcutsGeometry.h.

◆ Space

template<typename TKSpace >

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

Digital space.

Definition at line 90 of file ShortcutsGeometry.h.

◆ Surfel

template<typename TKSpace >

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

Definition at line 138 of file ShortcutsGeometry.h.

◆ Surfel2Index

template<typename TKSpace >

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

Definition at line 195 of file ShortcutsGeometry.h.

◆ SurfelRange

template<typename TKSpace >

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

Definition at line 150 of file ShortcutsGeometry.h.

◆ SurfelSet

template<typename TKSpace >

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

defines a set of surfels

Definition at line 126 of file ShortcutsGeometry.h.

◆ TriangulatedSurface

template<typename TKSpace >

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

Definition at line 193 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalCurvatureEstimator

template<typename TKSpace >

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

Definition at line 182 of file ShortcutsGeometry.h.

◆ TrueFirstPrincipalDirectionEstimator

template<typename TKSpace >

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

Definition at line 186 of file ShortcutsGeometry.h.

◆ TrueGaussianCurvatureEstimator

template<typename TKSpace >

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

Definition at line 180 of file ShortcutsGeometry.h.

◆ TrueMeanCurvatureEstimator

template<typename TKSpace >

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

Definition at line 178 of file ShortcutsGeometry.h.

◆ TrueNormalEstimator

template<typename TKSpace >

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

Definition at line 176 of file ShortcutsGeometry.h.

◆ TruePositionEstimator

template<typename TKSpace >

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

Definition at line 174 of file ShortcutsGeometry.h.

◆ TruePrincipalCurvaturesAndDirectionsEstimator

template<typename TKSpace >

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

Definition at line 190 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalCurvatureEstimator

template<typename TKSpace >

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

Definition at line 184 of file ShortcutsGeometry.h.

◆ TrueSecondPrincipalDirectionEstimator

template<typename TKSpace >

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

Definition at line 188 of file ShortcutsGeometry.h.

◆ Vector

template<typename TKSpace >

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

Vector with integer coordinates.

Definition at line 96 of file ShortcutsGeometry.h.

◆ Vertex

template<typename TKSpace >

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

Definition at line 141 of file ShortcutsGeometry.h.

Constructor & Destructor Documentation

◆ ShortcutsGeometry() [1/3]

template<typename TKSpace >

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

delete

Default constructor.

◆ ~ShortcutsGeometry()

template<typename TKSpace >

DGtal::ShortcutsGeometry< TKSpace >::~ShortcutsGeometry ( )

delete

Destructor.

◆ ShortcutsGeometry() [2/3]

template<typename TKSpace >

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

delete

Copy constructor.

Parameters

other the object to clone.

◆ ShortcutsGeometry() [3/3]

template<typename TKSpace >

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

delete

Move constructor.

Parameters

other the object to move.

Member Function Documentation

◆ BOOST_CONCEPT_ASSERT()

template<typename TKSpace >

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

private

◆ defaultParameters()

template<typename TKSpace >

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

inlinestatic

Returns: the parameters used in ShortcutsGeometry.

Definition at line 207 of file ShortcutsGeometry.h.

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

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

Referenced by main(), main(), main(), precompute(), TEST_CASE(), and TEST_CASE().

◆ getATScalarFieldApproximation() [1/2]

template<typename TKSpace >

template<typename TAnyDigitalSurface >

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

inlinestatic

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

See also: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

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

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: at-alpha [ 0.1 ]: parameter alpha in AT (data fit) at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities) at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities) at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon) at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon) at-max-iter [ 10 ]: maximum number of alternate 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.

Note: Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1525 of file ShortcutsGeometry.h.

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

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

◆ getATScalarFieldApproximation() [2/2]

template<typename TKSpace >

template<typename TAnyDigitalSurface , typename CellRangeConstIterator >

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

inlinestatic

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

See also: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

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

Parameters

[out]	features	the vector of scalar feature values (a scalar field where 1 means continuity and 0 discontinuity in the reconstruction), evaluated in the range[itB,itE).
[in]	itB	the start of the range of cells.
[in]	itE	past the end of the range of cells.
[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: at-alpha [ 0.1 ]: parameter alpha in AT (data fit) at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities) at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities) at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon) at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon) at-max-iter [ 10 ]: maximum number of alternate 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.

Note: Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1591 of file ShortcutsGeometry.h.

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

◆ getATVectorFieldApproximation() [1/2]

template<typename TKSpace >

template<typename TAnyDigitalSurface , typename VectorFieldInput >

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

inlinestatic

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

See also: Piecewise-smooth approximation using a discrete calculus model of Ambrosio-Tortorelli functional

Template Parameters

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

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: at-alpha [ 0.1 ]: parameter alpha in AT (data fit) at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities) at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities) at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon) at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon) at-max-iter [ 10 ]: maximum number of alternate 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.

Note: Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1400 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getATVectorFieldApproximation() [2/2]

template<typename TKSpace >

template<typename TAnyDigitalSurface , typename VectorFieldInput , typename CellRangeConstIterator >

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

inlinestatic

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

See also: 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.

Note: Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

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

◆ getCTrivialNormalVectors()

template<typename TKSpace >

template<typename TAnyDigitalSurface >

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

inlinestatic

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

Template Parameters

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

Parameters

[in]	surface	the digital surface
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: verbose [ 1]: verbose trace mode 0: silent, 1: verbose. t-ring [ 3.0]: the radius used when computing convolved trivial normals (it is a graph distance, not related to the grid step).

Returns: the vector containing the estimated normals, in the same order as surfels.

Definition at line 696 of file ShortcutsGeometry.h.

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

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

◆ getFirstPrincipalCurvatures()

template<typename TKSpace >

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

inlinestatic

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

Note: that the first principal curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	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 436 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getFirstPrincipalDirections()

template<typename TKSpace >

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

inlinestatic

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

Note: that the first principal direction is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	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 520 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getGaussianCurvatures()

template<typename TKSpace >

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

inlinestatic

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

Note: that the gaussian curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	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 395 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getIIGaussianCurvatures() [1/3]

template<typename TKSpace >

template<typename TPointPredicate >

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

inlinestatic

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

Template Parameters

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

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

◆ getIIGaussianCurvatures() [2/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1103 of file ShortcutsGeometry.h.

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

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

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

◆ getIIGaussianCurvatures() [3/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1139 of file ShortcutsGeometry.h.

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

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

◆ getIIMeanCurvatures() [1/3]

template<typename TKSpace >

template<typename TPointPredicate >

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

inlinestatic

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

Template Parameters

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the mean curvatures
[in]	params	the parameters: verbose [ 1]: verbose trace mode 0: silent, 1: verbose. r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial). alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)." 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 1050 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;
        }

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

◆ getIIMeanCurvatures() [2/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 979 of file ShortcutsGeometry.h.

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

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

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

◆ getIIMeanCurvatures() [3/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	dshape	the digitized implicit shape, which is an implicitly defined characteristic function.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: verbose [ 1]: verbose trace mode 0: silent, 1: verbose. r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial). alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)." 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 1015 of file ShortcutsGeometry.h.

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

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

◆ getIINormalVectors() [1/3]

template<typename TKSpace >

template<typename TPointPredicate >

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

inlinestatic

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

Template Parameters

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: verbose [ 1]: verbose trace mode 0: silent, 1: verbose. r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial). alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)." 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 923 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;
        }

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

◆ getIINormalVectors() [2/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 846 of file ShortcutsGeometry.h.

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

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

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

◆ getIINormalVectors() [3/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 886 of file ShortcutsGeometry.h.

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

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

◆ getIIPrincipalCurvaturesAndDirections() [1/3]

template<typename TKSpace >

template<typename TPointPredicate >

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

inlinestatic

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

Template Parameters

TPointPredicate any type of map Point -> boolean.

Parameters

[in]	shape	a function Point -> boolean telling if you are inside the shape.
[in]	K	the Khalimsky space where the shape and surfels live.
[in]	surfels	the sequence of surfels at which we compute the Gaussian curvatures
[in]	params	the parameters: verbose [ 1]: verbose trace mode 0: silent, 1: verbose. r-radius [ 3.0]: the constant for kernel radius parameter r in r(h)=r h^alpha (VCM,II,Trivial). alpha [ 0.33]: the parameter alpha in r(h)=r h^alpha (VCM, II)." 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 1300 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;
      }

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

◆ getIIPrincipalCurvaturesAndDirections() [2/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1228 of file ShortcutsGeometry.h.

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

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

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

◆ getIIPrincipalCurvaturesAndDirections() [3/3]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1265 of file ShortcutsGeometry.h.

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

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

◆ getKSpace() [1/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 332 of file Shortcuts.h.

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

◆ getKSpace() [2/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

[in] surface a smart pointer on a (light or not) digital surface (e.g. DigitalSurface or LightDigitalSurface).

Returns: the Khalimsky space associated to the given surface.

Definition at line 396 of file Shortcuts.h.

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

◆ getKSpace() [3/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

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

Returns: the Khalimsky space associated to the given surface.

Definition at line 407 of file Shortcuts.h.

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

◆ getKSpace() [4/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 354 of file Shortcuts.h.

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

◆ getKSpace() [5/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 378 of file Shortcuts.h.

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

◆ getKSpace() [6/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]

params

the parameters:

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

Returns: the Khalimsky space.

See also: makeDigitizedImplicitShape3D

Definition at line 486 of file Shortcuts.h.

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

◆ getMeanCurvatures()

template<typename TKSpace >

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

inlinestatic

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

Note: that the mean curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: projectionMaxIter [ 20]: the maximum number of iteration for the projection. projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection. projectionGamma [ 0.5]: the damping coefficient of the projection. gridstep [ 1.0]: the gridstep that defines the digitization (often called h).

Returns: the vector containing the mean curvatures, in the same order as surfels.

Definition at line 355 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getNormalVectors()

template<typename TKSpace >

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

inlinestatic

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

Note: that the normal vector is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	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 316 of file ShortcutsGeometry.h.

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

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

Referenced by main(), and main().

◆ getPositions() [1/2]

template<typename TKSpace >

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

inlinestatic

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

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

Parameters

[in]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels that we project onto the shape's surface
[in]	params	the parameters: projectionMaxIter [ 20]: the maximum number of iteration for the projection. projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection. projectionGamma [ 0.5]: the damping coefficient of the projection. gridstep [ 1.0]: the gridstep that defines the digitization (often called h).

Returns: the vector containing the true normals, in the same order as surfels.

Definition at line 248 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getPositions() [2/2]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 282 of file ShortcutsGeometry.h.

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

◆ getPrincipalCurvaturesAndDirections()

template<typename TKSpace >

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

inlinestatic

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

Note: that the second principal direction is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	shape	the implicit shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	surfels	the sequence of surfels at which we compute the normals
[in]	params	the parameters: projectionMaxIter [ 20]: the maximum number of iteration for the projection. projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection. projectionGamma [ 0.5]: the damping coefficient of the projection. gridstep [ 1.0]: the gridstep that defines the digitization (often called h).

Returns: the vector containing the principal curvatures and principal directions as a tuple (k1, k2, d1, d2), in the same order as surfels.

Definition at line 605 of file ShortcutsGeometry.h.

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

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

◆ getScalarsAbsoluteDifference()

template<typename TKSpace >

static Scalars DGtal::ShortcutsGeometry< TKSpace >::getScalarsAbsoluteDifference	(	const Scalars &	v1,
		const Scalars &	v2 )

inlinestatic

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

Parameters

[in]	v1	any vector of values.
[in]	v2	any vector of values.

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

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

Referenced by main().

◆ getScalarsNormL1()

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1730 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();
      }

Referenced by main().

◆ getScalarsNormL2()

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1714 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() );
      }

Referenced by main().

◆ getScalarsNormLoo()

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1746 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;
      }

Referenced by main().

◆ getSecondPrincipalCurvatures()

template<typename TKSpace >

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

inlinestatic

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

Note: that the second principal curvature is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	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 478 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getSecondPrincipalDirections()

template<typename TKSpace >

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

inlinestatic

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

Note: that the second principal direction is approximated by projecting the surfel centroid onto the implicit 3D shape.

Parameters

[in]	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 562 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getStatistic()

template<typename TKSpace >

static ScalarStatistic DGtal::ShortcutsGeometry< TKSpace >::getStatistic ( const Scalars & v )

inlinestatic

Computes the statistic of a vector of scalars

Parameters

[in] v a vector of scalars

Returns: its statistic.

Definition at line 1654 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getTrivialNormalVectors()

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 664 of file ShortcutsGeometry.h.

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

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

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

◆ getVCMNormalVectors()

template<typename TKSpace >

template<typename TAnyDigitalSurface >

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

inlinestatic

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

Template Parameters

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

Parameters

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

Returns: the vector containing the estimated normals, in the same order as surfels.

Definition at line 752 of file ShortcutsGeometry.h.

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

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

Referenced by main().

◆ getVectorsAngleDeviation()

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]	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 1669 of file ShortcutsGeometry.h.

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

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

◆ operator=() [1/2]

template<typename TKSpace >

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

delete

Copy assignment operator.

Parameters

other the object to copy.

Returns: a reference on 'this'.

◆ operator=() [2/2]

template<typename TKSpace >

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

delete

Move assignment operator.

Parameters

other the object to move.

Returns: a reference on 'this'.

◆ orientVectors()

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in,out]	v	the vectors to reorient.
[in]	ref_v	the vectors having the reference orientation.

Definition at line 1641 of file ShortcutsGeometry.h.

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

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

◆ parametersATApproximation()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are used to compute Ambrosio-Tortorelli piecewise-smooth approximation of a function.

at-enabled [ 1 ]: 1 if AT is enabled (WITH_EIGEN), 0 otherwise.
at-alpha [ 0.1 ]: parameter alpha in AT (data fit)
at-lambda [ 0.025 ]: parameter lambda in AT (1/length of discontinuities)
at-epsilon [ 0.5 ]: (last value of) parameter epsilon in AT (width of discontinuities)
at-epsilon-start[ 2.0 ]: first value for parameter epsilon in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
at-epsilon-ratio[ 2.0 ]: ratio between two consecutive epsilon value in Gamma-convergence optimization (sequence of AT optimization with decreasing epsilon)
at-max-iter [ 10 ]: maximum number of alternate minization in AT optimization
at-diff-v-max [ 0.0001]: stopping criterion that measures the loo-norm of the evolution of v between two iterations
at-v-policy ["Maximum"]: the policy when outputing feature vector v onto cells: "Average"|"Minimum"|"Maximum"

Note: Requires Eigen linear algebra backend. Use cmake -DWITH_EIGEN=true ..

Definition at line 1353 of file ShortcutsGeometry.h.

      {
#if defined(WITH_EIGEN)
        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" );
#else // defined(WITH_EIGEN)
        return Parameters( "at-enabled", 0 );
#endif// defined(WITH_EIGEN)
      }

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

◆ parametersDigitizedImplicitShape3D()

template<typename TKSpace >

static Parameters DGtal::Shortcuts< TKSpace >::parametersDigitizedImplicitShape3D ( )

inlinestatic

Returns

the parameters and their default values which are used for digitization.

minAABB [-10.0]: the min value of the AABB bounding box (domain)
maxAABB [ 10.0]: the max value of the AABB bounding box (domain)
gridstep [ 1.0]: the gridstep that defines the digitization (often called h).
offset [ 5.0]: the digital dilation of the digital space, useful when you process shapes and that you add noise.

Definition at line 461 of file Shortcuts.h.

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

◆ parametersGeometryEstimation()

template<typename TKSpace >

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

inlinestatic

Returns

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

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

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

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

◆ parametersKSpace()

template<typename TKSpace >

static Parameters DGtal::Shortcuts< TKSpace >::parametersKSpace ( )

inlinestatic

Returns

the parameters and their default values which are used for digitization.

closed [1 ]: specifies if the Khalimsky space is closed (!=0) or not (==0).
gridsizex[1.0]: specifies the space between points along x.
gridsizey[1.0]: specifies the space between points along y.
gridsizez[1.0]: specifies the space between points along z.

Definition at line 311 of file Shortcuts.h.

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

◆ parametersShapeGeometry()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are used to approximate the geometry of continuous shape.

projectionMaxIter [ 20]: the maximum number of iteration for the projection.
projectionAccuracy[0.0001]: the zero-proximity stop criterion during projection.
projectionGamma [ 0.5]: the damping coefficient of the projection.
gridstep [ 1.0]: the gridstep that defines the digitization (often called h).

Definition at line 220 of file ShortcutsGeometry.h.

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

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

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

ShortcutsGeometry.h

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ Arc

◆ ArcRange

◆ Base

◆ BinaryImage

◆ Cell

◆ Cell2Index

◆ CellRange

◆ CurvatureTensorQuantities

◆ CurvatureTensorQuantity

◆ 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

Constructor & Destructor Documentation

◆ ShortcutsGeometry() [1/3]

◆ ~ShortcutsGeometry()

◆ ShortcutsGeometry() [2/3]

◆ ShortcutsGeometry() [3/3]