Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface with few lines of code. 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/Shortcuts.h>

Inheritance diagram for DGtal::Shortcuts< TKSpace >:

[legend]

Data Structures
struct	CellReader

struct	CellWriter

struct	is_double_nested_container

struct	is_double_nested_container< C< D< T > > >

struct	SCellReader

struct	SCellWriter

struct	ValueReader

struct	ValueWriter

Public Types
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
	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	defaultParameters ()

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

static Parameters	parametersImplicitShape3D ()

static CountedPtr< ImplicitShape3D >	makeImplicitShape3D (const Parameters &params=parametersImplicitShape3D())

static Parameters	parametersKSpace ()

static KSpace	getKSpace (const Point &low, const Point &up, Parameters params=parametersKSpace())

static KSpace	getKSpace (CountedPtr< BinaryImage > bimage, Parameters params=parametersKSpace())

static KSpace	getKSpace (CountedPtr< GrayScaleImage > gimage, Parameters params=parametersKSpace())

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

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

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

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

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

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

static Parameters	parametersDigitizedImplicitShape3D ()

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

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

static Parameters	parametersBinaryImage ()

static CountedPtr< BinaryImage >	makeBinaryImage (Domain shapeDomain)

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

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

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

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

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

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

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

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

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

static Parameters	parametersGrayScaleImage ()

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (Domain aDomain)

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

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (CountedPtr< BinaryImage > binary_image, std::function< GrayScale(bool) > const &bool2grayscale=[](bool v) { return v ?(unsigned char) 255 :(unsigned char) 0;})

static bool	saveGrayScaleImage (CountedPtr< GrayScaleImage > gray_scale_image, std::string output)

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

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

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

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

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

static CountedPtr< FloatImage >	makeFloatImage (Domain aDomain)

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

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

static CountedPtr< DoubleImage >	makeDoubleImage (Domain aDomain)

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

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

static Parameters	parametersDigitalSurface ()

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

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

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

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

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

static std::vector< CountedPtr< LightDigitalSurface > >	makeLightDigitalSurfaces (CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())

static std::vector< CountedPtr< LightDigitalSurface > >	makeLightDigitalSurfaces (SurfelRange &surfel_reps, CountedPtr< BinaryImage > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())

template<typename TPointPredicate >
static CountedPtr< DigitalSurface >	makeDigitalSurface (CountedPtr< TPointPredicate > bimage, const KSpace &K, const Parameters &params=parametersDigitalSurface())

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

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

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

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

static CountedPtr< IdxDigitalSurface >	makeIdxDigitalSurface (const std::vector< CountedPtr< LightDigitalSurface > > &surfaces, const Parameters &params=parametersDigitalSurface())

template<typename TDigitalSurfaceContainer >
static CellRange	getCellRange (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Dimension k)

template<typename TDigitalSurfaceContainer >
static PointelRange	getCellRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Dimension k)

template<typename TDigitalSurfaceContainer >
static PointelRange	getPointelRange (Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)

template<typename TDigitalSurfaceContainer >
static PointelRange	getPointelRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface)

static PointelRange	getPointelRange (const KSpace &K, const SCell &surfel)

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

template<typename TDigitalSurfaceContainer >
static SurfelRange	getSurfelRange (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface, const Surfel &start_surfel, const Parameters &params=parametersDigitalSurface())

static IdxSurfelRange	getIdxSurfelRange (CountedPtr< IdxDigitalSurface > surface, const Parameters &params=parametersDigitalSurface())

static IdxSurfelRange	getIdxSurfelRange (CountedPtr< IdxDigitalSurface > surface, const IdxSurfel &start_surfel, const Parameters &params=parametersDigitalSurface())

template<typename TDigitalSurfaceContainer , typename TCellEmbedder >
static bool	saveOFF (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, const TCellEmbedder &embedder, std::string off_file, const Color &face_color=DGtal::Color::None)

template<typename TDigitalSurfaceContainer , typename TCellEmbedder >
static bool	saveOBJ (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, const TCellEmbedder &embedder, const RealVectors &normals, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)

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

template<typename TDigitalSurfaceContainer >
static bool	saveOFF (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, std::string off_file, const Color &face_color=Color(32, 32, 32))

template<typename TDigitalSurfaceContainer >
static bool	saveOBJ (CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > digsurf, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)

static bool	saveVectorFieldOBJ (const RealPoints &positions, const RealVectors &vf, double thickness, const Colors &diffuse_colors, std::string objfile, const Color &ambient_color=Color(32, 32, 32), const Color &diffuse_color=Color(200, 200, 255), const Color &specular_color=Color::White)

static Parameters	parametersMesh ()

static CountedPtr< TriangulatedSurface >	makeTriangulatedSurface (CountedPtr< Mesh > aMesh)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static Parameters	parametersUtilities ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Detailed Description

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

Aim: This class is used to simplify shape and surface creation. With it, you can create new shapes and surface with few lines of code. 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 'Shortcuts'

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/curvature-measures-icnc-XY-3d.cpp, geometry/meshes/curvature-measures-nc-XY-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-XY-3d.cpp, geometry/meshes/obj-curvature-measures-icnc-XY-3d.cpp, geometry/meshes/vol-curvature-measures-icnc-3d.cpp, geometry/meshes/vol-curvature-measures-icnc-XY-3d.cpp, geometry/volumes/fullConvexityAnalysis3D.cpp, geometry/volumes/fullConvexityCollapsiblePoints2D.cpp, geometry/volumes/fullConvexityLUT2D.cpp, geometry/volumes/fullConvexityShortestPaths3D.cpp, geometry/volumes/fullConvexitySphereGeodesics.cpp, and geometry/volumes/fullConvexityThinning3D.cpp.

Definition at line 101 of file Shortcuts.h.

Member Typedef Documentation

◆ Arc

template<typename TKSpace >

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

Definition at line 162 of file Shortcuts.h.

◆ ArcRange

template<typename TKSpace >

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

Definition at line 164 of file Shortcuts.h.

◆ BinaryImage

template<typename TKSpace >

typedef ImageContainerBySTLVector<Domain, bool> DGtal::Shortcuts< TKSpace >::BinaryImage

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

Definition at line 138 of file Shortcuts.h.

◆ Cell

template<typename TKSpace >

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

Definition at line 159 of file Shortcuts.h.

◆ Cell2Index

template<typename TKSpace >

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

Definition at line 186 of file Shortcuts.h.

◆ CellRange

template<typename TKSpace >

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

Definition at line 171 of file Shortcuts.h.

◆ Color

template<typename TKSpace >

typedef ::DGtal::Color DGtal::Shortcuts< TKSpace >::Color

Definition at line 188 of file Shortcuts.h.

◆ ColorMap

template<typename TKSpace >

typedef GradientColorMap<Scalar> DGtal::Shortcuts< TKSpace >::ColorMap

Definition at line 190 of file Shortcuts.h.

◆ Colors

template<typename TKSpace >

typedef std::vector< Color > DGtal::Shortcuts< TKSpace >::Colors

Definition at line 189 of file Shortcuts.h.

◆ DigitalSurface

template<typename TKSpace >

typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainer > DGtal::Shortcuts< TKSpace >::DigitalSurface

defines an arbitrary digital surface over a binary image.

Definition at line 155 of file Shortcuts.h.

◆ DigitizedImplicitShape3D

template<typename TKSpace >

typedef GaussDigitizer< Space, ImplicitShape3D > DGtal::Shortcuts< TKSpace >::DigitizedImplicitShape3D

defines the digitization of an implicit shape.

Definition at line 136 of file Shortcuts.h.

◆ Domain

template<typename TKSpace >

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

An (hyper-)rectangular domain.

Definition at line 124 of file Shortcuts.h.

◆ DoubleImage

template<typename TKSpace >

typedef ImageContainerBySTLVector<Domain, double> DGtal::Shortcuts< TKSpace >::DoubleImage

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

Definition at line 144 of file Shortcuts.h.

◆ ExplicitSurfaceContainer

template<typename TKSpace >

typedef SetOfSurfels< KSpace, SurfelSet > DGtal::Shortcuts< TKSpace >::ExplicitSurfaceContainer

defines a heavy container that represents any digital surface.

Definition at line 153 of file Shortcuts.h.

◆ Face

template<typename TKSpace >

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

Definition at line 163 of file Shortcuts.h.

◆ FloatImage

template<typename TKSpace >

typedef ImageContainerBySTLVector<Domain, float> DGtal::Shortcuts< TKSpace >::FloatImage

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

Definition at line 142 of file Shortcuts.h.

◆ GrayScale

template<typename TKSpace >

typedef unsigned char DGtal::Shortcuts< TKSpace >::GrayScale

The type for 8-bits gray-scale elements.

Definition at line 126 of file Shortcuts.h.

◆ GrayScaleImage

template<typename TKSpace >

typedef ImageContainerBySTLVector<Domain, GrayScale> DGtal::Shortcuts< TKSpace >::GrayScaleImage

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

Definition at line 140 of file Shortcuts.h.

◆ Idx

template<typename TKSpace >

typedef IdxVertex DGtal::Shortcuts< TKSpace >::Idx

Definition at line 178 of file Shortcuts.h.

◆ IdxArc

template<typename TKSpace >

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

Definition at line 167 of file Shortcuts.h.

◆ IdxArcRange

template<typename TKSpace >

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

Definition at line 168 of file Shortcuts.h.

◆ IdxDigitalSurface

template<typename TKSpace >

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

defines a connected or not indexed digital surface.

Definition at line 157 of file Shortcuts.h.

◆ IdxRange

template<typename TKSpace >

typedef std::vector< IdxVertex > DGtal::Shortcuts< TKSpace >::IdxRange

Definition at line 179 of file Shortcuts.h.

◆ IdxSurfel

template<typename TKSpace >

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

Definition at line 165 of file Shortcuts.h.

◆ IdxSurfelRange

template<typename TKSpace >

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

Definition at line 174 of file Shortcuts.h.

◆ IdxSurfelSet

template<typename TKSpace >

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

Definition at line 169 of file Shortcuts.h.

◆ IdxVertex

template<typename TKSpace >

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

Definition at line 166 of file Shortcuts.h.

◆ ImplicitShape3D

template<typename TKSpace >

typedef ImplicitPolynomial3Shape<Space> DGtal::Shortcuts< TKSpace >::ImplicitShape3D

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

Definition at line 134 of file Shortcuts.h.

◆ Integer

template<typename TKSpace >

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

Integer numbers.

Definition at line 112 of file Shortcuts.h.

◆ KSpace

template<typename TKSpace >

typedef TKSpace DGtal::Shortcuts< TKSpace >::KSpace

Digital cellular space.

Definition at line 108 of file Shortcuts.h.

◆ LightDigitalSurface

template<typename TKSpace >

typedef ::DGtal::DigitalSurface< LightSurfaceContainer > DGtal::Shortcuts< TKSpace >::LightDigitalSurface

defines a connected digital surface over a binary image.

Definition at line 151 of file Shortcuts.h.

◆ LightSurfaceContainer

template<typename TKSpace >

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

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

Definition at line 149 of file Shortcuts.h.

◆ Mesh

template<typename TKSpace >

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

Definition at line 181 of file Shortcuts.h.

◆ Point

template<typename TKSpace >

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

Point with integer coordinates.

Definition at line 114 of file Shortcuts.h.

◆ PointelRange

template<typename TKSpace >

typedef CellRange DGtal::Shortcuts< TKSpace >::PointelRange

Definition at line 172 of file Shortcuts.h.

◆ PolygonalSurface

template<typename TKSpace >

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

Definition at line 183 of file Shortcuts.h.

◆ RealPoint

template<typename TKSpace >

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

Point with floating-point coordinates.

Definition at line 120 of file Shortcuts.h.

◆ RealPoints

template<typename TKSpace >

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

Definition at line 177 of file Shortcuts.h.

◆ RealVector

template<typename TKSpace >

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

Vector with floating-point coordinates.

Definition at line 118 of file Shortcuts.h.

◆ RealVectors

template<typename TKSpace >

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

Definition at line 176 of file Shortcuts.h.

◆ Scalar

template<typename TKSpace >

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

Floating-point numbers.

Definition at line 122 of file Shortcuts.h.

◆ ScalarPolynomial

template<typename TKSpace >

typedef MPolynomial< Space::dimension, Scalar > DGtal::Shortcuts< TKSpace >::ScalarPolynomial

defines a multi-variate polynomial : RealPoint -> Scalar

Definition at line 131 of file Shortcuts.h.

◆ Scalars

template<typename TKSpace >

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

Definition at line 175 of file Shortcuts.h.

◆ SCell

template<typename TKSpace >

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

Definition at line 160 of file Shortcuts.h.

◆ SCellRange

template<typename TKSpace >

typedef std::vector< SCell > DGtal::Shortcuts< TKSpace >::SCellRange

Definition at line 170 of file Shortcuts.h.

◆ Space

template<typename TKSpace >

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

Digital space.

Definition at line 110 of file Shortcuts.h.

◆ SurfaceMesh

template<typename TKSpace >

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

Definition at line 184 of file Shortcuts.h.

◆ Surfel

template<typename TKSpace >

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

Definition at line 158 of file Shortcuts.h.

◆ Surfel2Index

template<typename TKSpace >

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

Definition at line 185 of file Shortcuts.h.

◆ SurfelRange

template<typename TKSpace >

typedef SCellRange DGtal::Shortcuts< TKSpace >::SurfelRange

Definition at line 173 of file Shortcuts.h.

◆ SurfelSet

template<typename TKSpace >

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

defines a set of surfels

Definition at line 146 of file Shortcuts.h.

◆ TriangulatedSurface

template<typename TKSpace >

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

Definition at line 182 of file Shortcuts.h.

◆ Vector

template<typename TKSpace >

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

Vector with integer coordinates.

Definition at line 116 of file Shortcuts.h.

◆ Vertex

template<typename TKSpace >

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

Definition at line 161 of file Shortcuts.h.

◆ ZeroTickedColorMap

template<typename TKSpace >

typedef TickedColorMap<Scalar,ColorMap> DGtal::Shortcuts< TKSpace >::ZeroTickedColorMap

Definition at line 191 of file Shortcuts.h.

Constructor & Destructor Documentation

◆ Shortcuts() [1/3]

template<typename TKSpace >

DGtal::Shortcuts< TKSpace >::Shortcuts ( )

delete

Default constructor.

◆ ~Shortcuts()

template<typename TKSpace >

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

delete

Destructor.

◆ Shortcuts() [2/3]

template<typename TKSpace >

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

delete

Copy constructor.

Parameters

other the object to clone.

◆ Shortcuts() [3/3]

template<typename TKSpace >

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

delete

Move constructor.

Parameters

other the object to move.

Member Function Documentation

◆ BOOST_CONCEPT_ASSERT()

template<typename TKSpace >

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

private

Referenced by DGtal::Shortcuts< TKSpace >::outputDualDigitalSurfaceAsObj(), and DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj().

◆ defaultParameters()

template<typename TKSpace >

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

inlinestatic

Returns: the parameters and their default values used in shortcuts.

Definition at line 200 of file Shortcuts.h.

      {
        return parametersImplicitShape3D()
          | parametersKSpace()
          | parametersDigitizedImplicitShape3D()
          | parametersBinaryImage()
          | parametersGrayScaleImage()
          | parametersDigitalSurface()
          | parametersMesh()
          | parametersUtilities();
      }

References DGtal::Shortcuts< TKSpace >::parametersBinaryImage(), DGtal::Shortcuts< TKSpace >::parametersDigitalSurface(), DGtal::Shortcuts< TKSpace >::parametersDigitizedImplicitShape3D(), DGtal::Shortcuts< TKSpace >::parametersGrayScaleImage(), DGtal::Shortcuts< TKSpace >::parametersImplicitShape3D(), DGtal::Shortcuts< TKSpace >::parametersKSpace(), DGtal::Shortcuts< TKSpace >::parametersMesh(), and DGtal::Shortcuts< TKSpace >::parametersUtilities().

Referenced by main(), and precompute().

◆ getCellEmbedder() [1/3]

template<typename TKSpace >

static CanonicCellEmbedder< KSpace > DGtal::Shortcuts< TKSpace >::getCellEmbedder ( const KSpace & K )

inlinestatic

Parameters

[in] K any Khalimsky space.

Returns: the canonic cell embedder associated to the given Khalimsky space.

Definition at line 435 of file Shortcuts.h.

      {
        return CanonicCellEmbedder<KSpace>( K );
      }

References K.

