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	SCellReader

struct	SCellWriter

struct	ValueReader

struct	ValueWriter

Public Types
typedef TKSpace	KSpace
	Digital cellular space. More...

typedef KSpace::Space	Space
	Digital space. More...

typedef Space::Integer	Integer
	Integer numbers. More...

typedef Space::Point	Point
	Point with integer coordinates. More...

typedef Space::Vector	Vector
	Vector with integer coordinates. More...

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

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

typedef RealVector::Component	Scalar
	Floating-point numbers. More...

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

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

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

typedef ImplicitPolynomial3Shape< Space >	ImplicitShape3D

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

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

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

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

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

typedef KSpace::SurfelSet	SurfelSet
	defines a set of surfels More...

typedef LightImplicitDigitalSurface< KSpace, BinaryImage >	LightSurfaceContainer

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

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

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

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

typedef LightDigitalSurface::Surfel	Surfel

typedef LightDigitalSurface::Cell	Cell

typedef LightDigitalSurface::SCell	SCell

typedef LightDigitalSurface::Vertex	Vertex

typedef LightDigitalSurface::Arc	Arc

typedef LightDigitalSurface::Face	Face

typedef LightDigitalSurface::ArcRange	ArcRange

typedef IdxDigitalSurface::Vertex	IdxSurfel

typedef IdxDigitalSurface::Vertex	IdxVertex

typedef IdxDigitalSurface::Arc	IdxArc

typedef IdxDigitalSurface::ArcRange	IdxArcRange

typedef std::set< 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())

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

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

static Parameters	parametersGrayScaleImage ()

static CountedPtr< GrayScaleImage >	makeGrayScaleImage (Domain aDomain)

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

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

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

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

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

static CountedPtr< FloatImage >	makeFloatImage (Domain aDomain)

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

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

static CountedPtr< DoubleImage >	makeDoubleImage (Domain aDomain)

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

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

static Parameters	parametersDigitalSurface ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static Parameters	parametersMesh ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static Parameters	parametersUtilities ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Detailed Description

template<typename TKSpace>
class DGtal::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.

Definition at line 104 of file Shortcuts.h.

Member Typedef Documentation

◆ Arc

template<typename TKSpace >

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

Definition at line 165 of file Shortcuts.h.

◆ ArcRange

template<typename TKSpace >

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

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

◆ Cell

template<typename TKSpace >

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

Definition at line 162 of file Shortcuts.h.

◆ Cell2Index

template<typename TKSpace >

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

Definition at line 189 of file Shortcuts.h.

◆ CellRange

template<typename TKSpace >

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

Definition at line 174 of file Shortcuts.h.

◆ Color

template<typename TKSpace >

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

Definition at line 191 of file Shortcuts.h.

◆ ColorMap

template<typename TKSpace >

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

Definition at line 193 of file Shortcuts.h.

◆ Colors

template<typename TKSpace >

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

Definition at line 192 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 158 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 139 of file Shortcuts.h.

◆ Domain

template<typename TKSpace >

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

An (hyper-)rectangular domain.

Definition at line 127 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 147 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 156 of file Shortcuts.h.

◆ Face

template<typename TKSpace >

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

Definition at line 166 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 145 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 129 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 143 of file Shortcuts.h.

◆ Idx

template<typename TKSpace >

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

Definition at line 181 of file Shortcuts.h.

◆ IdxArc

template<typename TKSpace >

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

Definition at line 170 of file Shortcuts.h.

◆ IdxArcRange

template<typename TKSpace >

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

Definition at line 171 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 160 of file Shortcuts.h.

◆ IdxRange

template<typename TKSpace >

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

Definition at line 182 of file Shortcuts.h.

◆ IdxSurfel

template<typename TKSpace >

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

Definition at line 168 of file Shortcuts.h.

◆ IdxSurfelRange

template<typename TKSpace >

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

Definition at line 177 of file Shortcuts.h.

◆ IdxSurfelSet

template<typename TKSpace >

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