◆ getCellEmbedder() [2/3]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static CanonicCellEmbedder< KSpace > DGtal::Shortcuts< TKSpace >::getCellEmbedder ( 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 canonic cell embedder associated to the given digital surface.

Definition at line 1271 of file Shortcuts.h.

        {
          return getCellEmbedder( refKSpace( surface ) );
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

◆ getCellEmbedder() [3/3]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static CanonicCellEmbedder< KSpace > DGtal::Shortcuts< TKSpace >::getCellEmbedder ( 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 canonic cell embedder associated to the given indexed digital surface.

Definition at line 1293 of file Shortcuts.h.

        {
          return getCellEmbedder( refKSpace( surface ) );
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

◆ getCellRange() [1/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static CellRange DGtal::Shortcuts< TKSpace >::getCellRange	(	Cell2Index &	c2i,
		CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	surface,
		const Dimension	k
	)

inlinestatic

Given any digital surface, returns the vector of its k-dimensional cells.

Note: The order of cells is given by the default traversal of the surfels of the surface, where the cells of each surfel are visited in no specific order.

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

[out]	c2i	the map Cell -> Cell index in the cell range.
[in]	surface	a smart pointer on a (light or not) digital surface (e.g. DigitalSurface or LightDigitalSurface).
[in]	k	the dimension of the output cells

Returns: a range of cells as a vector.

Definition at line 1659 of file Shortcuts.h.

      {
        CellRange result;
        // Approximate number of pointels given the number of 2-cells (valid for 2d surfaces in nD).
        result.reserve( 2 * surface->size() + 100 );
        const KSpace& K = refKSpace( surface );
        Idx n = 0;
        for ( auto&& surfel : *surface )
          {
            CellRange primal_cells = getPrimalCells( K, surfel, k );
            for ( auto&& primal_cell : primal_cells )
              {
                if ( ! c2i.count( primal_cell ) )
                  {
                    result.push_back( primal_cell );
                    c2i[ primal_cell ] = n++;
                  }
              }
          }
        return result;
      }

References DGtal::Shortcuts< TKSpace >::getPrimalCells(), K, DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::getCellRange().

◆ getCellRange() [2/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static PointelRange DGtal::Shortcuts< TKSpace >::getCellRange	(	CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	surface,
		const Dimension	k
	)

inlinestatic

Given any digital surface, returns the vector of its k-dimensional cells.

Note: The order of cells is given by the default traversal of the surfels of the surface, where the cells of each surfel are visited in no specific order.

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).
[in]	k	the dimension of the output cells

Returns: a range of cells as a vector.

Definition at line 1698 of file Shortcuts.h.

      {
        Cell2Index c2i;
        return getCellRange( c2i, surface, k );
      }

References DGtal::Shortcuts< TKSpace >::getCellRange(), and surface.

◆ getColorMap()

template<typename TKSpace >

static ColorMap DGtal::Shortcuts< TKSpace >::getColorMap	(	Scalar	min,
		Scalar	max,
		const Parameters &	params = `parametersUtilities()`
	)

inlinestatic

Parameters

[in]	min	the minimum considered value for the colormap.
[in]	max	the maximum considered value for the colormap.
[in]	params	the parameters: colormap [ "Custom" ]: "Cool"\|"Copper"\|"Hot"\|"Jet"\|"Spring"\|"Summer"\|"Autumn"\|"Winter"\|"Error"\|"Custom" specifies standard colormaps (if invalid, falls back to "Custom").

Returns: a colormap according to the specified parameters

Definition at line 3011 of file Shortcuts.h.

      {
        std::string cmap = params[ "colormap" ].as<std::string>();
        if      ( cmap == "Cool" )   return ColorMap( min, max, CMAP_COOL );
        else if ( cmap == "Copper" ) return ColorMap( min, max, CMAP_COPPER );
        else if ( cmap == "Hot" )    return ColorMap( min, max, CMAP_HOT );
        else if ( cmap == "Jet" )    return ColorMap( min, max, CMAP_JET );
        else if ( cmap == "Spring" ) return ColorMap( min, max, CMAP_SPRING );
        else if ( cmap == "Summer" ) return ColorMap( min, max, CMAP_SUMMER );
        else if ( cmap == "Autumn" ) return ColorMap( min, max, CMAP_AUTUMN );
        else if ( cmap == "Winter" ) return ColorMap( min, max, CMAP_WINTER );
        else if ( cmap == "Error" )
          {
            ColorMap gradcmap( min, max );
            gradcmap.addColor( Color( 255, 255, 255 ) );
            gradcmap.addColor( Color( 255,   0,   0 ) );
            gradcmap.addColor( Color( 0,   0,   0 ) );
            return gradcmap;
          }
        // Custom colormap 
        ColorMap gradcmap( min, max );
        gradcmap.addColor( Color( 0, 0, 255 ) );
        gradcmap.addColor( Color( 0, 255, 255 ) );
        gradcmap.addColor( Color( 255, 255, 255 ) );
        gradcmap.addColor( Color( 255, 255, 0 ) );
        gradcmap.addColor( Color( 255, 0, 0 ) );
        return gradcmap;
      }

References DGtal::GradientColorMap< PValue, PDefaultPreset, PDefaultFirstColor, PDefaultLastColor >::addColor(), DGtal::CMAP_AUTUMN, DGtal::CMAP_COOL, DGtal::CMAP_COPPER, DGtal::CMAP_HOT, DGtal::CMAP_JET, DGtal::CMAP_SPRING, DGtal::CMAP_SUMMER, DGtal::CMAP_WINTER, and max().

Referenced by DGtal::Shortcuts< TKSpace >::getZeroTickedColorMap().

◆ getIdxSurfelRange() [1/2]

template<typename TKSpace >

static IdxSurfelRange DGtal::Shortcuts< TKSpace >::getIdxSurfelRange	(	CountedPtr< IdxDigitalSurface >	surface,
		const IdxSurfel &	start_surfel,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Given an indexed digital surface, returns a vector of surfels in some specified order.

Parameters

[in]	surface	a smart pointer on a digital surface.
[in]	start_surfel	the surfel where the traversal starts in case of depth-first/breadth-first traversal.
[in]	params	the parameters: surfaceTraversal ["Default"]: "Default"\|"DepthFirst"\|"BreadthFirst": "Default" default surface traversal, "DepthFirst": depth-first surface traversal, "BreadthFirst": breadth-first surface traversal.

Returns: a range of indexed surfels as a vector.

Definition at line 1892 of file Shortcuts.h.

      {
        IdxSurfelRange result;
        std::string traversal = params[ "surfaceTraversal" ].as<std::string>();
        if ( traversal == "DepthFirst" )
          {
            typedef DepthFirstVisitor< IdxDigitalSurface > Visitor;
            typedef GraphVisitorRange< Visitor > VisitorRange;
            VisitorRange range( new Visitor( *surface, start_surfel ) );
            std::for_each( range.begin(), range.end(),
                           [&result] ( IdxSurfel s ) { result.push_back( s ); } );
          }
        else if ( traversal == "BreadthFirst" )
          {
            typedef BreadthFirstVisitor< IdxDigitalSurface > Visitor;
            typedef GraphVisitorRange< Visitor > VisitorRange;
            VisitorRange range( new Visitor( *surface, start_surfel ) );
            std::for_each( range.begin(), range.end(),
                           [&result] ( IdxSurfel s ) { result.push_back( s ); } );
          }
        else return surface->allVertices();
        return result;
      }

References surface.

◆ getIdxSurfelRange() [2/2]

template<typename TKSpace >

static IdxSurfelRange DGtal::Shortcuts< TKSpace >::getIdxSurfelRange	(	CountedPtr< IdxDigitalSurface >	surface,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Given an indexed digital surface, returns a vector of surfels in some specified order.

Parameters

[in]	surface	a smart pointer on a digital surface.
[in]	params	the parameters: surfaceTraversal ["Default"]: "Default"\|"DepthFirst"\|"BreadthFirst": "Default" default surface traversal, "DepthFirst": depth-first surface traversal, "BreadthFirst": breadth-first surface traversal.

Returns: a range of indexed surfels as a vector.

Definition at line 1872 of file Shortcuts.h.

      {
        return getIdxSurfelRange( surface, (IdxSurfel) 0, params );
      }

References DGtal::Shortcuts< TKSpace >::getIdxSurfelRange(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::getIdxSurfelRange(), DGtal::Shortcuts< TKSpace >::makeDigitalSurface(), and DGtal::Shortcuts< TKSpace >::outputPrimalIdxDigitalSurfaceAsObj().

◆ getKSpace() [1/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 329 of file Shortcuts.h.

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

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

Referenced by DGtal::DigitalSurfaceRegularization< TDigitalSurface >::DigitalSurfaceRegularization(), main(), DGtal::Shortcuts< TKSpace >::makePolygonalSurface(), and DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface().

◆ getKSpace() [2/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

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

Returns: the Khalimsky space associated to the given surface.

Definition at line 393 of file Shortcuts.h.

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

References surface.

◆ getKSpace() [3/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

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

Returns: the Khalimsky space associated to the given surface.

Definition at line 404 of file Shortcuts.h.

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

References surface.

◆ getKSpace() [4/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 351 of file Shortcuts.h.

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

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

◆ getKSpace() [5/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 375 of file Shortcuts.h.

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

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

◆ getKSpace() [6/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

[in]

params

the parameters:

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

Returns: the Khalimsky space.

See also: makeDigitizedImplicitShape3D

Definition at line 483 of file Shortcuts.h.

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

References domain, DGtal::Trace::error(), K, DGtal::HyperRectDomain< TSpace >::lowerBound(), DGtal::trace, and DGtal::HyperRectDomain< TSpace >::upperBound().

◆ getMatchedRange()

template<typename TKSpace >

template<typename TValue >

static std::vector< TValue > DGtal::Shortcuts< TKSpace >::getMatchedRange	(	const std::vector< TValue > &	range,
		const IdxRange &	match
	)

inlinestatic

Given a perfect or approximate match, returns the corresponding reordered/rematched range.

Parameters

[in]	range	any range.
[in]	match	a function V: Idx -> Idx such that `result[ i ] = range[ match[ i ] ]`.

Returns: the the corresponding reordered/rematched range.

See also: getRangeMatch

Definition at line 2996 of file Shortcuts.h.

        {
          std::vector< TValue > result( match.size() );
          for ( Idx i = 0; i < result.size(); i++ )
            result[ i ] = range[ match[ i ] ]; 
          return result;
        }

◆ getPointelRange() [1/3]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static PointelRange DGtal::Shortcuts< TKSpace >::getPointelRange	(	Cell2Index &	c2i,
		CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	surface
	)

inlinestatic

Given any digital surface, returns the vector of its pointels.

Note: The order of pointels is given by the default traversal of the surfels of the surface, where the 4 pointels of each surfel are visited in order.

Since: 1.1 The pointel ordering is now the same as the one given by makePrimalPolygonalSurface (for 3D only of course).

Note: If you wish to consider the primal digital surface, and visits pointels as vertices of this graph in breadth-first/depth-first order, the best is to build first a PolygonalSurface and then use specialized visitors.

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

[out]	c2i	the map Cell -> Vertex index in the pointel range.
[in]	surface	a smart pointer on a (light or not) digital surface (e.g. DigitalSurface or LightDigitalSurface).

Returns: a range of pointels as a vector.

Definition at line 1729 of file Shortcuts.h.

        {
          PointelRange result;
          result.reserve( surface->size() );
          const KSpace& K = refKSpace( surface );
          Idx n = 0;
          for ( auto&& surfel : *surface )
            {
              CellRange primal_vtcs = getPointelRange( K, surfel );
              for ( auto&& primal_vtx : primal_vtcs )
                {
                  if ( ! c2i.count( primal_vtx ) )
                    {
                      result.push_back( primal_vtx );
                      c2i[ primal_vtx ] = n++;
                    }
                }
            }
          return result;
        }

References DGtal::Shortcuts< TKSpace >::getPointelRange(), K, DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::getPointelRange(), DGtal::Shortcuts< TKSpace >::getPointelRange(), DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj(), DGtal::Shortcuts< TKSpace >::saveOBJ(), and DGtal::Shortcuts< TKSpace >::saveOFF().

◆ getPointelRange() [2/3]

template<typename TKSpace >

static PointelRange DGtal::Shortcuts< TKSpace >::getPointelRange	(	const KSpace &	K,
		const SCell &	surfel
	)

inlinestatic

Given any surfel, returns its 4 pointels in ccw order.

See also: getPrimalVertices

Parameters

[in]	K	the Khalimsky space
[in]	surfel	any surfel that lives in the Khalimsky space

Returns: a range of pointels as a vector.

Definition at line 1786 of file Shortcuts.h.

      {
        return KSpace::dimension == 3
          ? getPrimalVertices( K, surfel, true )
          : getPrimalVertices( K, surfel );
      }

References DGtal::KhalimskySpaceND< dim, TInteger >::dimension, DGtal::Shortcuts< TKSpace >::getPrimalVertices(), and K.

◆ getPointelRange() [3/3]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static PointelRange DGtal::Shortcuts< TKSpace >::getPointelRange ( CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > > surface )

inlinestatic

Given any digital surface, returns the vector of its pointels.

Note: The order of pointels is given by the default traversal of the surfels of the surface, where the 4 pointels of each surfel are visited in order.; If you wish to consider the primal digital surface, and visits pointels as vertices of this graph in breadth-first/depth-first order, the best is to build first a PolygonalSurface and then use specialized visitors.

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: a range of pointels as a vector.

Definition at line 1770 of file Shortcuts.h.

      {
        Cell2Index c2i;
        return getPointelRange( c2i, surface );
      }

References DGtal::Shortcuts< TKSpace >::getPointelRange(), and surface.

◆ getPolynomialList()

template<typename TKSpace >

static std::map< std::string, std::string > DGtal::Shortcuts< TKSpace >::getPolynomialList ( )

inlinestatic

Returns a map associating a name and a polynomial, e.g. "sphere1", "x^2+y^2+z^2-1".

{ "sphere1", "x^2+y^2+z^2-1" }, { "sphere9", "x^2+y^2+z^2-81" }, { "ellipsoid", "3*x^2+2*y^2+z^2-90" }, { "cylinder", "x^2+2*z^2-90" }, { "torus", "(x^2+y^2+z^2+6*6-2*2)^2-4*6*6*(x^2+y^2)" }, { "rcube", "x^4+y^4+z^4-6561" }, { "goursat", "-1*(8-0.03*x^4-0.03*y^4-0.03*z^4+2*x^2+2*y^2+2*z^2)" }, { "distel", "10000-(x^2+y^2+z^2+1000*(x^2+y^2)*(x^2+z^2)*(y^2+z^2))"}, { "leopold", "(x^2*y^2*z^2+4*x^2+4*y^2+3*z^2)-100" }, { "diabolo", "x^2-(y^2+z^2)^2" }, { "heart", "-1*(x^2+2.25*y^2+z^2-1)^3+x^2*z^3+0.1125*y^2*z^3" }, { "crixxi", "-0.9*(y^2+z^2-1)^2-(x^2+y^2-1)^3" }

Returns: the map associating a polynomial to a name.

Definition at line 233 of file Shortcuts.h.

        {
          std::vector< std::pair< std::string, std::string > >
            Ps = { { "sphere1", "x^2+y^2+z^2-1" },
                   { "sphere9", "x^2+y^2+z^2-81" },
                   { "ellipsoid", "3*x^2+2*y^2+z^2-90" },
                   { "cylinder", "x^2+2*z^2-90" },
                   { "torus",   "(x^2+y^2+z^2+6*6-2*2)^2-4*6*6*(x^2+y^2)" },
                   { "rcube",   "x^4+y^4+z^4-6561" },
                   { "goursat", "-1*(8-0.03*x^4-0.03*y^4-0.03*z^4+2*x^2+2*y^2+2*z^2)" },
                   { "goursat-hole", "x^4+y^4+z^4-2*4*(x^2+y^2+z^2)+2*4*4-2" },
                   { "distel",  "10000-(x^2+y^2+z^2+1000*(x^2+y^2)*(x^2+z^2)*(y^2+z^2))"},
                   { "leopold", "(x^2*y^2*z^2+4*x^2+4*y^2+3*z^2)-100" },
                   { "diabolo", "x^2-(y^2+z^2)^2" },
                   { "heart",   "-1*(x^2+2.25*y^2+z^2-1)^3+x^2*z^3+0.1125*y^2*z^3" },
                   { "crixxi",  "-0.9*(y^2+z^2-1)^2-(x^2+y^2-1)^3" } };
          std::map< std::string, std::string > L;
          for ( auto p : Ps )
            L[ p.first ] = p.second;
          return L;
        }

References DGtal::L.

Referenced by DGtal::Shortcuts< TKSpace >::makeImplicitShape3D().

◆ getPrimalCells()

template<typename TKSpace >

static CellRange DGtal::Shortcuts< TKSpace >::getPrimalCells	(	const KSpace &	K,
		const SCell &	s,
		const Dimension	k
	)

inlinestatic

Given a space K and an oriented cell s, returns its vertices.

Parameters

K	any cellular grid space.
s	any signed cell.
k	any dimension between 0 and `K.sdim(s)`.

Returns: the vector of the faces of dimension k of s, as unsigned cells.

Definition at line 3507 of file Shortcuts.h.

      {
        auto faces = K.uFaces( K.unsigns( s ) );
        CellRange primal_cells;
        for ( auto&& f : faces )
          {
            if ( K.uDim( f ) == k ) primal_cells.push_back( f );
          }
        return primal_cells;
      }

References K.

Referenced by DGtal::Shortcuts< TKSpace >::getCellRange(), and DGtal::Shortcuts< TKSpace >::getPrimalVertices().

◆ getPrimalVertices() [1/2]

template<typename TKSpace >

static CellRange DGtal::Shortcuts< TKSpace >::getPrimalVertices	(	const KSpace &	K,
		const SCell &	s
	)

inlinestatic

Given a space K and an oriented cell s, returns its vertices.

Parameters

K	any cellular grid space.
s	any signed cell.

Returns: the vector of the vertices of s, as unsigned cells of dimension 0.

Definition at line 3523 of file Shortcuts.h.

      {
        return getPrimalCells( K, s, 0 );
      }

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

Referenced by DGtal::Shortcuts< TKSpace >::getPointelRange(), and DGtal::Shortcuts< TKSpace >::getPrimalVertices().

◆ getPrimalVertices() [2/2]

template<typename TKSpace >

static CellRange DGtal::Shortcuts< TKSpace >::getPrimalVertices	(	const KSpace &	K,
		const Surfel &	s,
		bool	ccw
	)

inlinestatic

Given a space K and a surfel s, returns its vertices in ccw or cw order.

Parameters

K	any cellular grid space of dimension 3.
s	any surfel, a signed cell of dimension 2.
ccw	when 'true', the order corresponds to a ccw orientation seen from the exterior normal to the surfel, otherwise it is a cw order.

Returns: the vector of the vertices of s, as unsigned cells of dimension 0.

Note: useful when exporting faces to OBJ format.

Definition at line 3535 of file Shortcuts.h.

      {
        BOOST_STATIC_ASSERT(( KSpace::dimension == 3 ));
        CellRange vtcs = getPrimalVertices( K, s );
        std::swap( vtcs[ 2 ], vtcs[ 3 ] );
        auto  orth_dir = K.sOrthDir( s );
        auto    direct = K.sDirect( s, orth_dir ) ? ccw : ! ccw;
        Vector    s0s1 = K.uCoords( vtcs[ 1 ] ) - K.uCoords( vtcs[ 0 ] );
        Vector    s0s2 = K.uCoords( vtcs[ 2 ] ) - K.uCoords( vtcs[ 0 ] );
        Vector       t = s0s1.crossProduct( s0s2 );
        if ( ( ( t[ orth_dir ] > 0.0 ) && direct )
             || ( ( t[ orth_dir ] < 0.0 ) && ! direct ) )
          std::reverse( vtcs.begin(), vtcs.end() );
        return vtcs;
      }

References DGtal::PointVector< dim, TEuclideanRing, TContainer >::crossProduct(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, DGtal::Shortcuts< TKSpace >::getPrimalVertices(), and K.

◆ getRangeMatch()

template<typename TKSpace >

template<typename TValue >

static IdxRange DGtal::Shortcuts< TKSpace >::getRangeMatch	(	const std::vector< TValue > &	s1,
		const std::vector< TValue > &	s2,
		bool	perfect = `false`
	)

inlinestatic

Given two ranges with same elements but not necessarily in the same order, returns a vector V: index -> index such that s1[ i ] == s2[ V[ i ] ].

Template Parameters

TValue a model of boost::Assignable, boost::CopyConstructible, boost::LessThanComparable

Parameters

[in]	s1	a range of values
[in]	s2	another range of values which contains the same values as s1 but in any order.
[in]	perfect	if 'true' ask for a perfect match, otherwise extracts correspondences.

Returns: the vector V: index -> index such that s1[ i ] == s2[ V[ i ] ]. If perfect is true, then an empty range is returned in case of mismatch.

Note: if perfect==false and s1[ i ] is not in s2, then V[ i ] = s2.size().

Definition at line 2961 of file Shortcuts.h.

        {
          if ( perfect && ( s1.size() != s2.size() ) ) return IdxRange();
          std::map<TValue, Idx> M;
          Idx idx = 0;
          for ( auto val : s2 ) M[ val ] = idx++;
          IdxRange V( s1.size() );
          idx = 0;
          for ( auto val : s1 )
            {
              auto it = M.find( val );
              if ( it != M.end() ) V[ idx++ ] = it->second;
              else
                {
                  if ( perfect ) return IdxRange();
                  V[ idx++ ] = s2.size();
                }
            }
          return V;
        }

◆ getSCellEmbedder() [1/3]

template<typename TKSpace >

static CanonicSCellEmbedder< KSpace > DGtal::Shortcuts< TKSpace >::getSCellEmbedder ( const KSpace & K )

inlinestatic

Parameters

[in] K any Khalimsky space.

Returns: the canonic signed cell embedder associated to the given Khalimsky space.

Definition at line 443 of file Shortcuts.h.

      {
        return CanonicSCellEmbedder<KSpace>( K );
      }

References K.

Referenced by DGtal::Shortcuts< TKSpace >::getSCellEmbedder(), and DGtal::Shortcuts< TKSpace >::getSCellEmbedder().

◆ getSCellEmbedder() [2/3]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static CanonicSCellEmbedder< KSpace > DGtal::Shortcuts< TKSpace >::getSCellEmbedder ( 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 canonic signed cell embedder associated to the given digital surface.

Definition at line 1282 of file Shortcuts.h.

        {
          return getSCellEmbedder( refKSpace( surface ) );
        }

References DGtal::Shortcuts< TKSpace >::getSCellEmbedder(), DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

◆ getSCellEmbedder() [3/3]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static CanonicSCellEmbedder< KSpace > DGtal::Shortcuts< TKSpace >::getSCellEmbedder ( 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 canonic signed cell embedder associated to the given indexed digital surface.

Definition at line 1304 of file Shortcuts.h.

        {
          return getSCellEmbedder( refKSpace( surface ) );
        }

References DGtal::Shortcuts< TKSpace >::getSCellEmbedder(), DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

◆ getSurfelRange() [1/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static SurfelRange DGtal::Shortcuts< TKSpace >::getSurfelRange	(	CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	surface,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Given any digital surface, returns a vector of surfels in some specified order.

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).
[in]	params	the parameters: surfaceTraversal ["Default"]: "Default"\|"DepthFirst"\|"BreadthFirst": "Default" default surface traversal, "DepthFirst": depth-first surface traversal, "BreadthFirst": breadth-first surface traversal.

Returns: a range of surfels as a vector.

Definition at line 1807 of file Shortcuts.h.

      {
        return getSurfelRange( surface, *( surface->begin() ), params );
      }

References DGtal::Shortcuts< TKSpace >::getSurfelRange(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::getSurfelRange(), main(), DGtal::Shortcuts< TKSpace >::outputPrimalDigitalSurfaceAsObj(), and precompute().

◆ getSurfelRange() [2/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static SurfelRange DGtal::Shortcuts< TKSpace >::getSurfelRange	(	CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	surface,
		const Surfel &	start_surfel,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Given a light digital surface, returns a vector of surfels in some specified order.

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).
[in]	start_surfel	the surfel where the traversal starts in case of depth-first/breadth-first traversal.
[in]	params	the parameters: surfaceTraversal ["Default"]: "Default"\|"DepthFirst"\|"BreadthFirst": "Default" default surface traversal, "DepthFirst": depth-first surface traversal, "BreadthFirst": breadth-first surface traversal.

Returns: a range of surfels as a vector.

Definition at line 1830 of file Shortcuts.h.

      {
        typedef ::DGtal::DigitalSurface<TDigitalSurfaceContainer> AnyDigitalSurface;
        SurfelRange result;
        std::string traversal = params[ "surfaceTraversal" ].as<std::string>();
        if ( traversal == "DepthFirst" )
          {
            typedef DepthFirstVisitor< AnyDigitalSurface > Visitor;
            typedef GraphVisitorRange< Visitor > VisitorRange;
            VisitorRange range( new Visitor( *surface, start_surfel ) );
            std::for_each( range.begin(), range.end(),
                           [&result] ( Surfel s ) { result.push_back( s ); } );
          }
        else if ( traversal == "BreadthFirst" )
          {
            typedef BreadthFirstVisitor< AnyDigitalSurface > Visitor;
            typedef GraphVisitorRange< Visitor > VisitorRange;
            VisitorRange range( new Visitor( *surface, start_surfel ) );
            std::for_each( range.begin(), range.end(),
                           [&result] ( Surfel s ) { result.push_back( s ); } );
          }
        else
          {
            std::for_each( surface->begin(), surface->end(),
                           [&result] ( Surfel s ) { result.push_back( s ); } );
          }
        return result;
      }

References surface.

◆ getZeroTickedColorMap()

template<typename TKSpace >

static ZeroTickedColorMap DGtal::Shortcuts< TKSpace >::getZeroTickedColorMap	(	Scalar	min,
		Scalar	max,
		const Parameters &	params = `parametersUtilities()`
	)

inlinestatic

Parameters

[in]	min	the minimum considered value for the colormap.
[in]	max	the maximum considered value for the colormap.
[in]	params	the parameters: colormap [ "Custom" ]: "Cool"\|"Copper"\|"Hot"\|"Jet"\|"Spring"\|"Summer"\|"Autumn"\|"Winter"\|"Error"\|"Custom" specifies standard colormaps (if invalid, falls back to "Custom"). zero-tic [ 0.0 ]: if positive defines a black zone ]-zt,zt[ in the colormap.

Returns: a colormap according to the specified parameters adapted to make darker tics for a background "Tics" colormap.

Definition at line 3049 of file Shortcuts.h.

      {
        auto cmap = getColorMap( min, max, params );
        auto ztic = params[ "zero-tic" ].as<double>();
        ZeroTickedColorMap ztic_cmap( cmap, Color::Black );
        if ( ztic <= 0.0 ) return ztic_cmap;
        if ( min <= 0.0 && 0.0 <= max )
          ztic_cmap.addTick( 0.0, ztic );
        ztic_cmap.finalize();
        return ztic_cmap;
      }

References DGtal::Color::Black, DGtal::Shortcuts< TKSpace >::getColorMap(), and max().

◆ isValid()

template<typename TKSpace >

bool DGtal::Shortcuts< TKSpace >::isValid ( ) const

inline

Checks the validity/consistency of the object.

Returns: 'true' if the object is valid, 'false' otherwise.

Definition at line 3607 of file Shortcuts.h.

      {
        return true;
      }

◆ makeBinaryImage() [1/9]

template<typename TKSpace >

template<typename T , template< class... > class C1, template< class... > class C2, template< class... > class C3>

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	const C1< C2< C3< T > > > &	values,
		std::optional< Domain >	override_domain = `std::nullopt`
	)

inlinestatic

Create an arbitrary image from a vector where non zero values indicates voxels

Note: This overloads expect consistent size of subarrays. This is not checked.

Parameters

[in]	values	A vector (of vector of vector) where non-zero values indicates a voxel
[in]	override_domain	Overrides computed domain if needed

Returns: a smart pointer on a binary image

Definition at line 720 of file Shortcuts.h.

        {
          Domain d;
          if (override_domain.has_value()) 
          {
            d = override_domain.value();
          }
          else if (values.size() != 0) 
          {
            if (values[0].size() != 0)
            {
              if (values[0][0].size() != 0)
              {
                d = Domain(Point(0, 0, 0), Point(values.size(), values[0].size(), values[0][0].size()));
              }
            }
          }
 
          CountedPtr<BinaryImage> image(new BinaryImage(d));
          Point begin = d.lowerBound();
          for (size_t i = 0; i < values.size(); ++i)
          {
            for (size_t j = 0; j < values[i].size(); ++j)
            {
              for (size_t k = 0; k < values[i][j].size(); ++k)
              {
                Point p = begin + Point(i, j, k);
                image->setValue(p, static_cast<bool>(values[i][j][k]));
              }
            }
          }
 
          return image;
        }

References image(), and DGtal::HyperRectDomain< TSpace >::lowerBound().

◆ makeBinaryImage() [2/9]

template<typename TKSpace >

template<typename T , std::enable_if_t<!is_double_nested_container< T >::value, int > = 0>

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	const std::vector< T > &	positions,
		std::optional< Domain >	override_domain = `std::nullopt`
	)

inlinestatic

Create an arbitrary image from a vector of positions

Note: This overloads expect consistent size of subarrays. This is not checked.

Parameters

[in]	positions	A vector of positions to indicates locations of voxels
[in]	override_domain	Overrides computed domain if needed

Returns: a smart pointer on a binary image

Definition at line 767 of file Shortcuts.h.

      {
        Domain d;
        if (override_domain.has_value())
        {
          d = override_domain.value();
        }
        else if (positions.size() != 0)
        {
            Point lb(positions[0][0], positions[0][1], positions[0][2]);
            Point ub(positions[0][0], positions[0][1], positions[0][2]);
 
            for (size_t i = 0; i < positions.size(); ++i) 
            {
              lb[0] = std::min(lb[0], static_cast<typename Point::Component>(positions[i][0]));
              lb[1] = std::min(lb[1], static_cast<typename Point::Component>(positions[i][1]));
              lb[2] = std::min(lb[2], static_cast<typename Point::Component>(positions[i][2]));
 
              ub[0] = std::max(ub[0], static_cast<typename Point::Component>(positions[i][0]));
              ub[1] = std::max(ub[1], static_cast<typename Point::Component>(positions[i][1]));
              ub[2] = std::max(ub[2], static_cast<typename Point::Component>(positions[i][2]));
            }
 
            d = Domain(lb, ub);
        }
 
        CountedPtr<BinaryImage> image(new BinaryImage(d));
        for (size_t i = 0; i < positions.size(); ++i) 
        {
          // Builds a points for generality, T may not be a PointVector instance
          Point p({positions[i][0], positions[i][1], positions[i][2]});
          image->setValue(p, true);
        }
        return image;
      }

References image().

◆ makeBinaryImage() [3/9]

template<typename TKSpace >

template<typename T , typename __U = std::enable_if_t<std::is_arithmetic_v<T>>>

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	const std::vector< T > &	values,
		const Domain &	d
	)

inlinestatic

Create an arbitrary image from a vector where non zero values indicates voxels

Note: This overload expects a linearized array. Positions are infered from the domain. The order must be the same

Parameters

[in]	values	A vector where non-zero values indicates voxels
[in]	d	The domain of the image

Returns: a smart pointer on a binary image

Definition at line 690 of file Shortcuts.h.

        {
            CountedPtr<BinaryImage> image(new BinaryImage(d));
            
            size_t i = 0;
            for (auto it = d.begin(); it != d.end(); ++i, ++it)
            {
              image->setValue(*it, static_cast<bool>(values[i]));
            }
 
            return image;
        }

References DGtal::HyperRectDomain< TSpace >::begin(), DGtal::HyperRectDomain< TSpace >::end(), and image().

◆ makeBinaryImage() [4/9]

template<typename TKSpace >

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	CountedPtr< BinaryImage >	bimage,
		Parameters	params = `parametersBinaryImage()`
	)

inlinestatic

Adds Kanungo noise to a binary image and returns the resulting new image.

Parameters

[in]	bimage	a smart pointer on a binary image.
[in]	params	the parameters: noise [0.0]: specifies the Kanungo noise level for binary pictures.

Returns: a smart pointer on the noisified binary image.

Definition at line 625 of file Shortcuts.h.

      {
        const Scalar noise = params[ "noise"  ].as<Scalar>();
        if ( noise <= 0.0 ) return bimage;
        typedef KanungoNoise< BinaryImage, Domain > KanungoPredicate;
        const Domain shapeDomain    = bimage->domain();
        CountedPtr<BinaryImage> img ( new BinaryImage( shapeDomain ) );
        KanungoPredicate noisy_dshape( *bimage, shapeDomain, noise );
        std::transform( shapeDomain.begin(), shapeDomain.end(),
                        img->begin(),
                        [&noisy_dshape] ( const Point& p ) { return noisy_dshape(p); } );
        return img;
      }

References DGtal::HyperRectDomain< TSpace >::begin(), and DGtal::HyperRectDomain< TSpace >::end().

◆ makeBinaryImage() [5/9]

template<typename TKSpace >

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	CountedPtr< DigitizedImplicitShape3D >	shape_digitization,
		Domain	shapeDomain,
		Parameters	params = `parametersBinaryImage()`
	)

inlinestatic

Vectorizes an implicitly defined digital shape into a binary image, in the specified (hyper-)rectangular domain, and possibly add Kanungo noise to the result depending on parameters given in params.

Parameters

[in]	shape_digitization	a smart pointer on an implicit digital shape.
[in]	shapeDomain	any domain.
[in]	params	the parameters: noise [0.0]: specifies the Kanungo noise level for binary pictures.

Returns: a smart pointer on a binary image that samples the digital shape.

Definition at line 593 of file Shortcuts.h.

      {
        const Scalar noise        = params[ "noise"  ].as<Scalar>();
        CountedPtr<BinaryImage> img ( new BinaryImage( shapeDomain ) );
        if ( noise <= 0.0 )
          {
            std::transform( shapeDomain.begin(), shapeDomain.end(),
                            img->begin(),
                            [&shape_digitization]
                            ( const Point& p ) { return (*shape_digitization)(p); } );
          }
        else
          {
            typedef KanungoNoise< DigitizedImplicitShape3D, Domain > KanungoPredicate;
            KanungoPredicate noisy_dshape( *shape_digitization, shapeDomain, noise );
            std::transform( shapeDomain.begin(), shapeDomain.end(),
                            img->begin(),
                            [&noisy_dshape] ( const Point& p ) { return noisy_dshape(p); } );
          }
        return img;
      }

References DGtal::HyperRectDomain< TSpace >::begin(), and DGtal::HyperRectDomain< TSpace >::end().

◆ makeBinaryImage() [6/9]

template<typename TKSpace >

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	CountedPtr< DigitizedImplicitShape3D >	shape_digitization,
		Parameters	params = `parametersBinaryImage()`
	)

inlinestatic

Vectorizes an implicitly defined digital shape into a binary image, and possibly add Kanungo noise to the result depending on parameters given in params.

Parameters

[in]	shape_digitization	a smart pointer on an implicit digital shape.
[in]	params	the parameters: noise [0.0]: specifies the Kanungo noise level for binary pictures.

Returns: a smart pointer on a binary image that samples the digital shape.

Definition at line 573 of file Shortcuts.h.

      {
        return makeBinaryImage( shape_digitization,
                                shape_digitization->getDomain(),
                                params );
      }

References DGtal::Shortcuts< TKSpace >::makeBinaryImage().

◆ makeBinaryImage() [7/9]

template<typename TKSpace >

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage	(	CountedPtr< GrayScaleImage >	gray_scale_image,
		Parameters	params = `parametersBinaryImage()`
	)

inlinestatic

Binarizes an arbitrary gray scale image file and returns the binary image corresponding to the threshold/noise parameters.

Parameters

[in]	gray_scale_image	the input gray scale image.
[in]	params	the parameters: noise [0.0]: specifies the Kanungo noise level for binary pictures. thresholdMin [ 0]: specifies the threshold min (excluded) to define binary shape thresholdMax [255]: specifies the threshold max (included) to define binary shape

Returns: a smart pointer on a binary image that represents the (thresholded/noisified) gray scale image.

Definition at line 817 of file Shortcuts.h.

      {
        int     thresholdMin = params["thresholdMin"].as<int>();
        int     thresholdMax = params["thresholdMax"].as<int>();
        Domain        domain = gray_scale_image->domain();
        typedef functors::IntervalForegroundPredicate<GrayScaleImage> ThresholdedImage;
        ThresholdedImage tImage( *gray_scale_image, thresholdMin, thresholdMax );
        CountedPtr<BinaryImage> img ( new BinaryImage( domain ) );
        std::transform( domain.begin(), domain.end(),
                        img->begin(),
                        [tImage] ( const Point& p ) { return tImage(p); } );
        return makeBinaryImage( img, params );
      }

References DGtal::HyperRectDomain< TSpace >::begin(), domain, DGtal::HyperRectDomain< TSpace >::end(), and DGtal::Shortcuts< TKSpace >::makeBinaryImage().

◆ makeBinaryImage() [8/9]

template<typename TKSpace >

static CountedPtr< BinaryImage > DGtal::Shortcuts< TKSpace >::makeBinaryImage ( Domain shapeDomain )

inlinestatic

Makes an empty binary image within a given domain.

Parameters

[in] shapeDomain any domain.

Returns: a smart pointer on a binary image that fits the given domain.

Definition at line 558 of file Shortcuts.h.

      {
        return CountedPtr<BinaryImage>( new BinaryImage( shapeDomain ) );
      }

Referenced by main(), DGtal::Shortcuts< TKSpace >::makeBinaryImage(), DGtal::Shortcuts< TKSpace >::makeBinaryImage(), DGtal::Shortcuts< TKSpace >::makeBinaryImage(), DGtal::Shortcuts< TKSpace >::makePolygonalSurface(), and DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface().

◆ makeBinaryImage() [9/9]

template<typename TKSpace >

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

inlinestatic

Loads an arbitrary image file (e.g. vol file in 3D) and returns the binary image corresponding to the threshold/noise parameters.

Parameters

[in]	input	the input filename.
[in]	params	the parameters: noise [0.0]: specifies the Kanungo noise level for binary pictures. thresholdMin [ 0]: specifies the threshold min (excluded) to define binary shape thresholdMax [255]: specifies the threshold max (included) to define binary shape

Returns: a smart pointer on a binary image that represents the (thresholded/noisified) image file.

Definition at line 652 of file Shortcuts.h.

      {
        int     thresholdMin = params["thresholdMin"].as<int>();
        int     thresholdMax = params["thresholdMax"].as<int>();
        GrayScaleImage image = GenericReader<GrayScaleImage>::import( input );
        Domain        domain = image.domain();
        typedef functors::IntervalForegroundPredicate<GrayScaleImage> ThresholdedImage;
        ThresholdedImage tImage( image, thresholdMin, thresholdMax );
        CountedPtr<BinaryImage> img ( new BinaryImage( domain ) );
        std::transform( domain.begin(), domain.end(),
                        img->begin(),
                        [tImage] ( const Point& p ) { return tImage(p); } );
        return makeBinaryImage( img, params );
      }

References DGtal::HyperRectDomain< TSpace >::begin(), domain, DGtal::HyperRectDomain< TSpace >::end(), image(), DGtal::GenericReader< TContainer, Tdim, TValue >::import(), and DGtal::Shortcuts< TKSpace >::makeBinaryImage().

◆ makeDigitalSurface() [1/2]

template<typename TKSpace >

static CountedPtr< DigitalSurface > DGtal::Shortcuts< TKSpace >::makeDigitalSurface	(	CountedPtr< IdxDigitalSurface >	idx_surface,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Builds a explicit digital surface from an indexed digital surface.

Note: if the given surfel adjacency is not the same as the one chosen for the input indexed digital surface, the number of connected components may change in the process.

Parameters

[in]	idx_surface	any indexed digital surface.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int)

Returns: a smart pointer on a explicit digital surface.

Definition at line 1500 of file Shortcuts.h.

      {
        bool surfel_adjacency      = params[ "surfelAdjacency" ].as<int>();
        const KSpace& K = refKSpace( idx_surface );
        SurfelAdjacency< KSpace::dimension > surfAdj( surfel_adjacency );
        auto all_idx_surfels
          = getIdxSurfelRange( idx_surface, Parameters( "surfaceTraversal", "Default" ) );
        auto idx2surfel = idx_surface->surfels();
        SurfelSet all_surfels;
        for ( auto idx : all_idx_surfels ) all_surfels.insert( idx2surfel[ idx ] );
        ExplicitSurfaceContainer* surfContainer
          = new ExplicitSurfaceContainer( K, surfAdj, all_surfels );
        return CountedPtr<DigitalSurface>
          ( new DigitalSurface( surfContainer ) ); // acquired
      }

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

◆ makeDigitalSurface() [2/2]

template<typename TKSpace >

template<typename TPointPredicate >

static CountedPtr< DigitalSurface > DGtal::Shortcuts< TKSpace >::makeDigitalSurface	(	CountedPtr< TPointPredicate >	bimage,
		const KSpace &	K,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Creates a explicit digital surface representing the boundaries in the binary image bimage, or any one of its big components according to parameters.

Template Parameters

TPointPredicate any type representing a point predicate (e.g. a BinaryImage or a DigitizedImplicitShape3D).

Parameters

[in]	bimage	any point predicate: Point -> boolean that represents the characteristic function of a digital shape
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int)

Returns: a smart pointer on the explicit digital surface representing the boundaries in the binary image.

Definition at line 1469 of file Shortcuts.h.

        {
          SurfelSet all_surfels;
          bool      surfel_adjacency = params[ "surfelAdjacency" ].as<int>();
          SurfelAdjacency< KSpace::dimension > surfAdj( surfel_adjacency );
          // Extracts all boundary surfels
          Surfaces<KSpace>::sMakeBoundary( all_surfels, K, *bimage,
                                           K.lowerBound(), K.upperBound() );
          ExplicitSurfaceContainer* surfContainer
            = new ExplicitSurfaceContainer( K, surfAdj, all_surfels );
          return CountedPtr< DigitalSurface >
            ( new DigitalSurface( surfContainer ) ); // acquired
        }

References K, and DGtal::Surfaces< TKSpace >::sMakeBoundary().

Referenced by main(), DGtal::Shortcuts< TKSpace >::makePolygonalSurface(), DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface(), DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh(), and DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface().

◆ makeDigitizedImplicitShape3D()

template<typename TKSpace >

static CountedPtr< DigitizedImplicitShape3D > DGtal::Shortcuts< TKSpace >::makeDigitizedImplicitShape3D	(	CountedPtr< ImplicitShape3D >	shape,
		Parameters	params = `parametersDigitizedImplicitShape3D()`
	)

inlinestatic

Makes the Gauss digitization of the given implicit shape according to parameters. Use getKSpace to build the associated digital space.

Parameters

[in]	shape	a smart pointer on the implicit shape.
[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.

Returns: a smart pointer on the created implicit digital shape.

See also: getKSpaceDigitizedImplicitShape3D

Definition at line 519 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>();
        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->attach( shape );
        dshape->init( p1, p2, h );
        return dshape;
      }

Referenced by main().

◆ makeDoubleImage() [1/3]

template<typename TKSpace >

static CountedPtr< DoubleImage > DGtal::Shortcuts< TKSpace >::makeDoubleImage	(	CountedPtr< ImplicitShape3D >	shape,
		Parameters	params = `parametersDigitizedImplicitShape3D()`
	)

inlinestatic

Makes a double image from the given implicit shape according to parameters. Use getKSpace to build the associated digital space.

Parameters

[in]	shape	a smart pointer on the implicit shape.
[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.

Returns: a smart pointer on the created image.

Definition at line 1224 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>();
        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->attach( shape );
        dshape->init( p1, p2, h );
        Domain domain = dshape->getDomain();
        auto   fimage = makeDoubleImage( domain );
        auto       it = fimage->begin();
        for ( auto p : domain )
          {
            double val = (double) (*shape)( p );
            *it++      = val;
          }
        return fimage;
      }

References domain, and DGtal::Shortcuts< TKSpace >::makeDoubleImage().

◆ makeDoubleImage() [2/3]

template<typename TKSpace >

static CountedPtr< DoubleImage > DGtal::Shortcuts< TKSpace >::makeDoubleImage ( Domain aDomain )

inlinestatic

Makes an empty double image within a given domain (values are unsigned char).

Parameters

[in] aDomain any domain.

Returns: a smart pointer on a double image that fits the given domain.

Definition at line 1191 of file Shortcuts.h.

      {
        return CountedPtr<DoubleImage>( new DoubleImage( aDomain ) );
      }

Referenced by DGtal::Shortcuts< TKSpace >::makeDoubleImage().

◆ makeDoubleImage() [3/3]

template<typename TKSpace >

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

inlinestatic

Loads an arbitrary image file (e.g. vol file in 3D) and returns the corresponding double image.

Parameters

[in] input the input filename.

Returns: a smart pointer on the loaded double image.

Definition at line 1203 of file Shortcuts.h.

      {
        DoubleImage image = GenericReader<DoubleImage>::import( input );
        return CountedPtr<DoubleImage>( new DoubleImage( image ) );
      }

References image(), and DGtal::GenericReader< TContainer, Tdim, TValue >::import().

◆ makeDualPolygonalSurface() [1/3]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< PolygonalSurface > DGtal::Shortcuts< TKSpace >::makeDualPolygonalSurface ( CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the dual polygonal surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any digital surface (e.g. DigitalSurface or LightDigitalSurface)

Returns: a smart pointer on the built polygonal surface.

Definition at line 2549 of file Shortcuts.h.

        {
          Surfel2Index s2i;
          return makeDualPolygonalSurface( s2i, aSurface );
        }

References DGtal::Shortcuts< TKSpace >::makeDualPolygonalSurface().

◆ makeDualPolygonalSurface() [2/3]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< PolygonalSurface > DGtal::Shortcuts< TKSpace >::makeDualPolygonalSurface ( CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the dual polygonal surface associated to the given indexed digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any indexed digital surface (e.g. IdxDigitalSurface)

Returns: a smart pointer on the built polygonal surface.

Definition at line 2563 of file Shortcuts.h.

        {
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          auto pPolySurf = CountedPtr<PolygonalSurface>
            ( new PolygonalSurface( aSurface->heds(),
                                    aSurface->positions().storage() ) );
          return pPolySurf;
        }

References DGtal::KhalimskySpaceND< dim, TInteger >::dimension.

◆ makeDualPolygonalSurface() [3/3]

template<typename TKSpace >

template<typename TContainer >

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

inlinestatic

Builds the dual polygonal surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[out]	s2i	the map Surfel -> Vertex index in the polygonal surface.
[in]	aSurface	any digital surface (e.g. DigitalSurface or LightDigitalSurface)

Returns: a smart pointer on the built polygonal surface.

Definition at line 2529 of file Shortcuts.h.

        {
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          auto embedder = getCellEmbedder( aSurface );
          auto pPolySurf = CountedPtr<PolygonalSurface>
            ( new PolygonalSurface ); // acquired
          MeshHelpers::digitalSurface2DualPolygonalSurface
            ( *aSurface, embedder, *pPolySurf, s2i );
          return pPolySurf;
        }

References DGtal::MeshHelpers::digitalSurface2DualPolygonalSurface(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, and DGtal::Shortcuts< TKSpace >::getCellEmbedder().

Referenced by DGtal::Shortcuts< TKSpace >::makeDualPolygonalSurface().

◆ makeFloatImage() [1/3]

template<typename TKSpace >

static CountedPtr< FloatImage > DGtal::Shortcuts< TKSpace >::makeFloatImage	(	CountedPtr< ImplicitShape3D >	shape,
		Parameters	params = `parametersDigitizedImplicitShape3D()`
	)

inlinestatic

Makes a float image from the given implicit shape according to parameters. Use getKSpace to build the associated digital space.

Parameters

[in]	shape	a smart pointer on the implicit shape.
[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.

Returns: a smart pointer on the created image.

Definition at line 1158 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>();
        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->attach( shape );
        dshape->init( p1, p2, h );
        Domain domain = dshape->getDomain();
        auto   fimage = makeFloatImage( domain );
        auto       it = fimage->begin();
        for ( auto p : domain )
          {
            float val = (float) (*shape)( p );
            *it++      = val;
          }
        return fimage;
      }

References domain, and DGtal::Shortcuts< TKSpace >::makeFloatImage().

◆ makeFloatImage() [2/3]

template<typename TKSpace >

static CountedPtr< FloatImage > DGtal::Shortcuts< TKSpace >::makeFloatImage ( Domain aDomain )

inlinestatic

Makes an empty float image within a given domain (values are unsigned char).

Parameters

[in] aDomain any domain.

Returns: a smart pointer on a float image that fits the given domain.

Definition at line 1125 of file Shortcuts.h.

      {
        return CountedPtr<FloatImage>( new FloatImage( aDomain ) );
      }

Referenced by DGtal::Shortcuts< TKSpace >::makeFloatImage().

◆ makeFloatImage() [3/3]

template<typename TKSpace >

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

inlinestatic

Loads an arbitrary image file (e.g. vol file in 3D) and returns the corresponding float image.

Parameters

[in] input the input filename.

Returns: a smart pointer on the loaded float image.

Definition at line 1137 of file Shortcuts.h.

      {
        FloatImage image = GenericReader<FloatImage>::import( input );
        return CountedPtr<FloatImage>( new FloatImage( image ) );
      }

References image(), and DGtal::GenericReader< TContainer, Tdim, TValue >::import().

◆ makeGrayScaleImage() [1/8]

template<typename TKSpace >

template<typename T , template< class... > class C1, template< class... > class C2, template< class... > class C3>

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage	(	const C1< C2< C3< T > > > &	values,
		std::optional< Domain >	override_domain = `std::nullopt`
	)

inlinestatic

Create an arbitrary image from a vector

Note: This overloads expect consistent size of subarrays. This is not checked.

Parameters

[in]	values	A vector (of vector of vector) where non-zero values indicates a voxel
[in]	override_domain	Overrides infered domain if needed

Returns: a smart pointer on a gray scale image

Definition at line 1028 of file Shortcuts.h.

        {
          Domain d;
          if (override_domain.has_value()) 
          {
            d = override_domain.value();
          }
          else if (values.size() != 0) 
          {
            if (values[0].size() != 0)
            {
              if (values[0][0].size() != 0)
              {
                d = Domain(Point(0, 0, 0), Point(values.size(), values[0].size(), values[0][0].size()));
              }
            }
          }
 
          CountedPtr<GrayScaleImage> image(new GrayScaleImage(d));
          Point begin = d.lowerBound();
          for (size_t i = 0; i < values.size(); ++i)
          {
            for (size_t j = 0; j < values[i].size(); ++j)
            {
              for (size_t k = 0; k < values[i][j].size(); ++k)
              {
                Point p = begin + Point(i, j, k);
                image->setValue(p, static_cast<GrayScale>(values[i][j][k]));
              }
            }
          }
 
          return image;
        }

References image(), and DGtal::HyperRectDomain< TSpace >::lowerBound().

◆ makeGrayScaleImage() [2/8]

template<typename TKSpace >

template<typename T , typename U , std::enable_if_t<!is_double_nested_container< T >::value, int > = 0>

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage	(	const std::vector< T > &	positions,
		const std::vector< U > &	values,
		std::optional< Domain >	override_domain = `std::nullopt`
	)

inlinestatic

Create an arbitrary image from a vector of positions

Note: This overloads expect consistent size of subarrays. This is not checked.

Parameters

[in]	positions	A vector of positions to indicates locations of voxels
[in]	values	A vector of values for each voxel
[in]	override_domain	Overrides infered domain if needed

Returns: a smart pointer on a gray scale image

Definition at line 1076 of file Shortcuts.h.

      {
        Domain d;
        if (override_domain.has_value())
        {
          d = override_domain.value();
        }
        else if (positions.size() != 0)
        {
            Point lb(positions[0][0], positions[0][1], positions[0][2]);
            Point ub(positions[0][0], positions[0][1], positions[0][2]);
 
            for (size_t i = 0; i < positions.size(); ++i) 
            {
              lb[0] = std::min(lb[0], static_cast<typename Point::Component>(positions[i][0]));
              lb[1] = std::min(lb[1], static_cast<typename Point::Component>(positions[i][1]));
              lb[2] = std::min(lb[2], static_cast<typename Point::Component>(positions[i][2]));
 
              ub[0] = std::max(ub[0], static_cast<typename Point::Component>(positions[i][0]));
              ub[1] = std::max(ub[1], static_cast<typename Point::Component>(positions[i][1]));
              ub[2] = std::max(ub[2], static_cast<typename Point::Component>(positions[i][2]));
            }
 
            d = Domain(lb, ub);
        }
 
        CountedPtr<GrayScaleImage> image(new GrayScaleImage(d));
        for (size_t i = 0; i < positions.size(); ++i) 
        {
          // Builds a points for generality, T may not be a PointVector instance
          Point p({positions[i][0], positions[i][1], positions[i][2]});
          image->setValue(p, static_cast<GrayScale>(values[i]));
        }
        return image;
      }

References image().

◆ makeGrayScaleImage() [3/8]

template<typename TKSpace >

template<typename T , typename __U = std::enable_if_t<std::is_arithmetic_v<T>>>

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage	(	const std::vector< T > &	values,
		const Domain &	d
	)

inlinestatic

Create an arbitrary image from a vector

Note: This overload expects a linearized array. Positions are infered from the domain. The order must be the same

Parameters

[in]	values	A vector where non-zero values indicates voxels
[in]	d	The domain of the image

Returns: a smart pointer on a gray scale image

Definition at line 999 of file Shortcuts.h.

        {
            CountedPtr<GrayScaleImage> image(new GrayScaleImage(d));
            
            size_t i = 0;
            for (auto it = d.begin(); it != d.end(); ++i, ++it)
            {
              image->setValue(*it, static_cast<GrayScale>(values[i]));
            }
 
            return image;
        }

References DGtal::HyperRectDomain< TSpace >::begin(), DGtal::HyperRectDomain< TSpace >::end(), and image().

◆ makeGrayScaleImage() [4/8]

template<typename TKSpace >

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage	(	CountedPtr< BinaryImage >	binary_image,
		std::function< GrayScale(bool) > const &	bool2grayscale = `[] ( bool v ) { return v ? (unsigned char) 255 : (unsigned char) 0; }`
	)

inlinestatic

Makes a gray-scale image from a binary image using the given transformation

Parameters

[in]	binary_image	the input binary image.
[in]	bool2grayscale	the binarizing function.

Returns: a smart pointer on the resulting gray-scale image.

Definition at line 895 of file Shortcuts.h.

                          { return v ? (unsigned char) 255 : (unsigned char) 0; }
          // JOL: (GrayScale) was not working with visual C++: error C2065
          )
      {
        const Domain domain = binary_image->domain(); 
        CountedPtr<GrayScaleImage> gray_scale_image( new GrayScaleImage( domain ) );
        std::transform( binary_image->begin(), binary_image->end(),
                        gray_scale_image->begin(),
                        bool2grayscale );
        return gray_scale_image;
      }

◆ makeGrayScaleImage() [5/8]

template<typename TKSpace >

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage	(	CountedPtr< DoubleImage >	fimage,
		Parameters	params = `parametersGrayScaleImage()`
	)

inlinestatic

Makes a gray-scale image from the given double image. (i.e. quantify the given image)..

Parameters

[in]	fimage	a smart pointer on the double image.
[in]	params	the parameters: qShift [128.0]: the shift used when quantifying the implicit shape (q(x)=qSlopex+qShift, e.g. to build a grayscale image). qSlope [ 1.0]: the slope used when quantifying the implicit shape (q(x)=qSlopex+qShift, e.g. to build a grayscale image).

Returns: a smart pointer on the created image

Definition at line 968 of file Shortcuts.h.

      {
        double qShift = params[ "qShift"   ].as<double>();
        double qSlope = params[ "qSlope"   ].as<double>();
        std::function< unsigned char( double ) > f
          = [qShift,qSlope] (double v)
          { return (unsigned char) std::min( 255.0, std::max( 0.0, qSlope * v + qShift ) ); };
        Domain domain = fimage->domain();
        auto   gimage = makeGrayScaleImage( domain );
        auto       it = gimage->begin();
        for ( auto p : domain )
          {
            double val = (*fimage)( p );
            *it++      = f( val );
          }
        return gimage;
      }

References domain, and DGtal::Shortcuts< TKSpace >::makeGrayScaleImage().

◆ makeGrayScaleImage() [6/8]

template<typename TKSpace >

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage	(	CountedPtr< FloatImage >	fimage,
		Parameters	params = `parametersGrayScaleImage()`
	)

inlinestatic

Makes a gray-scale image from the given float image (i.e. quantify the given image)..

Parameters

[in]	fimage	a smart pointer on the float image.
[in]	params	the parameters: qShift [128.0]: the shift used when quantifying the implicit shape (q(x)=qSlopex+qShift, e.g. to build a grayscale image). qSlope [ 1.0]: the slope used when quantifying the implicit shape (q(x)=qSlopex+qShift, e.g. to build a grayscale image).

Returns: a smart pointer on the created image

Definition at line 936 of file Shortcuts.h.

      {
        float qShift = params[ "qShift"   ].as<float>();
        float qSlope = params[ "qSlope"   ].as<float>();
        std::function< unsigned char( float ) > f
          = [qShift,qSlope] (float v)
          { return (unsigned char) std::min( 255.0f, std::max( 0.0f, qSlope * v + qShift ) ); };
        Domain domain = fimage->domain();
        auto   gimage = makeGrayScaleImage( domain );
        auto       it = gimage->begin();
        for ( auto p : domain )
          {
            float val = (*fimage)( p );
            *it++      = f( val );
          }
        return gimage;
      }

References domain, and DGtal::Shortcuts< TKSpace >::makeGrayScaleImage().

◆ makeGrayScaleImage() [7/8]

template<typename TKSpace >

static CountedPtr< GrayScaleImage > DGtal::Shortcuts< TKSpace >::makeGrayScaleImage ( Domain aDomain )

inlinestatic

Makes an empty gray scale image within a given domain (values are unsigned char).

Parameters

[in] aDomain any domain.

Returns: a smart pointer on a gray scale image that fits the given domain.

Definition at line 869 of file Shortcuts.h.

      {
        return CountedPtr<GrayScaleImage>( new GrayScaleImage( aDomain ) );
      }

Referenced by DGtal::Shortcuts< TKSpace >::makeGrayScaleImage(), DGtal::Shortcuts< TKSpace >::makeGrayScaleImage(), and DGtal::Shortcuts< TKSpace >::saveBinaryImage().

◆ makeGrayScaleImage() [8/8]

template<typename TKSpace >

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

inlinestatic

Loads an arbitrary binary image file (e.g. vol file in 3D) and returns the corresponding gray-scale image.

Parameters

[in] input the input filename.

Returns: a smart pointer on the loaded gray-scale image.

Definition at line 881 of file Shortcuts.h.

      {
        GrayScaleImage image = GenericReader<GrayScaleImage>::import( input );
        return CountedPtr<GrayScaleImage>( new GrayScaleImage( image ) );
      }

References image(), and DGtal::GenericReader< TContainer, Tdim, TValue >::import().

◆ makeIdxDigitalSurface() [1/4]

template<typename TKSpace >

static CountedPtr< IdxDigitalSurface > DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface	(	const std::vector< CountedPtr< LightDigitalSurface > > &	surfaces,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Builds an indexed digital surface from a vector of light digital surfaces. Note that the surfel adjacency may be changed and a connected light digital surface could be disconnected in the process.

Note: the surfaces must live in the same digital spaces.

Parameters

[in]	surfaces	a vector of smart pointers on light digital surfaces.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int)

Returns: a smart pointer on the required indexed digital surface.

Definition at line 1624 of file Shortcuts.h.

      {
        if ( surfaces.empty() ) return CountedPtr<IdxDigitalSurface>( 0 );
        const KSpace& K = surfaces[ 0 ]->container().space();
        SurfelSet     surfels;
        for ( std::size_t i = 0; i < surfaces.size(); ++i )
          {
            const KSpace& Ki = surfaces[ i ]->container().space();
            if ( ( Ki.lowerBound() != K.lowerBound() )
                 || ( Ki.upperBound() != K.upperBound() ) )
              trace.warning() << "[Shortcuts::makeIdxDigitalSurface]"
                              << " Incompatible digital spaces for surface " << i << std::endl;
            surfels.insert( surfaces[ i ]->begin(), surfaces[ i ]->end() );
          }
        return makeIdxDigitalSurface( surfels, K, params );
      }    

References K, DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), DGtal::trace, and DGtal::Trace::warning().

◆ makeIdxDigitalSurface() [2/4]

template<typename TKSpace >

template<typename TSurfelRange >

static CountedPtr< IdxDigitalSurface > DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface	(	const TSurfelRange &	surfels,
		ConstAlias< KSpace >	K,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Builds an indexed digital surface from a space K and an arbitrary range of surfels.

Parameters

[in]	surfels	an arbitrary range of surfels.
[in]	K	the Khalimsky space whose domain encompasses the given surfels.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int)

Returns: a smart pointer on the indexed digital surface built over the surfels.

Definition at line 1568 of file Shortcuts.h.

        {
          bool surfel_adjacency      = params[ "surfelAdjacency" ].as<int>();
          SurfelAdjacency< KSpace::dimension > surfAdj( surfel_adjacency );
          // Build indexed digital surface.
          CountedPtr<ExplicitSurfaceContainer> ptrSurfContainer
            ( new ExplicitSurfaceContainer( K, surfAdj, surfels ) );
          CountedPtr<IdxDigitalSurface> ptrSurface
            ( new IdxDigitalSurface() );
          bool ok = ptrSurface->build( ptrSurfContainer );
          if ( !ok )
            trace.warning() << "[Shortcuts::makeIdxDigitalSurface]"
                            << " Error building indexed digital surface." << std::endl;
          return ptrSurface;
        }

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

◆ makeIdxDigitalSurface() [3/4]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Builds an indexed digital surface from a light digital surface. Note that the surfel adjacency may be changed and a connected light digital surface could be disconnected in the process.

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).
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int)

Returns: a smart pointer on the required indexed digital surface.

Definition at line 1601 of file Shortcuts.h.

        {
          const KSpace& K = refKSpace( surface );
          SurfelSet     surfels;
          surfels.insert( surface->begin(), surface->end() );
          return makeIdxDigitalSurface( surfels, K, params );
        }    

References K, DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), DGtal::Shortcuts< TKSpace >::refKSpace(), and surface.

◆ makeIdxDigitalSurface() [4/4]

template<typename TKSpace >

static CountedPtr< IdxDigitalSurface > DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface	(	CountedPtr< BinaryImage >	bimage,
		const KSpace &	K,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Builds an indexed digital surface from a space K and a binary image bimage. Note that it may connected or not depending on parameters.

Parameters

[in]	bimage	a binary image representing the characteristic function of a digital shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int) nbTriesToFindABel [100000]: number of tries in method Surfaces::findABel surfaceComponents ["AnyBig"]: "AnyBig"\|"All", "AnyBig": any big-enough component (> twice space width), "All": all components

Returns: a smart pointer on the required indexed digital surface.

Definition at line 1535 of file Shortcuts.h.

      {
        std::string component      = params[ "surfaceComponents" ].as<std::string>();
        SurfelSet surfels;
        if ( component == "AnyBig" )
          {
            auto light_surface = makeLightDigitalSurface( bimage, K, params );
            surfels.insert( light_surface->begin(), light_surface->end() );
          }
        else if ( component == "All" )
          {
            Surfaces<KSpace>::sMakeBoundary( surfels, K, *bimage,
                                             K.lowerBound(), K.upperBound() );
          }
        return makeIdxDigitalSurface( surfels, K, params );
      }    

References K, DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), DGtal::Shortcuts< TKSpace >::makeLightDigitalSurface(), and DGtal::Surfaces< TKSpace >::sMakeBoundary().

Referenced by DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), and DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface().

◆ makeImplicitShape3D()

template<typename TKSpace >

static CountedPtr< ImplicitShape3D > DGtal::Shortcuts< TKSpace >::makeImplicitShape3D ( const Parameters & params = parametersImplicitShape3D() )

inlinestatic

Builds a 3D implicit shape from parameters

Parameters

[in]

params

the parameters:

polynomial["sphere1"]: the implicit polynomial whose zero-level set defines the shape of interest.

Returns: a smart pointer on the created implicit shape.

Definition at line 279 of file Shortcuts.h.

      {
        typedef MPolynomialReader< Space::dimension, Scalar> Polynomial3Reader;
        std::string poly_str = params[ "polynomial" ].as<std::string>();
        // Recognizes specific strings as polynomials.
        auto PL = getPolynomialList();
        if ( PL[ poly_str ] != "" ) poly_str = PL[ poly_str ];
        ScalarPolynomial poly;
        Polynomial3Reader reader;
        std::string::const_iterator iter
          = reader.read( poly, poly_str.begin(), poly_str.end() );
        if ( iter != poly_str.end() )
          {
            trace.error() << "[Shortcuts::makeImplicitShape3D]"
                          << " ERROR reading polynomial: I read only <"
                          << poly_str.substr( 0, iter - poly_str.begin() )
                          << ">, and I built P=" << poly << std::endl;
          }
        return CountedPtr<ImplicitShape3D>( new ImplicitShape3D( poly ) );
      }

References DGtal::Trace::error(), DGtal::Shortcuts< TKSpace >::getPolynomialList(), and DGtal::trace.

Referenced by main().

◆ makeLightDigitalSurface()

template<typename TKSpace >

static CountedPtr< LightDigitalSurface > DGtal::Shortcuts< TKSpace >::makeLightDigitalSurface	(	CountedPtr< BinaryImage >	bimage,
		const KSpace &	K,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Builds a light digital surface from a space K and a binary image bimage.

Parameters

[in]	bimage	a binary image representing the characteristic function of a digital shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int) nbTriesToFindABel [100000]: number of tries in method Surfaces::findABel

Returns: a smart pointer on a (light) digital surface that represents the boundary of any big component of the digital shape.

Definition at line 1322 of file Shortcuts.h.

      {
        bool surfel_adjacency      = params[ "surfelAdjacency" ].as<int>();
        int nb_tries_to_find_a_bel = params[ "nbTriesToFindABel" ].as<int>();
        SurfelAdjacency< KSpace::dimension > surfAdj( surfel_adjacency );
 
        // We have to search for a surfel that belongs to a big connected component.
        CountedPtr<LightDigitalSurface> ptrSurface;
        Surfel       bel;
        Scalar       minsize    = bimage->extent().norm();
        unsigned int nb_surfels = 0;
        unsigned int tries      = 0;
        do
          {
            try { // Search initial bel
              bel = Surfaces<KSpace>::findABel( K, *bimage, nb_tries_to_find_a_bel );
            } catch (DGtal::InputException& e) {
              trace.error() << "[Shortcuts::makeLightDigitalSurface]"
                            << " ERROR Unable to find bel. " << e << std::endl;
              return ptrSurface;
            }
            // this pointer will be acquired by the surface.
            LightSurfaceContainer* surfContainer
              = new LightSurfaceContainer( K, *bimage, surfAdj, bel );
            ptrSurface = CountedPtr<LightDigitalSurface>
              ( new LightDigitalSurface( surfContainer ) ); // acquired
            nb_surfels = ptrSurface->size();
          }
        while ( ( nb_surfels < 2 * minsize ) && ( tries++ < 150 ) );
        if( tries >= 150 )
          trace.warning() << "[Shortcuts::makeLightDigitalSurface]"
                          << "ERROR cannot find a proper bel in a big enough component."
                          << std::endl;
        return ptrSurface;
      }

References DGtal::Trace::error(), DGtal::Surfaces< TKSpace >::findABel(), K, DGtal::trace, and DGtal::Trace::warning().

Referenced by DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), and DGtal::Shortcuts< TKSpace >::makeLightDigitalSurfaces().

◆ makeLightDigitalSurfaces() [1/2]

template<typename TKSpace >

static std::vector< CountedPtr< LightDigitalSurface > > DGtal::Shortcuts< TKSpace >::makeLightDigitalSurfaces	(	CountedPtr< BinaryImage >	bimage,
		const KSpace &	K,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Returns a vector containing either all the light digital surfaces in the binary image bimage, or any one of its big components according to parameters.

Parameters

[in]	bimage	a binary image representing the characteristic function of a digital shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int) nbTriesToFindABel [ 100000]: number of tries in method Surfaces::findABel surfaceComponents ["AnyBig"]: "AnyBig"\|"All", "AnyBig": any big-enough component (> twice space width), "All": all components

Returns: a vector of smart pointers to the connected (light) digital surfaces present in the binary image.

Definition at line 1379 of file Shortcuts.h.

      {
        SurfelRange surfel_reps;
        return makeLightDigitalSurfaces( surfel_reps, bimage, K, params );
      }

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

Referenced by DGtal::Shortcuts< TKSpace >::makeLightDigitalSurfaces().

◆ makeLightDigitalSurfaces() [2/2]

template<typename TKSpace >

static std::vector< CountedPtr< LightDigitalSurface > > DGtal::Shortcuts< TKSpace >::makeLightDigitalSurfaces	(	SurfelRange &	surfel_reps,
		CountedPtr< BinaryImage >	bimage,
		const KSpace &	K,
		const Parameters &	params = `parametersDigitalSurface()`
	)

inlinestatic

Returns a vector containing either all the light digital surfaces in the binary image bimage, or any one of its big components according to parameters.

Parameters

[out]	surfel_reps	a vector of surfels, one surfel per digital surface component.
[in]	bimage	a binary image representing the characteristic function of a digital shape.
[in]	K	the Khalimsky space whose domain encompasses the digital shape.
[in]	params	the parameters: surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int) nbTriesToFindABel [ 100000]: number of tries in method Surfaces::findABel surfaceComponents ["AnyBig"]: "AnyBig"\|"All", "AnyBig": any big-enough component (> twice space width), "All": all components

Returns: a vector of smart pointers to the connected (light) digital surfaces present in the binary image.

Definition at line 1409 of file Shortcuts.h.

      {
        std::vector< CountedPtr<LightDigitalSurface> > result;
        std::string component      = params[ "surfaceComponents" ].as<std::string>();
        if ( component == "AnyBig" )
          {
            result.push_back( makeLightDigitalSurface( bimage, K, params ) );
            surfel_reps.push_back( *( result[ 0 ]->begin() ) );
            return result;
          }     
        bool surfel_adjacency      = params[ "surfelAdjacency" ].as<int>();
        SurfelAdjacency< KSpace::dimension > surfAdj( surfel_adjacency );
        // Extracts all boundary surfels
        SurfelSet all_surfels;
        Surfaces<KSpace>::sMakeBoundary( all_surfels, K, *bimage,
                                         K.lowerBound(), K.upperBound() );
        // Builds all connected components of surfels.
        SurfelSet marked_surfels;
        CountedPtr<LightDigitalSurface> ptrSurface;
        for ( auto bel : all_surfels )
          {
            if ( marked_surfels.count( bel ) != 0 ) continue;
            surfel_reps.push_back( bel );
            LightSurfaceContainer* surfContainer
              = new LightSurfaceContainer( K, *bimage, surfAdj, bel );
            ptrSurface = CountedPtr<LightDigitalSurface>
              ( new LightDigitalSurface( surfContainer ) ); // acquired
            // mark all surfels of the surface component.
            marked_surfels.insert( ptrSurface->begin(), ptrSurface->end() );
            // add surface component to result.
            result.push_back( ptrSurface );
          }
        return result;
      }

References K, DGtal::Shortcuts< TKSpace >::makeLightDigitalSurface(), and DGtal::Surfaces< TKSpace >::sMakeBoundary().

◆ makeMesh() [1/2]

template<typename TKSpace >

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

inlinestatic

Builds a mesh (class Mesh) from a polygonal surface (class PolygonalSurface). Note that the mesh looses the topology of the polygonal surface, since it is essentially a soup of triangles.

Parameters

[in]	polySurf	the input polygonal surface mesh.
[in]	aColor	the default color of the mesh.

Returns: a smart pointer on the output mesh.

Definition at line 2349 of file Shortcuts.h.

      {
        auto pMesh = CountedPtr<Mesh>( new Mesh( aColor ) ); // acquired
        MeshHelpers::polygonalSurface2Mesh( *polySurf, *pMesh );
        return pMesh;
      }

References DGtal::MeshHelpers::polygonalSurface2Mesh().

◆ makeMesh() [2/2]

template<typename TKSpace >

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

inlinestatic

Builds a mesh (class Mesh) from a triangulated surface (class TriangulatedSurface). Note that the mesh looses the topology of the triangulated surface, since it is essentially a soup of triangles.

Parameters

[in]	triSurf	the input triangulated surface mesh.
[in]	aColor	the default color of the mesh.

Returns: a smart pointer on the output mesh.

Definition at line 2332 of file Shortcuts.h.

      {
        auto pMesh = CountedPtr<Mesh>( new Mesh( aColor ) ); // acquired
        MeshHelpers::triangulatedSurface2Mesh( *triSurf, *pMesh );
        return pMesh;
      }

References DGtal::MeshHelpers::triangulatedSurface2Mesh().

◆ makePolygonalSurface() [1/2]

template<typename TKSpace >

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

inlinestatic

Builds the polygonal marching-cubes surface that approximate an iso-surface of value "thresholdMin+0.5" in the given 3D gray-scale image.

Parameters

[in]	gray_scale_image	any gray-scale image.
[in]	params	the parameters: surfelAdjacency[0]: specifies the surfel adjacency (1:ext, 0:int) thresholdMin [0]: specifies the threshold min (excluded) to define binary shape 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.

Returns: a smart pointer on the built polygonal surface or 0 if the mesh was invalid.

Definition at line 2449 of file Shortcuts.h.

      {
        auto K       = getKSpace( gray_scale_image );
        auto bimage  = makeBinaryImage( gray_scale_image, params );
        auto digSurf = makeDigitalSurface( bimage, K, params );
        RealVector gh = { params[ "gridsizex" ].as<double>(),
                          params[ "gridsizey" ].as<double>(),
                          params[ "gridsizez" ].as<double>() };
        double threshold = params[ "thresholdMin" ].as<double>() + 0.5;
        typedef RegularPointEmbedder<Space>         PointEmbedder;
        typedef ImageLinearCellEmbedder
          < KSpace, GrayScaleImage, PointEmbedder > ImageCellEmbedder;
        PointEmbedder pembedder;
        pembedder.init( gh );
        ImageCellEmbedder cembedder;
        cembedder.init( K, *gray_scale_image, pembedder, threshold );
        auto pPolySurf = CountedPtr<PolygonalSurface>
          ( new PolygonalSurface ); // acquired
        Surfel2Index s2i;
        MeshHelpers::digitalSurface2DualPolygonalSurface
          ( *digSurf, cembedder, *pPolySurf, s2i );
        return pPolySurf;
      }

References DGtal::MeshHelpers::digitalSurface2DualPolygonalSurface(), DGtal::Shortcuts< TKSpace >::getKSpace(), DGtal::ImageLinearCellEmbedder< TKSpace, TImage, TEmbedder >::init(), K, DGtal::Shortcuts< TKSpace >::makeBinaryImage(), and DGtal::Shortcuts< TKSpace >::makeDigitalSurface().

◆ makePolygonalSurface() [2/2]

template<typename TKSpace >

static CountedPtr< PolygonalSurface > DGtal::Shortcuts< TKSpace >::makePolygonalSurface ( CountedPtr< Mesh > aMesh )

inlinestatic

Builds a polygon mesh (class PolygonalSurface) from a mesh (class Mesh). The output polygonal surface rebuilds a topology between faces.

Parameters

[in] aMesh any mesh (which should be a valid combinatorial surface).

Returns: a smart pointer on the built polygonal surface or 0 if the mesh was invalid.

Definition at line 2427 of file Shortcuts.h.

      {
        auto pPolySurf = CountedPtr<PolygonalSurface>
          ( new PolygonalSurface ); // acquired
        bool ok = MeshHelpers::mesh2PolygonalSurface( *aMesh, *pPolySurf );
        return ok ? pPolySurf : CountedPtr< PolygonalSurface >( nullptr );
      }

References DGtal::MeshHelpers::mesh2PolygonalSurface().

◆ makePrimalPolygonalSurface() [1/3]

template<typename TKSpace >

template<typename TContainer >

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

inlinestatic

Builds the primal polygonal surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[out]	c2i	the map Cell -> Vertex index in the polygonal surface.
[in]	aSurface	any digital surface (e.g. DigitalSurface or LightDigitalSurface)

Returns: a smart pointer on the built polygonal surface or 0 if it fails because aSurface is not a combinatorial 2-manifold.

Definition at line 2582 of file Shortcuts.h.

        {
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          auto embedder = getCellEmbedder( aSurface );
          auto pPolySurf = CountedPtr<PolygonalSurface>
            ( new PolygonalSurface ); // acquired
          bool ok = MeshHelpers::digitalSurface2PrimalPolygonalSurface
            ( *aSurface, embedder, *pPolySurf, c2i );
          return ok ? pPolySurf : CountedPtr< PolygonalSurface >( nullptr );
        }

References DGtal::MeshHelpers::digitalSurface2PrimalPolygonalSurface(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, and DGtal::Shortcuts< TKSpace >::getCellEmbedder().

Referenced by DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface(), and DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface().

◆ makePrimalPolygonalSurface() [2/3]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< PolygonalSurface > DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface ( CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the primal polygonal surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any digital surface (e.g. DigitalSurface or LightDigitalSurface)

Returns: a smart pointer on the built polygonal surface or 0 if it fails because aSurface is not a combinatorial 2-manifold.

Definition at line 2602 of file Shortcuts.h.

        {
          Cell2Index c2i;
          return makePrimalPolygonalSurface( c2i, aSurface );
        }

References DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface().

◆ makePrimalPolygonalSurface() [3/3]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< PolygonalSurface > DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface ( CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the primal polygonal surface associated to the given indexed digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any indexed digital surface (e.g. IdxDigitalSurface)

Returns: a smart pointer on the built polygonal surface or 0 if it fails because aSurface is not a combinatorial 2-manifold.

Definition at line 2616 of file Shortcuts.h.

        {
          auto dsurf = makeDigitalSurface( aSurface );
          Cell2Index c2i;
          return makePrimalPolygonalSurface( c2i, dsurf );
        }

References DGtal::Shortcuts< TKSpace >::makeDigitalSurface(), and DGtal::Shortcuts< TKSpace >::makePrimalPolygonalSurface().

◆ makePrimalSurfaceMesh() [1/3]

template<typename TKSpace >

template<typename TContainer >

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

inlinestatic

Builds the primal polygonal surface mesh associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[out]	c2i	the map Cell -> Vertex index in the polygonal surface.
[in]	aSurface	any digital surface (e.g. DigitalSurface or LightDigitalSurface)

Returns: a smart pointer on the built polygonal surface mesh

Definition at line 2633 of file Shortcuts.h.

      {
        BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
        auto embedder = getCellEmbedder( aSurface );
        auto pPolySurf = CountedPtr<SurfaceMesh>( new SurfaceMesh ); // acquired
        bool ok = MeshHelpers::digitalSurface2PrimalSurfaceMesh( *aSurface, embedder, *pPolySurf, c2i );
        return ok ? pPolySurf : CountedPtr< SurfaceMesh >( nullptr );
      }

References DGtal::MeshHelpers::digitalSurface2PrimalSurfaceMesh(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, and DGtal::Shortcuts< TKSpace >::getCellEmbedder().

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getCNCGaussianCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getCNCMeanCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getCNCPrincipalCurvaturesAndDirections(), main(), DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh(), and DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh().

◆ makePrimalSurfaceMesh() [2/3]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< SurfaceMesh > DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh ( CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the primal polygonal surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any digital surface (e.g. DigitalSurface or LightDigitalSurface)

Returns: a smart pointer on the built polygonal surface or 0 if it fails because aSurface is not a combinatorial 2-manifold.

Definition at line 2651 of file Shortcuts.h.

      {
        Cell2Index c2i;
        return makePrimalSurfaceMesh( c2i, aSurface );
      }

References DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh().

◆ makePrimalSurfaceMesh() [3/3]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< SurfaceMesh > DGtal::Shortcuts< TKSpace >::makePrimalSurfaceMesh ( CountedPtr< ::DGtal::IndexedDigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the primal polygonal surface associated to the given indexed digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any indexed digital surface (e.g. IdxDigitalSurface)

Returns: a smart pointer on the built polygonal surface or 0 if it fails because aSurface is not a combinatorial 2-manifold.

Definition at line 2665 of file Shortcuts.h.

      {
        auto dsurf = makeDigitalSurface( aSurface );
        Cell2Index c2i;
        return makePrimalSurfaceMesh( c2i, dsurf );
      }

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

◆ makeSurfaceMesh()

template<typename TKSpace >

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

inlinestatic

Loads a surface mesh

Parameters

[in] path Path to file

Returns: A smart pointer to the loaded polygonal surface, that holds nullptr if loading failed.

Definition at line 2677 of file Shortcuts.h.

      {
        std::ifstream file(path);
        if (file.is_open()) 
        {
          auto surf = CountedPtr<SurfaceMesh>( new SurfaceMesh );
          bool ok = SurfaceMeshReader<RealPoint, RealVector>::readOBJ(file, *surf);
 
          return ok ? surf : CountedPtr<SurfaceMesh>( nullptr );
        }
 
        return CountedPtr<SurfaceMesh>( nullptr );
      }

References DGtal::SurfaceMeshReader< TRealPoint, TRealVector >::readOBJ().

◆ makeTriangulatedSurface() [1/5]

template<typename TKSpace >

template<typename TContainer >

static CountedPtr< TriangulatedSurface > DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface ( CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface )

inlinestatic

Builds the dual triangulated surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[in] aSurface any digital surface (e.g. LightDigitalSurface or DigitalSurface)

Returns: a smart pointer on the built triangulated surface.

Definition at line 2383 of file Shortcuts.h.

        {
          Surfel2Index s2i;
          return makeTriangulatedSurface( s2i, aSurface );
        }

References DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface().

◆ makeTriangulatedSurface() [2/5]

template<typename TKSpace >

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

inlinestatic

Builds the marching-cubes surface that approximate an iso-surface of value "thresholdMin+0.5" in the given 3D gray-scale image. Non triangular faces are triangulated by putting a centroid vertex.

Parameters

[in]	gray_scale_image	any gray-scale image.
[in]	params	the parameters: surfelAdjacency[0]: specifies the surfel adjacency (1:ext, 0:int) thresholdMin [0]: specifies the threshold min (excluded) to define binary shape 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.

Returns: a smart pointer on the built triangulated surface or 0 if the mesh was invalid.

Definition at line 2492 of file Shortcuts.h.

      {
        auto K       = getKSpace( gray_scale_image );
        auto bimage  = makeBinaryImage( gray_scale_image, params );
        auto digSurf = makeDigitalSurface( bimage, K, params );
        RealVector gh = { params[ "gridsizex" ].as<double>(),
                          params[ "gridsizey" ].as<double>(),
                          params[ "gridsizez" ].as<double>() };
        double threshold = params[ "thresholdMin" ].as<double>() + 0.5;
        typedef RegularPointEmbedder<Space>         PointEmbedder;
        typedef ImageLinearCellEmbedder
          < KSpace, GrayScaleImage, PointEmbedder > ImageCellEmbedder;
        PointEmbedder pembedder;
        pembedder.init( gh );
        ImageCellEmbedder cembedder;
        cembedder.init( K, *gray_scale_image, pembedder, threshold );
        auto pPolySurf = CountedPtr<TriangulatedSurface>
          ( new TriangulatedSurface ); // acquired
        Surfel2Index s2i;
        MeshHelpers::digitalSurface2DualTriangulatedSurface
          ( *digSurf, cembedder, *pPolySurf, s2i );
        return pPolySurf;
      }

References DGtal::MeshHelpers::digitalSurface2DualTriangulatedSurface(), DGtal::Shortcuts< TKSpace >::getKSpace(), DGtal::ImageLinearCellEmbedder< TKSpace, TImage, TEmbedder >::init(), K, DGtal::Shortcuts< TKSpace >::makeBinaryImage(), and DGtal::Shortcuts< TKSpace >::makeDigitalSurface().

◆ makeTriangulatedSurface() [3/5]

template<typename TKSpace >

static CountedPtr< TriangulatedSurface > DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface ( CountedPtr< Mesh > aMesh )

inlinestatic

Builds a triangulated surface (class TriangulatedSurface) from a mesh (class Mesh). Note that a triangulated surface contains only triangles, so polygonal faces (0,1,2,3,4,...) of the input mesh are (naively) triangulated (triangles (0,1,2), (0,2,3), (0,3,4), etc). Furthermore, the output triangulated surface rebuilds a topology between faces.

Parameters

[in] aMesh any mesh (which should be a valid combinatorial surface).

Returns: a smart pointer on the built triangulated surface or 0 if the mesh was invalid.

Definition at line 2315 of file Shortcuts.h.

      {
        auto pTriSurf = CountedPtr<TriangulatedSurface>
          ( new TriangulatedSurface ); // acquired
        bool ok = MeshHelpers::mesh2TriangulatedSurface( *aMesh, *pTriSurf );
        return ok ? pTriSurf : CountedPtr< TriangulatedSurface >( nullptr );
      }

References DGtal::MeshHelpers::mesh2TriangulatedSurface().

Referenced by DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface().

◆ makeTriangulatedSurface() [4/5]

template<typename TKSpace >

static CountedPtr< TriangulatedSurface > DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface	(	CountedPtr< PolygonalSurface >	polySurf,
		const Parameters &	params = `parametersMesh()`
	)

inlinestatic

Builds a triangulated surface from a polygonal surface.

Note: Be very careful with "Naive" subdivision, since it may create non-manifold edges on general polygonal surfaces. Indeed, take the closed surface made of faces (0, 1, 2, 3) and (3, 2, 1, 0). Depending on how faces are triangulated, it is still a valid combinatorial triangulated 2-manifold (e.g. (0,1,2,3) gives (0,1,2) and (2,0,3) and (3,2,1,0) gives (3,2,1) and (1,3,0)) or a non-valid one (e.g. (0,1,2,3) gives (0,1,2) and (2,0,3) and (3,2,1,0) gives (3,2,0) and (0,2,1): then edge {2,0} is shared by four faces).

Parameters

[in]	polySurf	any polygonal surface.
[in]	params	the parameters: faceSubdivision ["Centroid"]: "No"\|"Naive"\|"Centroid" specifies how faces are subdivided, "No" is considered as "Naive" since faces must be triangulated.

Returns: a smart pointer on the built triangulated surface.

Definition at line 2407 of file Shortcuts.h.

      {
        std::string faceSubdivision = params[ "faceSubdivision" ].as<std::string>();
        bool centroid = ( faceSubdivision == "Centroid" );
        auto pTriSurf = CountedPtr<TriangulatedSurface>
          ( new TriangulatedSurface ); // acquired
        MeshHelpers::polygonalSurface2TriangulatedSurface( *polySurf, *pTriSurf, centroid );
        return pTriSurf;
      }

References DGtal::MeshHelpers::polygonalSurface2TriangulatedSurface().

◆ makeTriangulatedSurface() [5/5]

template<typename TKSpace >

template<typename TContainer >

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

inlinestatic

Builds the dual triangulated surface associated to the given digital surface.

Template Parameters

TContainer the digital surface container

Parameters

[out]	s2i	the map Surfel -> Vertex index in the triangulated surface.
[in]	aSurface	any digital surface (e.g. LightDigitalSurface or DigitalSurface)

Returns: a smart pointer on the built triangulated surface.

Definition at line 2365 of file Shortcuts.h.

        {
          auto embedder = getCellEmbedder( aSurface );
          auto pTriSurf = CountedPtr<TriangulatedSurface>
            ( new TriangulatedSurface ); // acquired
          MeshHelpers::digitalSurface2DualTriangulatedSurface
            ( *aSurface, embedder, *pTriSurf, s2i );
          return pTriSurf;
        }

References DGtal::MeshHelpers::digitalSurface2DualTriangulatedSurface(), and DGtal::Shortcuts< TKSpace >::getCellEmbedder().

◆ operator=() [1/2]

template<typename TKSpace >

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

delete

Copy assignment operator.

Parameters

other the object to copy.

Returns: a reference on 'this'.

◆ operator=() [2/2]

template<typename TKSpace >

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

delete

Move assignment operator.

Parameters

other the object to move.

Returns: a reference on 'this'.

◆ outputCellMapAsCSV()

template<typename TKSpace >

template<typename TCellMap , typename TValueWriter >

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

inlinestatic

Definition at line 3485 of file Shortcuts.h.

      {
        CellWriter w;
        for ( auto&& v : anyMap )
          {
            w( output, K, v.first );
            writer( output, v.second );
            output << std::endl;
          }
        return output.good();
      }

References K.

◆ outputDualDigitalSurfaceAsObj() [1/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Outputs a digital surface, seen from the dual point of view (surfels=vertices), as an OBJ file (3D only). Note that faces are oriented consistently (normals toward outside).

Template Parameters

TDigitalSurfaceContainer either model of concepts::CDigitalSurfaceContainer.

Parameters

[out]	output	the output stream.
[in]	surface	a smart pointer on a digital surface (a DigitalSurface or a LightDigitalSurface).
[in]	params	the parameters: faceSubdivision ["Centroid"]: "No"\|"Naive"\|"Centroid" specifies how dual faces are subdivided when exported.

Returns: 'true' if the output stream is good.

Definition at line 3225 of file Shortcuts.h.

        {
          auto embedder = getCellEmbedder( surface );
          return outputDualDigitalSurfaceAsObj( output, surface, embedder, params );
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::outputDualDigitalSurfaceAsObj(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::outputDualDigitalSurfaceAsObj().

◆ outputDualDigitalSurfaceAsObj() [2/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer , typename TCellEmbedder = CanonicCellEmbedder< KSpace >>

static bool DGtal::Shortcuts< TKSpace >::outputDualDigitalSurfaceAsObj	(	std::ostream &	output,
		CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	surface,
		const TCellEmbedder &	embedder,
		const Parameters &	params = `parametersMesh()`
	)

inlinestatic

Outputs a digital surface, seen from the dual point of view (surfels=vertices), as an OBJ file (3D only). Note that faces are oriented consistently (normals toward outside). Each vertex is mapped to a 3D point using the given cell embedder.

Template Parameters

TDigitalSurfaceContainer	either model of concepts::CDigitalSurfaceContainer.
TCellEmbedder	any model of CCellEmbedder

Parameters

[out]	output	the output stream.
[in]	surface	a smart pointer on a digital surface (either DigitalSurface or LightDigitalSurface).
[in]	embedder	the embedder for mapping (unsigned) surfels (cells of dimension 2) to points in space.
[in]	params	the parameters: faceSubdivision ["Centroid"]: "No"\|"Naive"\|"Centroid" specifies how dual faces are subdivided when exported.

Returns: 'true' if the output stream is good.

Definition at line 3259 of file Shortcuts.h.

        {
          typedef unsigned long Size;
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          BOOST_CONCEPT_ASSERT(( concepts::CCellEmbedder< TCellEmbedder > ));
          std::string dualFaceSubdivision = params[ "faceSubdivision" ].as<std::string>();
          const int   subdivide
          = dualFaceSubdivision == "Naive"    ? 1
          : dualFaceSubdivision == "Centroid" ? 2
          : 0;
          const KSpace& K = embedder.space();
          // Number and ouput vertices.
          std::map< Vertex, Size > vtx_numbering;
          std::map< Face,   Size > sub_numbering;
          Size n = 1;  // OBJ vertex numbering start at 1 
          for ( auto && s : *surface )
            {
              if ( ! vtx_numbering.count( s ) )
                {
                  vtx_numbering[ s ] = n++;
                  // Output vertex positions
                  RealPoint p = embedder( K.unsigns( s ) );
                  output << "v " << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
                }
            }
          auto faces = surface->allClosedFaces();
          // Prepare centroids if necessary
          if ( subdivide == 2 )
            {
              for ( auto&& f : faces )
                {
                  auto vtcs = surface->verticesAroundFace( f );
                  Size   nv = vtcs.size();
                  if ( nv > 3 )
                    {
                      sub_numbering[ f ] = n++;
                      RealPoint p = RealPoint::zero;
                      for ( auto&& s : vtcs ) p += embedder( K.unsigns( s ) );
                      p /= nv;
                      output << "v " << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
                    }
                }
            }
          // Outputs closed faces.
          if ( subdivide == 0 )
            { // No subdivision
              for ( auto&& f : faces )
                {
                  output << "f";
                  auto vtcs = surface->verticesAroundFace( f );
                  std::reverse( vtcs.begin(), vtcs.end() );
                  for ( auto&& s : vtcs )
                    output << " " << vtx_numbering[ s ];
                  output << std::endl;
                }
            }
          else if ( subdivide == 1 )
            { // naive subdivision
              for ( auto&& f : faces )
                {
                  auto vtcs = surface->verticesAroundFace( f );
                  Size   nv = vtcs.size();
                  for ( Size i = 1; i < nv - 1; ++i )
                    output << "f " << vtx_numbering[ vtcs[ 0 ] ]
                           << " "  << vtx_numbering[ vtcs[ i+1 ] ]
                           << " "  << vtx_numbering[ vtcs[ i ] ] << std::endl;
                }
            }
          else if ( subdivide == 2 )
            { // centroid subdivision
              for ( auto&& f : faces )
                {
                  auto vtcs = surface->verticesAroundFace( f );
                  Size   nv = vtcs.size();
                  if ( nv == 3 )
                    output << "f " << vtx_numbering[ vtcs[ 0 ] ]
                           << " "  << vtx_numbering[ vtcs[ 2 ] ]
                           << " "  << vtx_numbering[ vtcs[ 1 ] ] << std::endl;
                  else {
                    Size c = sub_numbering[ f ];
                    for ( Size i = 0; i < nv; ++i )
                      {
                        output << "f " << c
                               << " "  << vtx_numbering[ vtcs[ (i+1)%nv ] ]
                               << " "  << vtx_numbering[ vtcs[ i ] ] << std::endl;
                      }
                  }
                }
            }
          return output.good();
        }

References DGtal::Shortcuts< TKSpace >::BOOST_CONCEPT_ASSERT(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, K, surface, and DGtal::PointVector< dim, TEuclideanRing, TContainer >::zero.

◆ outputPrimalDigitalSurfaceAsObj() [1/2]

template<typename TKSpace >

template<typename TAnyDigitalSurface >

static bool DGtal::Shortcuts< TKSpace >::outputPrimalDigitalSurfaceAsObj	(	std::ostream &	output,
		CountedPtr< TAnyDigitalSurface >	surface
	)

inlinestatic

Outputs a digital surface, seen from the primal point of view (surfels=face), as an OBJ file (3D only). Note that faces are oriented consistently (normals toward outside).

Template Parameters

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

Parameters

[out]	output	the output stream.
[in]	surface	a smart pointer on a digital surface.

Returns: 'true' if the output stream is good.

Definition at line 3125 of file Shortcuts.h.

        {
          auto embedder = getCellEmbedder( surface );
          return outputPrimalDigitalSurfaceAsObj( output, surface, embedder );
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::outputPrimalDigitalSurfaceAsObj(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::outputPrimalDigitalSurfaceAsObj().

◆ outputPrimalDigitalSurfaceAsObj() [2/2]

template<typename TKSpace >

template<typename TAnyDigitalSurface , typename TCellEmbedder = CanonicCellEmbedder< KSpace >>

static bool DGtal::Shortcuts< TKSpace >::outputPrimalDigitalSurfaceAsObj	(	std::ostream &	output,
		CountedPtr< TAnyDigitalSurface >	surface,
		const TCellEmbedder &	embedder
	)

inlinestatic

Outputs a digital surface, seen from the primal point of view (surfels=face), as an OBJ file (3D only). Note that faces are oriented consistently (normals toward outside). Each vertex is mapped to a 3D point using the given cell embedder.

Template Parameters

TAnyDigitalSurface	either kind of DigitalSurface, like Shortcuts::LightDigitalSurface or Shortcuts::DigitalSurface.
TCellEmbedder	any model of CCellEmbedder

Parameters

[out]	output	the output stream.
[in]	surface	a smart pointer on a digital surface.
[in]	embedder	the embedder for mapping surfel vertices (cells of dimension 0) to points in space.

Returns: 'true' if the output stream is good.

Definition at line 3153 of file Shortcuts.h.

        {
          auto surfels = getSurfelRange( surface, Parameters( "Traversal", "Default" ) );
          return outputSurfelsAsObj( output, surfels, embedder );
        }

References DGtal::Shortcuts< TKSpace >::getSurfelRange(), DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj(), and surface.

◆ outputPrimalIdxDigitalSurfaceAsObj() [1/2]

template<typename TKSpace >

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

inlinestatic

Outputs an indexed digital surface, seen from the primal point of view (surfels=face), as an OBJ file (3D only). Note that faces are oriented consistently (normals toward outside).

Parameters

[out]	output	the output stream.
[in]	surface	a smart pointer on an indexed digital surface.

Returns: 'true' if the output stream is good.

Definition at line 3171 of file Shortcuts.h.

      {
        auto embedder = getCellEmbedder( surface );
        return outputPrimalIdxDigitalSurfaceAsObj( output, surface, embedder );
      }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::outputPrimalIdxDigitalSurfaceAsObj(), and surface.

Referenced by DGtal::Shortcuts< TKSpace >::outputPrimalIdxDigitalSurfaceAsObj().

◆ outputPrimalIdxDigitalSurfaceAsObj() [2/2]

template<typename TKSpace >

template<typename TCellEmbedder = CanonicCellEmbedder< KSpace >>

static bool DGtal::Shortcuts< TKSpace >::outputPrimalIdxDigitalSurfaceAsObj	(	std::ostream &	output,
		CountedPtr< IdxDigitalSurface >	surface,
		const TCellEmbedder &	embedder
	)

inlinestatic

Outputs an indexed digital surface, seen from the primal point of view (surfels=face), as an OBJ file (3D only). Note that faces are oriented consistently (normals toward outside). Each vertex is mapped to a 3D point using the given cell embedder.

Template Parameters

TCellEmbedder any model of CCellEmbedder

Parameters

[out]	output	the output stream.
[in]	surface	a smart pointer on an indexed digital surface.
[in]	embedder	the embedder for mapping surfel vertices (cells of dimension 0) to points in space.

Returns: 'true' if the output stream is good.

Definition at line 3194 of file Shortcuts.h.

        {
          auto idxsurfels = getIdxSurfelRange( surface, Parameters( "Traversal", "Default" ) );
          auto  surfelmap = surface->surfels();
          SurfelRange surfels;
          for ( auto&& idx : idxsurfels )
            surfels.push_back( surfelmap[ idx ] );
          return outputSurfelsAsObj( output, surfels, embedder );
        }

References DGtal::Shortcuts< TKSpace >::getIdxSurfelRange(), DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj(), and surface.

◆ outputSCellMapAsCSV()

template<typename TKSpace >

template<typename TSCellMap , typename TValueWriter >

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

inlinestatic

Definition at line 3455 of file Shortcuts.h.

      {
        SCellWriter w;
        for ( auto&& v : anyMap )
          {
            w( output, K, v.first );
            writer( output, v.second );
            output << std::endl;
          }
        return output.good();
      }

References K.

◆ outputSurfelsAsObj()

template<typename TKSpace >

template<typename TCellEmbedder = CanonicCellEmbedder< KSpace >>

static bool DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj	(	std::ostream &	output,
		const SurfelRange &	surfels,
		const TCellEmbedder &	embedder
	)

inlinestatic

Outputs a range of surfels as an OBJ file, embedding each vertex using the given cell embedder (3D only).

Template Parameters

TCellEmbedder any model of CCellEmbedder

Parameters

[out]	output	the output stream.
[in]	surfels	the range of surfels (oriented cells of dimension 2).
[in]	embedder	the embedder for mapping surfel vertices (cells of dimension 0) to points in space.

Returns: 'true' if the output stream is good.

Definition at line 3074 of file Shortcuts.h.

        {
          typedef unsigned long Size;
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          BOOST_CONCEPT_ASSERT(( concepts::CCellEmbedder< TCellEmbedder > ));
          const KSpace& K = embedder.space();
          // Number and output vertices.
          std::map< Cell, Size > vtx_numbering;
          Size n = 1;  // OBJ vertex numbering start at 1 
          for ( auto&& s : surfels )
            {
              auto primal_vtcs = getPointelRange( K, s, true );
              for ( auto&& primal_vtx : primal_vtcs )
                {
                  if ( ! vtx_numbering.count( primal_vtx ) )
                    {
                      vtx_numbering[ primal_vtx ] = n++;
                      // Output vertex positions
                      RealPoint p = embedder( primal_vtx );
                      output << "v " << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
                    }
                }
            }
          // Outputs all faces
          for ( auto&& s : surfels )
            {
              output << "f";
              auto primal_vtcs = getPointelRange( K, s, true );
              for ( auto&& primal_vtx : primal_vtcs )
                output << " " << vtx_numbering[ primal_vtx ];
              output << std::endl;
            }      
          return output.good();
        }

References DGtal::Shortcuts< TKSpace >::BOOST_CONCEPT_ASSERT(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, DGtal::Shortcuts< TKSpace >::getPointelRange(), and K.

Referenced by DGtal::Shortcuts< TKSpace >::outputPrimalDigitalSurfaceAsObj(), and DGtal::Shortcuts< TKSpace >::outputPrimalIdxDigitalSurfaceAsObj().

◆ parametersBinaryImage()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are related to binary images and synthetic noise.

noise [0.0]: specifies the Kanungo noise level for binary pictures.
thresholdMin [ 0]: specifies the threshold min (excluded) to define binary shape
thresholdMax [255]: specifies the threshold max (included) to define binary shape

Definition at line 544 of file Shortcuts.h.

      {
        return Parameters
          ( "noise", 0.0 )
          ( "thresholdMin", 0 )
          ( "thresholdMax", 255 );
      }

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

◆ parametersDigitalSurface()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are related to digital surfaces.

surfelAdjacency [ 0]: specifies the surfel adjacency (1:ext, 0:int)
nbTriesToFindABel [ 100000]: number of tries in method Surfaces::findABel
surfaceComponents [ "AnyBig"]: "AnyBig"|"All", "AnyBig": any big-enough componen
surfaceTraversal ["Default"]: "Default"|"DepthFirst"|"BreadthFirst": "Default" default surface traversal, "DepthFirst": depth-first surface traversal, "BreadthFirst": breadth-first surface traversal.

Definition at line 1257 of file Shortcuts.h.

      {
        return Parameters
          ( "surfelAdjacency",   0 )
          ( "nbTriesToFindABel", 100000 )
          ( "surfaceComponents", "AnyBig" )
          ( "surfaceTraversal",  "Default" );
      }

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

◆ parametersDigitizedImplicitShape3D()

template<typename TKSpace >

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

inlinestatic

Returns

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

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

Definition at line 458 of file Shortcuts.h.

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

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

◆ parametersGrayScaleImage()

template<typename TKSpace >

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

inlinestatic

Returns

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

qShift [128.0]: the shift used when quantifying the implicit shape (q(x)=qSlope*x+qShift, e.g. to build a grayscale image).
qSlope [ 1.0]: the slope used when quantifying the implicit shape (q(x)=qSlope*x+qShift, e.g. to build a grayscale image).

Definition at line 856 of file Shortcuts.h.

      {
        return Parameters
          ( "qShift",   128.0 )
          ( "qSlope",     1.0 );
      }

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

◆ parametersImplicitShape3D()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are used to define an implicit shape.

polynomial ["sphere1"]: the implicit polynomial whose zero-level set defines the shape of interest.
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.

Definition at line 262 of file Shortcuts.h.

      {
        return Parameters
          ( "polynomial", "sphere1" )
          ( "projectionMaxIter", 20 )
          ( "projectionAccuracy", 0.0001 )
          ( "projectionGamma",    0.5 );
      }

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

◆ parametersKSpace()

template<typename TKSpace >

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

inlinestatic

Returns

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

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

Definition at line 308 of file Shortcuts.h.

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

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

◆ parametersMesh()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are related to meshes.

faceSubdivision ["Centroid"]: "No"|"Naive"|"Centroid" specifies how polygonal faces should be subdivided when triangulated or when exported.

Definition at line 2297 of file Shortcuts.h.

      {
        return Parameters
          ( "faceSubdivision", "Centroid" ); 
      }

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

◆ parametersUtilities()

template<typename TKSpace >

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

inlinestatic

Returns

the parameters and their default values which are related to utilities

colormap [ "Custom" ]: "Cool"|"Copper"|"Hot"|"Jet"|"Spring"|"Summer"|"Autumn"|"Winter"|"Error"|"Custom" specifies standard colormaps (if invalid, falls back to "Custom").
zero-tic [ 0.0 ]: if positive defines a black zone ]-zt,zt[ in the colormap.

Definition at line 2936 of file Shortcuts.h.

      {
        return Parameters
          ( "colormap", "Custom" )
          ( "zero-tic", 0.0 ); 
      }

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

◆ refKSpace() [1/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static const KSpace & DGtal::Shortcuts< TKSpace >::refKSpace ( 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: a const reference to the Khalimsky space associated to the given surface.

Definition at line 415 of file Shortcuts.h.

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

References surface.

Referenced by DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::getCellRange(), DGtal::Shortcuts< TKSpace >::getPointelRange(), DGtal::Shortcuts< TKSpace >::getSCellEmbedder(), DGtal::Shortcuts< TKSpace >::getSCellEmbedder(), DGtal::Shortcuts< TKSpace >::makeDigitalSurface(), DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), DGtal::Shortcuts< TKSpace >::saveOBJ(), and DGtal::Shortcuts< TKSpace >::saveOFF().

◆ refKSpace() [2/2]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static const KSpace & DGtal::Shortcuts< TKSpace >::refKSpace ( 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: a const reference to the Khalimsky space associated to the given surface.

Definition at line 426 of file Shortcuts.h.

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

References surface.

◆ saveBinaryImage()

template<typename TKSpace >

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

inlinestatic

Saves an arbitrary binary image file (e.g. vol file in 3D).

Parameters

[in]	bimage	the input binary image.
[in]	output	the output filename .

Returns: 'true' if everything went well, 'false' if there was an error during save.

Definition at line 840 of file Shortcuts.h.

      {
        auto gray_scale_image = makeGrayScaleImage( bimage );
        return saveGrayScaleImage( gray_scale_image, output );
      }

References DGtal::Shortcuts< TKSpace >::makeGrayScaleImage(), and DGtal::Shortcuts< TKSpace >::saveGrayScaleImage().

◆ saveGrayScaleImage()

template<typename TKSpace >

static bool DGtal::Shortcuts< TKSpace >::saveGrayScaleImage	(	CountedPtr< GrayScaleImage >	gray_scale_image,
		std::string	output
	)

inlinestatic

Saves an arbitrary gray-scale image file (e.g. vol file in 3D).

Parameters

[in]	gray_scale_image	the input gray-scale image.
[in]	output	the output filename .

Returns: 'true' if everything went well, 'false' if there was an error during save.

Definition at line 916 of file Shortcuts.h.

      {
        return GenericWriter< GrayScaleImage > 
          ::exportFile( output, *gray_scale_image );
      }

Referenced by DGtal::Shortcuts< TKSpace >::saveBinaryImage().

◆ saveOBJ() [1/9]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static bool DGtal::Shortcuts< TKSpace >::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`
	)

inlinestatic

Outputs a digital surface as an OBJ file (with its topology) and a material MTL file. Optionnaly you can specify the surfels normals and diffuse colors. Here surfels are canonically embedded into the space.

Template Parameters

TDigitalSurfaceContainer any model of concepts::CDigitalSurfaceContainer

Parameters

[in]	digsurf	the digital surface to output as an OBJ file
[in]	normals	the normal vector per face.
[in]	diffuse_colors	either empty or a vector of size `trisurf.nbFaces` specifying the diffuse color for each face.
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all faces.
[in]	diffuse_color	the diffuse color of all faces (if diffuse_colors is empty).
[in]	specular_color	the specular color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 2119 of file Shortcuts.h.

        {
          auto embedder = getCellEmbedder( digsurf );
          return saveOBJ( digsurf, embedder, normals, diffuse_colors, objfile,
                          ambient_color, diffuse_color, specular_color );
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), and DGtal::Shortcuts< TKSpace >::saveOBJ().

◆ saveOBJ() [2/9]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer , typename TCellEmbedder >

static bool DGtal::Shortcuts< TKSpace >::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`
	)

inlinestatic

Outputs a digital surface as an OBJ file (with its topology) and a material MTL file. Optionnaly you can specify the surfels normals and diffuse colors, and even specify how 0-cells are embedded into the space.

Template Parameters

TDigitalSurfaceContainer	any model of concepts::CDigitalSurfaceContainer
TCellEmbedder	any type for maping Cell -> RealPoint.

Parameters

[in]	digsurf	the digital surface to output as an OBJ file
[in]	embedder	any map Cell->RealPoint
[in]	normals	the normal vector per face.
[in]	diffuse_colors	either empty or a vector of size `trisurf.nbFaces` specifying the diffuse color for each face.
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all faces.
[in]	diffuse_color	the diffuse color of all faces (if diffuse_colors is empty).
[in]	specular_color	the specular color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 1999 of file Shortcuts.h.

        {
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          std::string mtlfile;
          auto lastindex = objfile.find_last_of(".");
          if ( lastindex == std::string::npos )
            {
              mtlfile  = objfile + ".mtl";
              objfile  = objfile + ".obj";
            }
          else
            {
              mtlfile  = objfile.substr(0, lastindex) + ".mtl"; 
            }
 
          std::ofstream output_obj( objfile.c_str() );
          output_obj << "#  OBJ format" << std::endl;
          output_obj << "# DGtal::MeshHelpers::exportOBJwithFaceNormalAndColor" << std::endl;
          output_obj << "o anObject" << std::endl;
                  //remove directory to write material
          auto indexpath = objfile.find_last_of("/");
          output_obj << "mtllib " << mtlfile.substr(indexpath+1) << std::endl;
          std::ofstream output_mtl( mtlfile.c_str() );
          output_mtl << "#  MTL format"<< std::endl;
          output_mtl << "# generated from MeshWriter from the DGTal library"<< std::endl;
          // Number and output vertices.
          const KSpace&     K = refKSpace( digsurf );
          Cell2Index      c2i;
          auto       pointels = getPointelRange( c2i, digsurf );
          for ( auto&& pointel : pointels )
            {
              RealPoint p = embedder( pointel );
              output_obj << "v " << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
            }   
          // Taking care of normals
          Idx nbfaces = digsurf->size();
          bool has_normals = ( nbfaces == normals.size() );
          if ( has_normals )
            {
              for ( Idx f = 0; f < nbfaces; ++f )
                {
                  const auto& p = normals[ f ];
                  output_obj << "vn " << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
                }
            }
          // Taking care of materials
          bool has_material = ( nbfaces == diffuse_colors.size() );
          Idx   idxMaterial = 0;
          std::map<Color, Idx > mapMaterial;
          if ( has_material )
            {
              for ( Idx f = 0; f < nbfaces; ++f )
                {
                  Color c = diffuse_colors[ f ];
                  if ( mapMaterial.count( c ) == 0 )
                    {
                      MeshHelpers::exportMTLNewMaterial
                        ( output_mtl, idxMaterial, ambient_color, c, specular_color );
                      mapMaterial[ c ] = idxMaterial++;
                    }
                }
            }
          else
            {
              MeshHelpers::exportMTLNewMaterial
                ( output_mtl, idxMaterial, ambient_color, diffuse_color, specular_color );
            }
      
          // Taking care of faces
          Idx f = 0;
          for ( auto&& surfel : *digsurf )
            {
              output_obj << "usemtl material_"
                         << ( has_material ? mapMaterial[ diffuse_colors[ f ] ] : idxMaterial )
                         << std::endl; 
              output_obj << "f";
              auto primal_vtcs = getPointelRange( K, surfel );
              // The +1 in lines below is because indexing starts at 1 in OBJ file format.
              if ( has_normals )
                {
                  for ( auto&& primal_vtx : primal_vtcs )
                    output_obj << " " << (c2i[ primal_vtx ]+1) << "//" << (f+1);
                }
              else
                {
                  for ( auto&& primal_vtx : primal_vtcs )
                    output_obj << " " << (c2i[ primal_vtx ]+1);
                }
              output_obj << std::endl;
              f += 1;
            }
          output_mtl.close();
          return output_obj.good();
        }

References DGtal::KhalimskySpaceND< dim, TInteger >::dimension, DGtal::MeshHelpers::exportMTLNewMaterial(), DGtal::Shortcuts< TKSpace >::getPointelRange(), K, DGtal::Shortcuts< TKSpace >::refKSpace(), and DGtal::PointVector< dim, TEuclideanRing, TContainer >::size().

Referenced by DGtal::Shortcuts< TKSpace >::saveOBJ(), and DGtal::Shortcuts< TKSpace >::saveOBJ().

◆ saveOBJ() [3/9]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static bool DGtal::Shortcuts< TKSpace >::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`
	)

inlinestatic

Outputs a digital surface as an OBJ file (with its topology) and a simple MTL file. Here surfels are canonically embedded into the space.

Template Parameters

TDigitalSurfaceContainer any model of concepts::CDigitalSurfaceContainer

Parameters

[in]	digsurf	the digital surface to output as an OBJ file
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all faces.
[in]	diffuse_color	the diffuse color of all faces (if diffuse_colors is empty).
[in]	specular_color	the specular color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 2170 of file Shortcuts.h.

        {
          auto embedder = getCellEmbedder( digsurf );
          return saveOBJ( digsurf, embedder, RealVectors(), Colors(), objfile,
                          ambient_color, diffuse_color, specular_color );
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), and DGtal::Shortcuts< TKSpace >::saveOBJ().

◆ saveOBJ() [4/9]

template<typename TKSpace >

template<typename TPoint >

static bool DGtal::Shortcuts< TKSpace >::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`
	)

inlinestatic

Outputs a polygonal surface as an OBJ file (with its topology) (and a material MTL file).

Template Parameters

TPoint any model of point

Parameters

[in]	polysurf	the polygonal surface to output as an OBJ file
[in]	normals	the normal vector per face.
[in]	diffuse_colors	either empty or a vector of size `polysurf.nbFaces` specifying the diffuse color for each face.
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all faces.
[in]	diffuse_color	the diffuse color of all faces (if diffuse_colors is empty).
[in]	specular_color	the specular color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 2788 of file Shortcuts.h.

        {
          std::string mtlfile;
          auto lastindex = objfile.find_last_of(".");
          if ( lastindex == std::string::npos )
            {
              mtlfile  = objfile + ".mtl";
              objfile  = objfile + ".obj";
            }
          else
            {
              mtlfile  = objfile.substr(0, lastindex) + ".mtl"; 
            }
          std::ofstream output( objfile.c_str() );
          bool ok = MeshHelpers::exportOBJwithFaceNormalAndColor
            ( output, mtlfile, *polysurf, normals, diffuse_colors,
              ambient_color, diffuse_color, specular_color );
          output.close();
          return ok;
        }

References DGtal::MeshHelpers::exportOBJwithFaceNormalAndColor().

◆ saveOBJ() [5/9]

template<typename TKSpace >

template<typename TPoint >

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

inlinestatic

Outputs a polygonal surface as an OBJ file (with its topology).

Template Parameters

TPoint any model of point

Parameters

[in]	polysurf	the polygonal surface to output as an OBJ file
[in]	objfile	the output filename.

Returns: 'true' if the output stream is good.

Definition at line 2719 of file Shortcuts.h.

        {
          std::ofstream output( objfile.c_str() );
          bool ok = MeshHelpers::exportOBJ( output, *polysurf );
          output.close();
          return ok;
        }

References DGtal::MeshHelpers::exportOBJ().

◆ saveOBJ() [6/9]

template<typename TKSpace >

template<typename TPoint , typename TVector >

static bool DGtal::Shortcuts< TKSpace >::saveOBJ	(	CountedPtr< ::DGtal::SurfaceMesh< TPoint, TVector > >	surf,
		const RealVectors &	normals,
		const Colors &	diffuse_colors,
		std::string	objfile,
		const Color &	ambient_color = `Color( 32, 32, 32 )`,
		const Color &	diffuse_color = `Color( 200, 200, 255 )`,
		const Color &	specular_color = `Color::White`
	)

inlinestatic

Outputs a SurfaceMesh as an OBJ file (with its topology) (and a material MTL file).

Template Parameters

TPoint	any model of point
TVector	any model of vector

Parameters

[in]	surf	the surface to output as an OBJ file
[in]	normals	the normal vector per face.
[in]	diffuse_colors	either empty or a vector of size `trisurf.nbFaces` specifying the diffuse color for each face.
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all faces.
[in]	diffuse_color	the diffuse color of all faces (if diffuse_colors is empty).
[in]	specular_color	the specular color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 2873 of file Shortcuts.h.

        {
          std::string mtlfile;
          auto lastindex = objfile.find_last_of(".");
          if ( lastindex == std::string::npos )
            {
              mtlfile  = objfile + ".mtl";
              objfile  = objfile + ".obj";
            }
          else
            {
              mtlfile  = objfile.substr(0, lastindex) + ".mtl"; 
            }
          std::ofstream output( objfile.c_str() );
          bool ok = MeshHelpers::exportOBJwithFaceNormalAndColor
            ( output, mtlfile, *surf, normals, diffuse_colors,
              ambient_color, diffuse_color, specular_color );
          output.close();
          return ok;
        }

References DGtal::MeshHelpers::exportOBJwithFaceNormalAndColor().

◆ saveOBJ() [7/9]

template<typename TKSpace >

template<typename TPoint , typename TVector >

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

inlinestatic

Outputs a SurfaceMesh as an OBJ file (with its topology).

Template Parameters

TPoint	any model of point
TVector	any model of vector

Parameters

[in]	surf	the surface to output as an OBJ file
[in]	objfile	the output filename.

Returns: 'true' if the output stream is good.

Definition at line 2701 of file Shortcuts.h.

        {
          std::ofstream output( objfile.c_str() );
          bool ok = MeshHelpers::exportOBJ( output, *surf );
          output.close();
          return ok;
        }

References DGtal::MeshHelpers::exportOBJ().

◆ saveOBJ() [8/9]

template<typename TKSpace >

template<typename TPoint >

static bool DGtal::Shortcuts< TKSpace >::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`
	)

inlinestatic

Outputs a triangulated surface as an OBJ file (with its topology) (and a material MTL file).

Template Parameters

TPoint any model of point

Parameters

[in]	trisurf	the triangulated surface to output as an OBJ file
[in]	normals	the normal vector per face.
[in]	diffuse_colors	either empty or a vector of size `trisurf.nbFaces` specifying the diffuse color for each face.
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all faces.
[in]	diffuse_color	the diffuse color of all faces (if diffuse_colors is empty).
[in]	specular_color	the specular color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 2830 of file Shortcuts.h.

        {
          std::string mtlfile;
          auto lastindex = objfile.find_last_of(".");
          if ( lastindex == std::string::npos )
            {
              mtlfile  = objfile + ".mtl";
              objfile  = objfile + ".obj";
            }
          else
            {
              mtlfile  = objfile.substr(0, lastindex) + ".mtl"; 
            }
          std::ofstream output( objfile.c_str() );
          bool ok = MeshHelpers::exportOBJwithFaceNormalAndColor
            ( output, mtlfile, *trisurf, normals, diffuse_colors,
              ambient_color, diffuse_color, specular_color );
          output.close();
          return ok;
        }

References DGtal::MeshHelpers::exportOBJwithFaceNormalAndColor().

◆ saveOBJ() [9/9]

template<typename TKSpace >

template<typename TPoint >

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

inlinestatic

Outputs a triangulated surface as an OBJ file (with its topology).

Template Parameters

TPoint any model of point

Parameters

[in]	trisurf	the triangulated surface to output as an OBJ file
[in]	objfile	the output filename.

Returns: 'true' if the output stream is good.

Definition at line 2764 of file Shortcuts.h.

        {
          std::ofstream output( objfile.c_str() );
          bool ok = MeshHelpers::exportOBJ( output, *trisurf );
          output.close();
          return ok;
        }

References DGtal::MeshHelpers::exportOBJ().

◆ saveOFF() [1/4]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer , typename TCellEmbedder >

static bool DGtal::Shortcuts< TKSpace >::saveOFF	(	CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	digsurf,
		const TCellEmbedder &	embedder,
		std::string	off_file,
		const Color &	face_color = `DGtal::Color::None`
	)

inlinestatic

Outputs a digital surface as an OFF file (with its topology). Optionnaly you can specify the face colors (see saveOBJ for a more advanced export).

Template Parameters

TDigitalSurfaceContainer	any model of concepts::CDigitalSurfaceContainer
TCellEmbedder	any type for maping Cell -> RealPoint.

Parameters

[in]	digsurf	the digital surface to output as an OBJ file
[in]	embedder	any map Cell->RealPoint
[in]	face_color	the color of every face.
[in]	off_file	the output filename.

Returns: 'true' if the output stream is good.

Definition at line 1933 of file Shortcuts.h.

        {
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
 
          std::ofstream output_off( off_file.c_str() );
          output_off << "OFF" << std::endl;
          output_off << "# Generated from  DGtal::Shortcuts from the DGTal library" << std::endl;
          Cell2Index      c2i;
          auto       pointels = getPointelRange( c2i, digsurf );
          output_off <<  pointels.size()  << " " << digsurf->size() << " " << 0 << " " << std::endl;
          
          
          // Number and output vertices.
          const KSpace&     K = refKSpace( digsurf );
          for ( auto&& pointel : pointels )
            {
              RealPoint p = embedder( pointel );
              output_off << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
            }   
          
          // Taking care of faces
          for ( auto&& surfel : *digsurf )
            {              
              auto primal_vtcs = getPointelRange( K, surfel );
              output_off << primal_vtcs.size();
                {
                  for ( auto&& primal_vtx : primal_vtcs )
                    output_off << " " << (c2i[ primal_vtx ]);
                }
                if(face_color != DGtal::Color::None)
                {
                  output_off << " ";
                  output_off  << face_color.r() << " " << face_color.g()
                              << " " << face_color.b() << " " << face_color.a();
                }
                output_off << std::endl;
            }
          return output_off.good();
        }

References DGtal::KhalimskySpaceND< dim, TInteger >::dimension, DGtal::Shortcuts< TKSpace >::getPointelRange(), K, DGtal::Color::None, and DGtal::Shortcuts< TKSpace >::refKSpace().

Referenced by DGtal::Shortcuts< TKSpace >::saveOFF().

◆ saveOFF() [2/4]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

static bool DGtal::Shortcuts< TKSpace >::saveOFF	(	CountedPtr< ::DGtal::DigitalSurface< TDigitalSurfaceContainer > >	digsurf,
		std::string	off_file,
		const Color &	face_color = `Color( 32, 32, 32 )`
	)

inlinestatic

Outputs a digital surface as an OFF file (with its topology). Here surfels are canonically embedded into the space. Optionnaly you can specify the face colors (see saveOBJ for a more advanced export).

Outputs a digital surface as an OFF.

Template Parameters

TDigitalSurfaceContainer any model of concepts::CDigitalSurfaceContainer

Parameters

[in]	digsurf	the digital surface to output as an OBJ file
[in]	off_file	the output filename.
[in]	face_color	the color of every face.

Returns: 'true' if the output stream is good.

Definition at line 2148 of file Shortcuts.h.

          {
          auto embedder = getCellEmbedder( digsurf );
          return saveOFF( digsurf, embedder, off_file, face_color);
        }

References DGtal::Shortcuts< TKSpace >::getCellEmbedder(), and DGtal::Shortcuts< TKSpace >::saveOFF().

◆ saveOFF() [3/4]

template<typename TKSpace >

template<typename TPoint >

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

inlinestatic

Outputs a triangulated surface as an OFF file.

Template Parameters

TPoint any model of point

Parameters

[in]	polysurf	the polygonal surface to output as an OBJ file
[in]	off_file	the output filename.
[in]	face_color	the color of every face.

Returns: 'true' if the output stream is good.

Definition at line 2739 of file Shortcuts.h.

        {
          DGtal::Mesh< TPoint > m;
          MeshHelpers::polygonalSurface2Mesh(*polysurf,m);
          std::ofstream output( off_file.c_str() );
          for (unsigned int i=0; i< m.nbFaces(); i++)
          {
            m.setFaceColor(i, face_color);
          }
          bool ok = MeshWriter< TPoint >::export2OFF( output, m, true );
          output.close();
          return ok;
        }

References DGtal::MeshWriter< TPoint >::export2OFF(), DGtal::Mesh< TPoint >::nbFaces(), DGtal::MeshHelpers::polygonalSurface2Mesh(), and DGtal::Mesh< TPoint >::setFaceColor().

◆ saveOFF() [4/4]

template<typename TKSpace >

template<typename TPoint >

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

inlinestatic

Outputs a triangulated surface as an OFF file.

Template Parameters

TPoint any model of point

Parameters

[in]	trisurf	the triangulated surface to output as an OBJ file
[in]	off_file	the output filename.
[in]	face_color	the color of all faces.

Returns: 'true' if the output stream is good.

Definition at line 2911 of file Shortcuts.h.

        {
          DGtal::Mesh< TPoint > m;
          MeshHelpers::triangulatedSurface2Mesh(*trisurf,m);
          std::ofstream output( off_file.c_str() );
          for (unsigned int i=0; i< m.nbFaces(); i++)
          {
            m.setFaceColor(i, face_color);
          }
          bool ok = MeshWriter< TPoint >::export2OFF( output, m, true );
          output.close();
          return ok;
        }

References DGtal::MeshWriter< TPoint >::export2OFF(), DGtal::Mesh< TPoint >::nbFaces(), DGtal::Mesh< TPoint >::setFaceColor(), and DGtal::MeshHelpers::triangulatedSurface2Mesh().

◆ saveVectorFieldOBJ()

template<typename TKSpace >

static bool DGtal::Shortcuts< TKSpace >::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`
	)

inlinestatic

Outputs any vector field vf anchored at positions as an OBJ file and a material MTL file. Optionnaly you can specify the diffuse colors.

Parameters

[in]	positions	the bases of the vectors of the vector field.
[in]	vf	the vector field (an array of real vectors).
[in]	thickness	the thickness of the sticks representing the vector field.
[in]	diffuse_colors	either empty or a vector of size `normals.size()` specifying the diffuse color for each face.
[in]	objfile	the output filename.
[in]	ambient_color	the ambient color of all vectors.
[in]	diffuse_color	the diffuse color of all vectors (if diffuse_colors is empty).
[in]	specular_color	the specular color of all vectors.

Returns: 'true' if the output stream is good.

Note: It outputs only the vector field, not the surface onto which it is defined (if any).

Definition at line 2199 of file Shortcuts.h.

        {
          BOOST_STATIC_ASSERT (( KSpace::dimension == 3 ));
          std::string mtlfile;
          auto lastindex = objfile.find_last_of(".");
          if ( lastindex == std::string::npos )
            {
              mtlfile  = objfile + ".mtl";
              objfile  = objfile + ".obj";
            }
          else
            {
              mtlfile  = objfile.substr(0, lastindex) + ".mtl"; 
            }
          std::ofstream output_obj( objfile.c_str() );
          output_obj << "#  OBJ format" << std::endl;
          output_obj << "# DGtal::saveOBJ" << std::endl;
          output_obj << "o vectors" << std::endl;
          output_obj << "mtllib " << mtlfile << std::endl;
          std::ofstream output_mtl( mtlfile.c_str() );
          output_mtl << "#  MTL format"<< std::endl;
          output_mtl << "# generated from MeshWriter from the DGTal library"<< std::endl;
          // Output vertices
          auto n = std::min( positions.size(), vf.size() );
          for ( unsigned int i = 0; i < n; ++i )
            {
              RealPoint    p0 = positions[ i ];
              RealPoint    p1 = p0 + vf[ i ];
              RealVector    v = vf[ i ];
              RealVector absv = RealVector( fabs( v[ 0 ] ), fabs( v[ 1 ] ), fabs( v[ 2 ] ) );
              auto mc = std::max_element( absv.begin(), absv.end() ) - absv.begin();
              RealVector   b  =
                mc == 2 ? RealVector( 1, 0, 0 ) :
                mc == 1 ? RealVector( 0, 0, 1 ) : RealVector( 0, 1, 0 );
              RealVector   e0 = v.crossProduct( b ).getNormalized();
              RealVector   e1 = v.crossProduct( e0 ).getNormalized();
              RealPoint    t[4] = {  thickness * e0,  thickness * e1,
                                    -thickness * e0, -thickness * e1 };
              for ( unsigned int j = 0; j < 4; ++j ) {
                RealPoint pt0 = p0 + t[ j ];
                RealPoint pt1 = p1 + t[ j ];
                output_obj << "v " << pt0[ 0 ] << " " << pt0[ 1 ] << " " << pt0[ 2 ]
                           << std::endl;
                output_obj << "v " << pt1[ 0 ] << " " << pt1[ 1 ] << " " << pt1[ 2 ]
                           << std::endl;
              }
            }
          // Simplify materials (very useful for blender).
          std::map<Color,Idx> map_colors;
          {
            Idx j = 0;
            for ( auto && c : diffuse_colors )
              if ( ! map_colors.count( c ) )
                map_colors[ c ] = j++;
          }
          
          // Output materials
          bool has_material = ! diffuse_colors.empty();
          if ( has_material )
            for ( auto&& pair : map_colors )
              MeshHelpers::exportMTLNewMaterial
                ( output_mtl, pair.second, ambient_color, pair.first, specular_color);
          else
            MeshHelpers::exportMTLNewMaterial
              ( output_mtl, 0, ambient_color, diffuse_color, specular_color );
          // Output faces
          for ( Idx i = 0; i < n; ++i )
            {
              output_obj << "usemtl material_" // << ( has_material ? i : 0 )
                         << ( has_material ? map_colors[ diffuse_colors[ i ] ] : 0 )
                         << std::endl;
              Idx b = 8*i+1;
              for ( Idx j = 0; j < 8; j += 2 )
                output_obj << "f " << (b+j) << " " << (b+j+1)
                           << " " << (b+(j+3)%8) << " " << (b+(j+2)%8) << std::endl;
              output_obj << "f " << b << " " << (b+2)
                         << " " << (b+4) << " " << (b+6) << std::endl;
              output_obj << "f " << (b+1) << " " << (b+7)
                         << " " << (b+5) << " " << (b+3) << std::endl;
            }
          output_mtl.close();
          return output_obj.good();
        }

References DGtal::PointVector< dim, TEuclideanRing, TContainer >::begin(), DGtal::PointVector< dim, TEuclideanRing, TContainer >::crossProduct(), DGtal::KhalimskySpaceND< dim, TInteger >::dimension, DGtal::PointVector< dim, TEuclideanRing, TContainer >::end(), and DGtal::MeshHelpers::exportMTLNewMaterial().

◆ selfDisplay()

template<typename TKSpace >

void DGtal::Shortcuts< TKSpace >::selfDisplay ( std::ostream & out ) const

inline

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

Definition at line 3598 of file Shortcuts.h.

      {
        out << "[Shortcuts]";
      }

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

Shortcuts.h

Data Structures

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ Arc

◆ ArcRange

◆ BinaryImage

◆ Cell

◆ Cell2Index

◆ CellRange

◆ Color

◆ ColorMap

◆ Colors

◆ DigitalSurface

◆ DigitizedImplicitShape3D

◆ Domain

◆ DoubleImage

◆ ExplicitSurfaceContainer

◆ Face

◆ FloatImage

◆ GrayScale

◆ GrayScaleImage

◆ Idx

◆ IdxArc

◆ IdxArcRange

◆ IdxDigitalSurface

◆ IdxRange

◆ IdxSurfel

◆ IdxSurfelRange

◆ IdxSurfelSet

◆ IdxVertex

◆ ImplicitShape3D

◆ Integer

◆ KSpace

◆ LightDigitalSurface

◆ LightSurfaceContainer

◆ Mesh

◆ Point

◆ PointelRange

◆ PolygonalSurface

◆ RealPoint

◆ RealPoints

◆ RealVector

◆ RealVectors

◆ Scalar

◆ ScalarPolynomial

◆ Scalars

◆ SCell

◆ SCellRange

◆ Space

◆ SurfaceMesh

◆ Surfel

◆ Surfel2Index

◆ SurfelRange

◆ SurfelSet

◆ TriangulatedSurface

◆ Vector

◆ Vertex

◆ ZeroTickedColorMap

Constructor & Destructor Documentation

◆ Shortcuts() [1/3]

◆ ~Shortcuts()

◆ Shortcuts() [2/3]

◆ Shortcuts() [3/3]

Member Function Documentation

◆ BOOST_CONCEPT_ASSERT()

◆ defaultParameters()

◆ getCellEmbedder() [1/3]

◆ getCellEmbedder() [2/3]

◆ getCellEmbedder() [3/3]

◆ getCellRange() [1/2]

◆ getCellRange() [2/2]

◆ getColorMap()

◆ getIdxSurfelRange() [1/2]

◆ getIdxSurfelRange() [2/2]

◆ getKSpace() [1/6]

◆ getKSpace() [2/6]