Definition at line 172 of file Shortcuts.h.

◆ IdxVertex

template<typename TKSpace >

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

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

◆ Integer

template<typename TKSpace >

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

Integer numbers.

Definition at line 115 of file Shortcuts.h.

◆ KSpace

template<typename TKSpace >

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

Digital cellular space.

Definition at line 111 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 154 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 152 of file Shortcuts.h.

◆ Mesh

template<typename TKSpace >

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

Definition at line 184 of file Shortcuts.h.

◆ Point

template<typename TKSpace >

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

Point with integer coordinates.

Definition at line 117 of file Shortcuts.h.

◆ PointelRange

template<typename TKSpace >

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

Definition at line 175 of file Shortcuts.h.

◆ PolygonalSurface

template<typename TKSpace >

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

Definition at line 186 of file Shortcuts.h.

◆ RealPoint

template<typename TKSpace >

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

Point with floating-point coordinates.

Definition at line 123 of file Shortcuts.h.

◆ RealPoints

template<typename TKSpace >

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

Definition at line 180 of file Shortcuts.h.

◆ RealVector

template<typename TKSpace >

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

Vector with floating-point coordinates.

Definition at line 121 of file Shortcuts.h.

◆ RealVectors

template<typename TKSpace >

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

Definition at line 179 of file Shortcuts.h.

◆ Scalar

template<typename TKSpace >

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

Floating-point numbers.

Definition at line 125 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 134 of file Shortcuts.h.

◆ Scalars

template<typename TKSpace >

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

Definition at line 178 of file Shortcuts.h.

◆ SCell

template<typename TKSpace >

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

Definition at line 163 of file Shortcuts.h.

◆ SCellRange

template<typename TKSpace >

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

Definition at line 173 of file Shortcuts.h.

◆ Space

template<typename TKSpace >

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

Digital space.

Definition at line 113 of file Shortcuts.h.

◆ SurfaceMesh

template<typename TKSpace >

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

Definition at line 187 of file Shortcuts.h.

◆ Surfel

template<typename TKSpace >

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

Definition at line 161 of file Shortcuts.h.

◆ Surfel2Index

template<typename TKSpace >

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

Definition at line 188 of file Shortcuts.h.

◆ SurfelRange

template<typename TKSpace >

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

Definition at line 176 of file Shortcuts.h.

◆ SurfelSet

template<typename TKSpace >

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

defines a set of surfels

Definition at line 149 of file Shortcuts.h.

◆ TriangulatedSurface

template<typename TKSpace >

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

Definition at line 185 of file Shortcuts.h.

◆ Vector

template<typename TKSpace >

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

Vector with integer coordinates.

Definition at line 119 of file Shortcuts.h.

◆ Vertex

template<typename TKSpace >

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

Definition at line 164 of file Shortcuts.h.

◆ ZeroTickedColorMap

template<typename TKSpace >

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

Definition at line 194 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 203 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().

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

         {
           return getCellEmbedder( refKSpace( surface ) );
         }

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

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

         {
           return getCellEmbedder( refKSpace( surface ) );
         }

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

◆ 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 1398 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, and DGtal::Shortcuts< TKSpace >::refKSpace().

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

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

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

◆ 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 2668 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 1631 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;
       }

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

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

Referenced by 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 332 of file Shortcuts.h.

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

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

Referenced by DGtal::DigitalSurfaceRegularization< TDigitalSurface >::DigitalSurfaceRegularization(), 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 396 of file Shortcuts.h.

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

◆ getKSpace() [3/6]

template<typename TKSpace >

template<typename TDigitalSurfaceContainer >

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

inlinestatic

Template Parameters

TDigitalSurfaceContainer either kind of DigitalSurfaceContainer

Parameters

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

Returns: the Khalimsky space associated to the given surface.

Definition at line 407 of file Shortcuts.h.

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

◆ getKSpace() [4/6]

template<typename TKSpace >

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

inlinestatic

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

Parameters

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

Returns: the Khalimsky space.

Definition at line 354 of file Shortcuts.h.

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

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

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

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

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

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 2653 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 1468 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 K, and DGtal::Shortcuts< TKSpace >::refKSpace().

Referenced by 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 1525 of file Shortcuts.h.

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

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

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

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

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

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 3164 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 3180 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 3192 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::Shortcuts< TKSpace >::getPrimalVertices(), K, and reverse().

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

       {
         return CanonicSCellEmbedder<KSpace>( K );
       }

References K.

Referenced by 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 1021 of file Shortcuts.h.

         {
           return getSCellEmbedder( refKSpace( surface ) );
         }

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

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

         {
           return getSCellEmbedder( refKSpace( surface ) );
         }

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

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

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

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

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

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

       {
         return true;
       }

◆ makeBinaryImage() [1/6]

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 628 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() [2/6]

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 596 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() [3/6]

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

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

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

◆ makeBinaryImage() [4/6]

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 684 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() [5/6]

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

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

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

◆ makeBinaryImage() [6/6]

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 655 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(), 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 1239 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 1208 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 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 522 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;
       }

◆ 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 963 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 930 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 942 of file Shortcuts.h.

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

References 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 2288 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 2302 of file Shortcuts.h.

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

◆ 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 2268 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(), 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 897 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 864 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 876 of file Shortcuts.h.

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

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

◆ makeGrayScaleImage() [1/5]

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 762 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() [2/5]

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 835 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, DGtal::Shortcuts< TKSpace >::makeGrayScaleImage(), and max().

◆ makeGrayScaleImage() [3/5]

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 803 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, DGtal::Shortcuts< TKSpace >::makeGrayScaleImage(), and max().

◆ makeGrayScaleImage() [4/5]

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

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

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

◆ makeGrayScaleImage() [5/5]

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

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

References 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 1363 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 1307 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 1340 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(), and DGtal::Shortcuts< TKSpace >::refKSpace().

◆ 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 1274 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 >::makeLightDigitalSurface(), and DGtal::Surfaces< TKSpace >::sMakeBoundary().

Referenced by 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 282 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.

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

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

References K.

◆ 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 1148 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 2088 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 2071 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 2188 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(), 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 2166 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 2321 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(), and DGtal::Shortcuts< TKSpace >::getCellEmbedder().

Referenced by 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 2341 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 2355 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 2372 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(), and DGtal::Shortcuts< TKSpace >::getCellEmbedder().

Referenced by 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 2390 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 2404 of file Shortcuts.h.

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

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

◆ 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 2122 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 2231 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(), 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 2054 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 2146 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 2104 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 3142 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 2882 of file Shortcuts.h.

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

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

◆ 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 2916 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(), K, reverse(), 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 2782 of file Shortcuts.h.

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

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

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

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

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

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

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

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

◆ 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 2851 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(), and DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj().

◆ 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 3112 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 2731 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::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 547 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 996 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 461 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 723 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 265 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 311 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 2036 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 2593 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 418 of file Shortcuts.h.

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

Referenced by DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::getCellRange(), DGtal::Shortcuts< TKSpace >::getPointelRange(), 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 429 of file Shortcuts.h.

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

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

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

References DGtal::GenericWriter< TContainer, Tdim, TValue, TFunctor >::exportFile().

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

◆ saveOBJ() [1/7]

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 1858 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/7]

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 1738 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::MeshHelpers::exportMTLNewMaterial(), DGtal::Shortcuts< TKSpace >::getPointelRange(), K, and DGtal::Shortcuts< TKSpace >::refKSpace().

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

◆ saveOBJ() [3/7]

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 1909 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/7]

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 2488 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/7]

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 2419 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/7]

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 2530 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() [7/7]

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 2464 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 1672 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::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 1887 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 2439 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(), and DGtal::MeshHelpers::polygonalSurface2Mesh().

◆ 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 2568 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(), 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 1938 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::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 3255 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

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

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]

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