functions namespace gathers all DGtal functionsxs. More...

Namespaces
	Hull2D
	Hull2D namespace gathers useful functions to compute and return the convex hull or the alpha-shape of a range of 2D points.

	setops

Functions
template<typename Container , bool ordered>
bool	isEqual (const Container &S1, const Container &S2)

template<typename Container >
bool	isEqual (const Container &S1, const Container &S2)

template<typename Container , bool ordered>
bool	isSubset (const Container &S1, const Container &S2)

template<typename Container >
bool	isSubset (const Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container &	assignDifference (Container &S1, const Container &S2)

template<typename Container >
Container &	assignDifference (Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container	makeDifference (const Container &S1, const Container &S2)

template<typename Container >
Container	makeDifference (const Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container &	assignUnion (Container &S1, const Container &S2)

template<typename Container >
Container &	assignUnion (Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container	makeUnion (const Container &S1, const Container &S2)

template<typename Container >
Container	makeUnion (const Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container &	assignIntersection (Container &S1, const Container &S2)

template<typename Container >
Container &	assignIntersection (Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container	makeIntersection (const Container &S1, const Container &S2)

template<typename Container >
Container	makeIntersection (const Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container &	assignSymmetricDifference (Container &S1, const Container &S2)

template<typename Container >
Container &	assignSymmetricDifference (Container &S1, const Container &S2)

template<typename Container , bool ordered>
Container	makeSymmetricDifference (const Container &S1, const Container &S2)

template<typename Container >
Container	makeSymmetricDifference (const Container &S1, const Container &S2)

template<typename TCoordinate , typename TInteger , unsigned short adjacency>
bool	checkOnePoint (const ArithmeticalDSS< TCoordinate, TInteger, adjacency > &aDSS)

template<typename TCoordinate , typename TInteger , unsigned short adjacency>
bool	checkPointsPosition (const ArithmeticalDSS< TCoordinate, TInteger, adjacency > &aDSS)

template<typename TCoordinate , typename TInteger , unsigned short adjacency>
bool	checkPointsRemainder (const ArithmeticalDSS< TCoordinate, TInteger, adjacency > &aDSS)

template<typename TCoordinate , typename TInteger , unsigned short adjacency>
bool	checkAll (const ArithmeticalDSS< TCoordinate, TInteger, adjacency > &aDSS)

template<typename Position , typename Coordinate , typename PointVector , typename OutputIterator , typename PositionFunctor , typename TruncationFunctor1 , typename TruncationFunctor2 >
bool	smartCHNextVertex (const Position &positionBound, const Coordinate &remainderBound, PointVector &X, Coordinate &rX, const PointVector &Y, const Coordinate &rY, PointVector &V, Coordinate &rV, OutputIterator ito, const PositionFunctor &pos, const TruncationFunctor1 &f1, const TruncationFunctor2 &f2)
	Procedure that computes the next (lower or upper) vertex of the left hull of a DSS. More...

template<typename PointVector , typename Coordinate , typename Position , typename PositionFunctor , typename OutputIterator >
PointVector	smartCH (const PointVector &aFirstPoint, const Coordinate &aRemainderBound, const Position &aPositionBound, const PointVector &aStep, const Coordinate &aRStep, const PointVector &aShift, const Coordinate &aRShift, const PositionFunctor &aPositionFunctor, OutputIterator uIto, OutputIterator lIto)
	Procedure that computes the lower and upper left hull of a DSS of first point aFirstPoint, length aPositionBound, contained in a digital straight line described by aRStep, aRShift and aRemainderBound. More...

template<typename DSL , typename OutputIterator >
DSL::Vector	smartCH (const DSL &aDSL, const typename DSL::Point &aFirstPoint, const typename DSL::Position &aLength, OutputIterator uIto, OutputIterator lIto)
	Procedure that computes the lower and upper left hull of a DSS of first point aFirstPoint, length aLength, contained in a DSL aDSL [Roussillon 2014 : [91]]. More...

template<typename PointVector , typename Position , typename OutputIterator , typename TruncationFunctor1 , typename TruncationFunctor2 , typename PositionFunctor >
bool	smartCHPreviousVertex (PointVector &X, const PointVector &Y, PointVector &V, const Position &aFirstPosition, const Position &aLastPosition, OutputIterator ito, const PositionFunctor &pos, const TruncationFunctor1 &f1, const TruncationFunctor2 &f2)
	Procedure that computes the previous vertex of the left hull of a DSS of main direction vector V , first upper leaning point U and first positive Bezout point L. The computation stops as soon as a computed vertex is located before aLastPosition. More...

template<typename PointVector , typename Position , typename PositionFunctor , typename OutputIterator >
PointVector	reversedSmartCH (PointVector U, PointVector L, PointVector V, const Position &aFirstPosition, const Position &aLastPosition, const PositionFunctor &aPositionFunctor, OutputIterator uIto, OutputIterator lIto)
	Procedure that computes the lower and upper left hull of the left subsegment of a greater DSS characterized by the first upper leaning point U, the first positive Bezout point L and its direction vector V. Note that the so-called left subsegment is bounded on the one hand by the first point of the DSS located at aFirstPosition and on the other hand by the point located at position aLastPosition. More...

template<typename DSS , typename OutputIterator >
DSS::Vector	reversedSmartCH (const DSS &aDSS, const typename DSS::Position &aPositionBound, OutputIterator uIto, OutputIterator lIto)
	Procedure that computes the lower and upper left hull of the left subsegment of a greater DSS aDSS. Note that the so-called left subsegment is bounded on the one hand by the first point of aDSS and on the other hand by the point located at position aPositionBound [Roussillon 2014 : [91]]. More...

template<typename T >
T	power (const T &aVal, const unsigned int exponent)

template<typename T >
T	roundToUpperPowerOfTwo (const T &n)

template<typename T >
T	abs (const T &a)

template<typename T >
T	square (T x)

template<typename T >
T	cube (T x)

template<typename TKSpace , typename TCellContainer , typename CellConstIterator , typename CellMapIteratorPriority >
uint64_t	collapse (CubicalComplex< TKSpace, TCellContainer > &K, CellConstIterator S_itB, CellConstIterator S_itE, const CellMapIteratorPriority &priority, bool hintIsSClosed=false, bool hintIsKClosed=false, bool verbose=false)

template<typename TKSpace , typename TCellContainer , typename BdryCellOutputIterator , typename InnerCellOutputIterator >
void	filterCellsWithinBounds (const CubicalComplex< TKSpace, TCellContainer > &K, const typename TKSpace::Point &kLow, const typename TKSpace::Point &kUp, BdryCellOutputIterator itBdry, InnerCellOutputIterator itInner)

template<typename TObject , typename TKSpace , typename TCellContainer >
std::unique_ptr< TObject >	objectFromSpels (const CubicalComplex< TKSpace, TCellContainer > &C)

template<typename TComplex >
NeighborhoodConfiguration	getSpelNeighborhoodConfigurationOccupancy (const TComplex &input_complex, const typename TComplex::Point &center, const std::unordered_map< typename TComplex::Point, NeighborhoodConfiguration > &mapPointToMask)

DGtal::CountedPtr< boost::dynamic_bitset<> >	loadTable (const std::string &input_filename, const unsigned int known_size, const bool compressed=true)

template<unsigned int dimension = 3>
DGtal::CountedPtr< boost::dynamic_bitset<> >	loadTable (const std::string &input_filename, const bool compressed=true)

template<typename TPoint >
DGtal::CountedPtr< std::unordered_map< TPoint, NeighborhoodConfiguration > >	mapZeroPointNeighborhoodToConfigurationMask ()

template<typename TObject , typename TMap >
void	generateSimplicityTable (const typename TObject::DigitalTopology &dt, TMap &map)

template<typename TVoxelComplex , typename TMap >
void	generateVoxelComplexTable (TMap &map, std::function< bool(const TVoxelComplex &, const typename TVoxelComplex::Cell &) > skelFunction)

template<typename TComplex >
TComplex	asymetricThinningScheme (TComplex &vc, std::function< std::pair< typename TComplex::Cell, typename TComplex::Data >(const typename TComplex::Clique &) > Select, std::function< bool(const TComplex &, const typename TComplex::Cell &) > Skel, bool verbose=false)

template<typename TComplex >
TComplex	persistenceAsymetricThinningScheme (TComplex &vc, std::function< std::pair< typename TComplex::Cell, typename TComplex::Data >(const typename TComplex::Clique &) > Select, std::function< bool(const TComplex &, const typename TComplex::Cell &) > Skel, uint32_t persistence, bool verbose=false)

template<typename TComplex >
std::pair< typename TComplex::Cell, typename TComplex::Data >	selectFirst (const typename TComplex::Clique &clique)

template<typename TComplex >
std::pair< typename TComplex::Cell, typename TComplex::Data >	selectRandom (const typename TComplex::Clique &clique)

template<typename TComplex , typename TRandomGenerator >
std::pair< typename TComplex::Cell, typename TComplex::Data >	selectRandom (const typename TComplex::Clique &clique, TRandomGenerator &gen)

template<typename TDistanceTransform , typename TComplex >
std::pair< typename TComplex::Cell, typename TComplex::Data >	selectMaxValue (const TDistanceTransform &dist_map, const typename TComplex::Clique &clique)

template<typename TComplex >
bool	skelUltimate (const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TComplex >
bool	skelEnd (const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TComplex >
bool	skelSimple (const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TComplex >
bool	skelIsthmus (const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TComplex >
bool	oneIsthmus (const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TComplex >
bool	twoIsthmus (const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TComplex >
bool	skelWithTable (const boost::dynamic_bitset<> &table, const std::unordered_map< typename TComplex::Point, unsigned int > &pointToMaskMap, const TComplex &vc, const typename TComplex::Cell &cell)

template<typename TObject >
bool	isZeroSurface (const TObject &small_obj)

template<typename TObject >
bool	isOneSurface (const TObject &small_obj)

template<typename TObject >
std::vector< TObject >	connectedComponents (const TObject &input_obj, bool verbose)

template<typename TComplex , typename TDistanceTransform = DistanceTransformation<Z3i::Space, Z3i::DigitalSet, ExactPredicateLpSeparableMetric<Z3i::Space, 3>>>
TComplex	thinningVoxelComplex (TComplex &vc, const std::string &skel_type_str, const std::string &skel_select_type_str, const std::string &tables_folder, const int &persistence=0, const TDistanceTransform *distance_transform=nullptr, const bool profile=false, const bool verbose=false)

Detailed Description

functions namespace gathers all DGtal functionsxs.

Function Documentation

◆ abs()

template<typename T >

T DGtal::functions::abs ( const T & a )

Return the absolute value of an instance of type T.

Template Parameters

T	the type of elements to compare (model of boost::LessThanComparable).

Parameters

a	first value

Returns: the absolute value |a|.

Definition at line 116 of file BasicMathFunctions.h.

     {
       BOOST_CONCEPT_ASSERT((boost::LessThanComparable<T>));
       if (a<0) 
         return -a;
       else
         return a;
     }

◆ assignDifference() [1/2]

template<typename Container , bool ordered>

Container& DGtal::functions::assignDifference	(	Container &	S1,
		const Container &	S2
	)

Set difference operation. Updates the set S1 as S1 - S2.

Parameters

[in,out]	S1	an input set, S1 - S2 as output.
[in]	S2	another input set.

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 896 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = ordered 
           || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignDifference( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignDifference().

Referenced by makeDifference(), and DGtal::functions::setops::operator-=().

◆ assignDifference() [2/2]

template<typename Container >

Container& DGtal::functions::assignDifference	(	Container &	S1,
		const Container &	S2
	)

Set difference operation. Updates the set S1 as S1 - S2.

Parameters

[in,out]	S1	an input set, S1 - S2 as output.
[in]	S2	another input set.

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 918 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignDifference( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignDifference().

◆ assignIntersection() [1/2]

template<typename Container , bool ordered>

Container& DGtal::functions::assignIntersection	(	Container &	S1,
		const Container &	S2
	)

Set intersection operation. Updates the set S1 as \( S1 \cap S2 \).

Parameters

[in,out]	S1	an input set, \( S1 \cap S2 \) as output.
[in]	S2	another input set.

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 1082 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = ordered 
           || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignIntersection( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignIntersection().

Referenced by makeIntersection(), and DGtal::functions::setops::operator&=().

◆ assignIntersection() [2/2]

template<typename Container >

Container& DGtal::functions::assignIntersection	(	Container &	S1,
		const Container &	S2
	)

Set intersection operation. Updates the set S1 as \( S1 \cap S2 \).

Parameters

[in,out]	S1	an input set, \( S1 \cap S2 \) as output.
[in]	S2	another input set.

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 1104 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignIntersection( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignIntersection().

◆ assignSymmetricDifference() [1/2]

template<typename Container , bool ordered>

Container& DGtal::functions::assignSymmetricDifference	(	Container &	S1,
		const Container &	S2
	)

Set symmetric difference operation. Updates the set S1 as \( S1 \Delta S2 \).

Parameters

[in,out]	S1	an input set, \( S1 \Delta S2 \) as output.
[in]	S2	another input set.

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 1176 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = ordered 
           || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignSymmetricDifference( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignSymmetricDifference().

Referenced by makeSymmetricDifference(), and DGtal::functions::setops::operator^=().

◆ assignSymmetricDifference() [2/2]

template<typename Container >

Container& DGtal::functions::assignSymmetricDifference	(	Container &	S1,
		const Container &	S2
	)

Set symmetric difference operation. Updates the set S1 as \( S1 \Delta S2 \).

Parameters

[in,out]	S1	an input set, \( S1 \Delta S2 \) as output.
[in]	S2	another input set.

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 1198 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignSymmetricDifference( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignSymmetricDifference().

◆ assignUnion() [1/2]

template<typename Container , bool ordered>

Container& DGtal::functions::assignUnion	(	Container &	S1,
		const Container &	S2
	)

Set union operation. Updates the set S1 as \( S1 \cup S2 \).

Parameters

[in,out]	S1	an input set, \( S1 \cup S2 \) as output.
[in]	S2	another input set.

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 990 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = ordered 
           || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignUnion( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignUnion().

Referenced by makeUnion(), and DGtal::functions::setops::operator|=().

◆ assignUnion() [2/2]

template<typename Container >

Container& DGtal::functions::assignUnion	(	Container &	S1,
		const Container &	S2
	)

Set union operation. Updates the set S1 as \( S1 \cup S2 \).

Parameters

[in,out]	S1	an input set, \( S1 \cup S2 \) as output.
[in]	S2	another input set.

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 1012 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isAssociative = IsAssociativeContainer< Container >::value );
       BOOST_STATIC_CONSTANT
         ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
  
       return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
         ::assignUnion( S1, S2 );
     }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::assignUnion().

◆ asymetricThinningScheme()

template<typename TComplex >

TComplex DGtal::functions::asymetricThinningScheme	(	TComplex &	vc,
		std::function< std::pair< typename TComplex::Cell, typename TComplex::Data >(const typename TComplex::Clique &) >	Select,
		std::function< bool(const TComplex &, const typename TComplex::Cell &) >	Skel,
		bool	verbose = `false`
	)

◆ checkAll()

template<typename TCoordinate , typename TInteger , unsigned short adjacency>

bool DGtal::functions::checkAll ( const ArithmeticalDSS< TCoordinate, TInteger, adjacency > & aDSS )

Checks whether a DSS is valid or not. NB: in logarithmic time (in order to check that a and b are relatively prime)

Parameters

aDSS any DSS

Returns: 'true' if valid, 'false' otherwise.

◆ checkOnePoint()

template<typename TCoordinate , typename TInteger , unsigned short adjacency>

bool DGtal::functions::checkOnePoint ( const ArithmeticalDSS< TCoordinate, TInteger, adjacency > & aDSS )

Checks the validity of the DSS when it contains only one point.

Parameters

aDSS any DSS

Precondition: the DSS contains only one point

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

◆ checkPointsPosition()

template<typename TCoordinate , typename TInteger , unsigned short adjacency>

bool DGtal::functions::checkPointsPosition ( const ArithmeticalDSS< TCoordinate, TInteger, adjacency > & aDSS )

Checks that the difference between two extremal upper (resp. lower) leaning points is equal to the direction vector (a,b) scaled by an integer. Checks that there is no pattern between end points and extremal leaning points.

Parameters

aDSS any DSS

Precondition: the DSS contains more than one point, ie a and b are not both null.

Returns: 'true' if ok, 'false' otherwise.

◆ checkPointsRemainder()

template<typename TCoordinate , typename TInteger , unsigned short adjacency>

bool DGtal::functions::checkPointsRemainder ( const ArithmeticalDSS< TCoordinate, TInteger, adjacency > & aDSS )

Checks the consistency between the parameters and the leaning points: first and last upper leaning points should have a remainder equal to mu while firsta and last lower leaning points should have a remainder equal to mu + omega - 1. Moreover, front and back points should have a remainder lying within the range [mu, mu+omega[.

Parameters

aDSS any DSS

Precondition: the DSS contains more than one point, ie a and b are not both null.

Returns: 'true' if this property is fulfilled, 'false' otherwise.

◆ collapse()

template<typename TKSpace , typename TCellContainer , typename CellConstIterator , typename CellMapIteratorPriority >

uint64_t DGtal::functions::collapse	(	CubicalComplex< TKSpace, TCellContainer > &	K,
		CellConstIterator	S_itB,
		CellConstIterator	S_itE,
		const CellMapIteratorPriority &	priority,
		bool	hintIsSClosed = `false`,
		bool	hintIsKClosed = `false`,
		bool	verbose = `false`
	)

Collapse a user-specified part of complex K, collapsing cells following priority [priority], in a decreasing sequence until no more collapse is feasible. The range [S_itb,S_itE) provides the starting cells, generally (but not compulsory) maximal cells. The resulting complex is guaranteed to keep the same homotopy type (a kind of topology equivalence).

Note: Cells whose data has been marked as FIXED are not removed.; Only cells that are in the closure of [S_itb,S_itE) may be removed, and only if they are not marked as FIXED.

Advanced:: If you use a DefaultCellMapIteratorPriority object as priority, then the VALUE part of each cell data defines the priority (the highest value the soonest are these cells collapsed). You may thus fill these cell values before calling this method.

Template Parameters

TKSpace	the digital space in which lives the cubical complex.
TCellContainer	the associative container used to store cells within the cubical complex.
CellConstIterator	any forward const iterator on Cell.
CellMapIteratorPriority	any type defining a method 'bool operator()( const Cell&, const Cell&) const'. Defines the order in which cells are collapsed.

See also: DefaultCellMapIteratorPriority

Parameters

[in,out]	K	the complex that is collapsed.
	S_itB	the start of a range of cells which is included in [K].
	S_itE	the end of a range of cells which is included in [K].
	priority	the object that assign a priority to each cell.
	hintIsSClosed	indicates if [S_itb,S_ite) is a closed set (faster in this case).
	hintIsKClosed	indicates that complex K is closed.
	verbose	outputs some information during processing when 'true'.

Returns: the number of cells removed from complex K.

See also: topology/cubical-complex-collapse.cpp

◆ connectedComponents()

template<typename TObject >

std::vector< TObject > DGtal::functions::connectedComponents	(	const TObject &	input_obj,
		bool	verbose
	)

Get all connected components of the input object.

Template Parameters

TObject Object Type

Parameters

input_obj	input object
verbose	flag to be verbose at execution

Returns: vector of TObject containing the different connected components of the object.

See also: ObjectBoostGraphInterface.h

◆ cube()

template<typename T >

T DGtal::functions::cube ( T x )

inline

Returns the value x * x * x

Template Parameters

T	a type with the multiply operator.

Parameters

x any value

Returns: the value x * x * x

Definition at line 144 of file BasicMathFunctions.h.

145 { return x * x * x; }

◆ filterCellsWithinBounds()

template<typename TKSpace , typename TCellContainer , typename BdryCellOutputIterator , typename InnerCellOutputIterator >

void DGtal::functions::filterCellsWithinBounds	(	const CubicalComplex< TKSpace, TCellContainer > &	K,
		const typename TKSpace::Point &	kLow,
		const typename TKSpace::Point &	kUp,
		BdryCellOutputIterator	itBdry,
		InnerCellOutputIterator	itInner
	)

Computes the cells of the given complex K that lies on the boundary or inside the parallelepiped specified by bounds kLow and kUp.

Template Parameters

TKSpace	the digital space in which lives the cubical complex.
TCellContainer	the associative container used to store cells within the cubical complex.
BdryCellOutputIterator	any output iterator on TCubicalComplex::Cell.
InnerCellOutputIterator	any output iterator on TCubicalComplex::Cell.

Parameters

[in]	K	any cubical complex.
[in]	kLow	any Khalimsky coordinate representing the lowest possible cell.
[in]	kUp	any Khalimsky coordinate representing the uppermost possible cell.
[in,out]	itBdry	An output iterator on Cell that outputs all the cells of K that lie on the boundary of the parallelepiped specified by bounds kLow and kUp.
[in,out]	itInner	An output iterator on Cell that outputs all the cells of K that lie in the interior of the parallelepiped specified by bounds kLow and kUp.

Note: Complexity is linear in the number of cells of K (but the constant is also linear in the dimension of K).

◆ generateSimplicityTable()

template<typename TObject , typename TMap >

void DGtal::functions::generateSimplicityTable	(	const typename TObject::DigitalTopology &	dt,
		TMap &	map
	)

Given a digital topology dt, generates tables that tells if the central point is simple for the specified configuration. The configuration is determined by a sequence of bits, the first bit for the point in the neighborhood, the second bit for the second point, etc. When set to one, the point is in the neighborhood.

Template Parameters

TObject	the type of object whose simpleness we wish to precompute. Includes the topology.
TMap	the type used to store the mapping configuration -> bool.

Parameters

dt	an instance of the digital topology.
map	(modified) the mapping configuration -> bool.

Definition at line 71 of file NeighborhoodTablesGenerators.h.

   {
     typedef typename TObject::DigitalSet DigitalSet;
     typedef typename TObject::Point Point;
     typedef typename DigitalSet::Domain Domain;
     typedef typename Domain::ConstIterator DomainConstIterator;
  
     Point p1 = Point::diagonal( -1 );
     Point p2 = Point::diagonal(  1 );
     Point c = Point::diagonal( 0 );
     Domain domain( p1, p2 );
     DigitalSet shapeSet( domain );
     TObject shape( dt, shapeSet );
     unsigned int k = 0;
     for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it )
       if ( *it != c ) ++k;
     ASSERT( ( k < 32 )
         && "[generateSimplicityTable] number of configurations is too high." );
     unsigned int nbCfg = 1 << k;
     for ( NeighborhoodConfiguration cfg = 0; cfg < nbCfg; ++cfg )
     {
       if ( ( cfg % 1000 ) == 0 )
       {
         trace.progressBar( (double) cfg, (double) nbCfg );
       }
       shape.pointSet().clear();
       shape.pointSet().insert( c );
       NeighborhoodConfiguration mask = 1;
       for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it )
       {
         if ( *it != c )
         {
           if ( cfg & mask ) shape.pointSet().insert( *it );
           mask <<= 1;
         }
       }
       bool simple = shape.isSimple( c );
       map[ cfg ] = simple;
     }
   }

References domain, DGtal::Trace::progressBar(), and DGtal::trace.

◆ generateVoxelComplexTable()

template<typename TVoxelComplex , typename TMap >

void DGtal::functions::generateVoxelComplexTable	(	TMap &	map,
		std::function< bool(const TVoxelComplex &, const typename TVoxelComplex::Cell &) >	skelFunction
	)

Generates a table mapping the number of configuration of a 26 topology voxel neighborhood, and the boolean result of a predicate function applied to the central point for each configuration. The configuration is determined by a sequence of bits, the first bit for the point in the neighborhood, the second bit for the second point, etc. When set to one, the point is in the neighborhood.

Template Parameters

TVoxelComplex	the type of the VoxelComplex whose property we wish to precompute.
TMap	the type used to store the mapping configuration -> bool.

Parameters

map	(modified) the mapping configuration -> bool.
skelFunction	a predicate function related to the property we want to check.

Definition at line 132 of file NeighborhoodTablesGenerators.h.

     {
       using Domain = DGtal::Z3i::Domain;
       using Point = typename Domain::Point ;
       using DigitalSet = DigitalSetByAssociativeContainer<
         Domain, std::unordered_set< Point > >;
       using DomainConstIterator = typename Domain::ConstIterator ;
       using KSpace = typename TVoxelComplex::KSpace;
  
       Point p1 = Point::diagonal( -1 );
       Point p2 = Point::diagonal(  1 );
       Point c = Point::diagonal( 0 );
       Domain domain( p1, p2 );
       DigitalSet shapeSet( domain );
       unsigned int k = 0;
       for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it )
         if ( *it != c ) ++k;
       ASSERT( ( k < 32 )
           && "[generateVoxelComplexTable] number of configurations is too high." );
       unsigned int nbCfg = 1 << k;
  
       KSpace ks;
       // Pad KSpace domain.
       ks.init(domain.lowerBound() + Point::diagonal( -1 ) ,
           domain.upperBound() + Point::diagonal( 1 ),
           true);
       TVoxelComplex vc(ks);
       vc.construct(shapeSet);
       for ( unsigned int cfg = 0; cfg < nbCfg; ++cfg ){
         if ( ( cfg % 1000 ) == 0 )
           trace.progressBar( (double) cfg, (double) nbCfg );
         vc.clear();
         vc.insertVoxelPoint(c);
         unsigned int mask = 1;
         for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it ){
           if ( *it != c ) {
             if ( cfg & mask ) vc.insertVoxelPoint( *it );
             mask <<= 1;
           }
         }
         const auto &kcell = vc.space().uSpel(c);
         bool predicate_output = skelFunction(vc, kcell);
         map[ cfg ] = predicate_output;
       }
     }

References domain, DGtal::KhalimskySpaceND< dim, TInteger >::init(), DGtal::Trace::progressBar(), and DGtal::trace.

◆ getSpelNeighborhoodConfigurationOccupancy()

template<typename TComplex >

NeighborhoodConfiguration DGtal::functions::getSpelNeighborhoodConfigurationOccupancy	(	const TComplex &	input_complex,
		const typename TComplex::Point &	center,
		const std::unordered_map< typename TComplex::Point, NeighborhoodConfiguration > &	mapPointToMask
	)

Get the occupancy configuration of the neighborhood of a point in a cubical complex. The neighborhood size is considered 3^D for dimension D of the point (ie 3x3x3 cube for 3D point).

Template Parameters

TComplex Complex type.

Parameters

input_complex	input complex. Used to check what points are occupied.
center	of the neighborhood. It doesn't matter if center belongs or not to input_complex.
mapPointToMask	map[Point]->configuration, where Point is inside a DxD cube centered in {0,0,..} in ND.

Note: This doesn't work with KSpace coordinates, these must be converted to digital coordinates before:

See also: KhalimskySpaceND::uCoords(3,cell); mapPointToBitMask

Returns: bit configuration

◆ isEqual() [1/2]

template<typename Container , bool ordered>

bool DGtal::functions::isEqual	(	const Container &	S1,
		const Container &	S2
	)

Equality test.

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: true iff S1 is equal to S2 (i.e. S1 is a subset of S2 and S2 is a subset of S1).

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 789 of file SetFunctions.h.

       {
         BOOST_STATIC_ASSERT( IsContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isAssociative = IsAssociativeContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isOrdered = ordered 
             || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
         
         return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
           ::isEqual( S1, S2 );
       }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::isEqual().

Referenced by DGtal::operator!=(), and DGtal::operator==().

◆ isEqual() [2/2]

template<typename Container >

bool DGtal::functions::isEqual	(	const Container &	S1,
		const Container &	S2
	)

Equality test.

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: true iff S1 is equal to S2 (i.e. S1 is a subset of S2 and S2 is a subset of S1).

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 815 of file SetFunctions.h.

       {
         BOOST_STATIC_ASSERT( IsContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isAssociative = IsAssociativeContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
         
         return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
           ::isEqual( S1, S2 );
       }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::isEqual().

◆ isOneSurface()

template<typename TObject >

bool DGtal::functions::isOneSurface ( const TObject & small_obj )

Check if input object is a simple closed curve. Object must be:

Connected.
Each voxel is a isZeroSurface.

See also: isZeroSurface

Template Parameters

TObject Object Type

Parameters

small_obj input object

Returns: bool

Referenced by TEST_CASE_METHOD().

◆ isSubset() [1/2]

template<typename Container , bool ordered>

bool DGtal::functions::isSubset	(	const Container &	S1,
		const Container &	S2
	)

Inclusion test.

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: true iff S1 is a subset of S2.

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 845 of file SetFunctions.h.

       {
         BOOST_STATIC_ASSERT( IsContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isAssociative = IsAssociativeContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isOrdered = ordered 
             || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
         
         return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
           ::isSubset( S1, S2 );
       }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::isSubset().

Referenced by DGtal::operator<=(), and DGtal::operator>=().

◆ isSubset() [2/2]

template<typename Container >

bool DGtal::functions::isSubset	(	const Container &	S1,
		const Container &	S2
	)

Inclusion test.

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: true iff S1 is a subset of S2.

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 869 of file SetFunctions.h.

       {
         BOOST_STATIC_ASSERT( IsContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isAssociative = IsAssociativeContainer< Container >::value );
         BOOST_STATIC_CONSTANT
           ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
         
         return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
           ::isSubset( S1, S2 );
       }

References DGtal::detail::SetFunctionsImpl< Container, associative, ordered >::isSubset().

◆ isZeroSurface()

template<typename TObject >

bool DGtal::functions::isZeroSurface ( const TObject & small_obj )

Check if the object contains, exclusively, two disconnected voxels.

See also: Object::computeConnectedness

Template Parameters

TObject Object Type

Parameters

small_obj input object

Returns: bool

Referenced by TEST_CASE_METHOD().

◆ loadTable() [1/2]

template<unsigned int dimension = 3>

DGtal::CountedPtr< boost::dynamic_bitset<> > DGtal::functions::loadTable	(	const std::string &	input_filename,
		const bool	compressed = `true`
	)

inline

Load existing look up table existing in file_name, precalculated tables can be accessed including the header: "DGtal/topology/tables/NeighborhoodTables.h"

Template Parameters

dimension of the space input_filename table refers. 2 or 3

Parameters

input_filename	plain text containing the bool table.
compressed	true if table to read has been compressed with zlib.

Returns: smart ptr of map[neighbor_configuration] -> bool

See also: NeighborhoodConfigurations::loadTable

◆ loadTable() [2/2]

DGtal::CountedPtr< boost::dynamic_bitset<> > DGtal::functions::loadTable	(	const std::string &	input_filename,
		const unsigned int	known_size,
		const bool	compressed = `true`
	)

inline

Load existing look up table existing in file_name, precalculated tables can be accessed including the header: "DGtal/topology/tables/NeighborhoodTables.h"

Parameters

input_filename	plain text containing the bool table.
known_size	of the bitset, for 2D = 256 (2^8), 3D = 67108864 (2^26)
compressed	true if table to read has been compressed with zlib.

Returns: smart ptr of map[neighbor_configuration] -> bool

Note: The tables were calculated using the generateTableXXX examples. Compressed files of the tables are distributed in the source code. At build or install time, the header "DGtal/topology/tables/NeighborhoodTables.h" is generated. It has const strings variables with the file names of the tables.

Referenced by SCENARIO(), TEST_CASE_METHOD(), and thinningVoxelComplex().

◆ makeDifference() [1/2]

template<typename Container , bool ordered>

Container DGtal::functions::makeDifference	(	const Container &	S1,
		const Container &	S2
	)

Set difference operation. Returns the difference of S1 - S2.

Parameters

[in]	S1	an input set
[in]	S2	another input set.

Returns: the set S1 - S2.

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 946 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignDifference<Container, ordered>( S, S2 );
       return S;
     }

Referenced by DGtal::functions::setops::operator-().

◆ makeDifference() [2/2]

template<typename Container >

Container DGtal::functions::makeDifference	(	const Container &	S1,
		const Container &	S2
	)

Set difference operation. Returns the difference of S1 - S2.

Parameters

[in]	S1	an input set
[in]	S2	another input set.

Returns: the set S1 - S2.

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 965 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignDifference( S, S2 );
       return S;
     }

References assignDifference().

◆ makeIntersection() [1/2]

template<typename Container , bool ordered>

Container DGtal::functions::makeIntersection	(	const Container &	S1,
		const Container &	S2
	)

Set intersection operation. Returns the set \( S1 \cap S2 \).

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: the set \( S1 \cap S2 \).

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 1131 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignIntersection<Container, ordered>( S, S2 );
       return S;
     }

Referenced by DGtal::functions::setops::operator&().

◆ makeIntersection() [2/2]

template<typename Container >

Container DGtal::functions::makeIntersection	(	const Container &	S1,
		const Container &	S2
	)

Set intersection operation. Returns the set \( S1 \cap S2 \).

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: the set \( S1 \cap S2 \).

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 1149 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignIntersection( S, S2 );
       return S;
     }

References assignIntersection().

◆ makeSymmetricDifference() [1/2]

template<typename Container , bool ordered>

Container DGtal::functions::makeSymmetricDifference	(	const Container &	S1,
		const Container &	S2
	)

Set symmetric difference operation. Returns the set \( S1 \Delta S2 \).

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: the set \( S1 \Delta S2 \).

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 1225 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignSymmetricDifference<Container, ordered>( S, S2 );
       return S;
     }

Referenced by DGtal::functions::setops::operator^().

◆ makeSymmetricDifference() [2/2]

template<typename Container >

Container DGtal::functions::makeSymmetricDifference	(	const Container &	S1,
		const Container &	S2
	)

Set symmetric difference operation. Returns the set \( S1 \Delta S2 \).

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: the set \( S1 \Delta S2 \).

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 1243 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignSymmetricDifference( S, S2 );
       return S;
     }

References assignSymmetricDifference().

◆ makeUnion() [1/2]

template<typename Container , bool ordered>

Container DGtal::functions::makeUnion	(	const Container &	S1,
		const Container &	S2
	)

Set union operation. Returns the set \( S1 \cup S2 \).

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: the set \( S1 \cup S2 \).

Template Parameters

Container	any type of container (even a sequence, a set, an unordered_set, a map, etc).
ordered	when 'true', the user indicates that values are ordered (e.g. a sorted vector), otherwise, depending on the container type, the compiler may still determine that values are ordered.

Definition at line 1039 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignUnion<Container, ordered>( S, S2 );
       return S;
     }

Referenced by DGtal::functions::setops::operator|().

◆ makeUnion() [2/2]

template<typename Container >

Container DGtal::functions::makeUnion	(	const Container &	S1,
		const Container &	S2
	)

Set union operation. Returns the set \( S1 \cup S2 \).

Parameters

[in]	S1	an input set.
[in]	S2	another input set.

Returns: the set \( S1 \cup S2 \).

Template Parameters

Container any type of container (even a sequence, a set, an unordered_set, a map, etc).

Definition at line 1057 of file SetFunctions.h.

     {
       BOOST_STATIC_ASSERT( IsContainer< Container >::value );
       Container S( S1 );
       assignUnion( S, S2 );
       return S;
     }

References assignUnion().

◆ mapZeroPointNeighborhoodToConfigurationMask()

template<typename TPoint >

DGtal::CountedPtr< std::unordered_map<TPoint, NeighborhoodConfiguration > > DGtal::functions::mapZeroPointNeighborhoodToConfigurationMask ( )

inline

Maps any point in the neighborhood of point Zero (0,..,0) to its corresponding configuration bit mask. This is a helper to use with tables. The order of the configuration is lexicographic, starting in {-1, -1, ...}.

Note: the neighborhood is considered to be all points p which ||p-zero|| <= 1

Example: Point{ -1, -1, -1 } = 1; // corresponding to mask x x 0000 0001 Point{ 0, -1, -1 } = 2; // corresponding to mask x x 0000 0010 Point{ 1, 1, 1 } = 2^26; // x 0010 x x x x x x

Note: NeighborhoodConfiguration is type uint 32 bits, so the max dimension supported is 3.

See also: HyperRectDomain_Iterator::nextLexicographicOrder; testNeighborhoodConfigurations.cpp shows the complete mapping.

Template Parameters

TPoint type of point to create map and input the desired dimension.

Returns: map[Point]->configuration smart pointer.

◆ objectFromSpels()

template<typename TObject , typename TKSpace , typename TCellContainer >

std::unique_ptr<TObject> DGtal::functions::objectFromSpels ( const CubicalComplex< TKSpace, TCellContainer > & C )

Create object from the spels in the complex.

User has to provide a 3D TObject type with its associated DigitalSet and DigitalTopology.

Given a dimension n, spels are the n-cells, equivalently, spels are the grid-points in Z^n.

Template Parameters

TObject	with its associdated DigitalSet and DigitalTopology
TKSpace	kspace type of the input CubicalComplex.
TCellContainer	cell container type of the input CubicalComplex

Parameters

C	input CubicalComplex

Returns: unique_ptr of created object with the pointset containing the spels of the complex.

◆ oneIsthmus()

template<typename TComplex >

bool DGtal::functions::oneIsthmus	(	const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Check if input cell is a 1-isthmus. A voxel is a 1-isthmus if, after a thinning, its proper neighborhood is made only by two voxels, ie, it is a 0-Surface isZeroSurface.

See also: isZeroSurface; Object::properNeighborhood

Template Parameters

TComplex VoxelComplex.

Parameters

vc	input complex.
cell	apply function on input cell.

Returns: bool

Referenced by TEST_CASE_METHOD().

◆ persistenceAsymetricThinningScheme()

template<typename TComplex >

TComplex DGtal::functions::persistenceAsymetricThinningScheme	(	TComplex &	vc,
		std::function< std::pair< typename TComplex::Cell, typename TComplex::Data >(const typename TComplex::Clique &) >	Select,
		std::function< bool(const TComplex &, const typename TComplex::Cell &) >	Skel,
		uint32_t	persistence,
		bool	verbose = `false`
	)

◆ power()

template<typename T >

T DGtal::functions::power	(	const T &	aVal,
		const unsigned int	exponent
	)

Compute exponentiation by squaring of a scalar aVal of type T by the exponent exponent (unsigned int). The computation is done in \( O(\log(exponent))\) multiplications.

Note: This function is better than std::pow on unsigned int exponents and integer value type since it performs exact computations (no cast to float or doubles).

Parameters

aVal	the value
exponent	the exponent

Template Parameters

T	scalar value type (must have '*' operator).

Returns: aVal^exponent

See also: square, cube

Definition at line 73 of file BasicMathFunctions.h.

     {
       unsigned int q=exponent;
       T p(aVal);
       
       if (exponent == 0) { return 1;    }
       
       T result = NumberTraits<T>::ONE;
       while (q != 0) 
         {
           if (q % 2 == 1) {    // q is odd
             result *= p;
             q--;
           }
           p *= p;
           q /= 2;
         }
       return result;
     }

◆ reversedSmartCH() [1/2]

template<typename DSS , typename OutputIterator >

DSS::Vector DGtal::functions::reversedSmartCH	(	const DSS &	aDSS,
		const typename DSS::Position &	aPositionBound,
		OutputIterator	uIto,
		OutputIterator	lIto
	)

inline

Procedure that computes the lower and upper left hull of the left subsegment of a greater DSS aDSS. Note that the so-called left subsegment is bounded on the one hand by the first point of aDSS and on the other hand by the point located at position aPositionBound [Roussillon 2014 : [91]].

Parameters

aDSS	bounding DSS
aPositionBound	position of the last point of the subsegment (should be located after the first point of aDSS).
uIto	output iterator used to store the vertices of the upper convex hull
lIto	output iterator used to store the vertices of the lower convex hull

Template Parameters

DSS	a model of arithmetical DSS
OutputIterator	a model of output iterator

Returns: last direction vector, ie. the rational slope of minimal denominator

◆ reversedSmartCH() [2/2]

template<typename PointVector , typename Position , typename PositionFunctor , typename OutputIterator >

PointVector DGtal::functions::reversedSmartCH	(	PointVector	U,
		PointVector	L,
		PointVector	V,
		const Position &	aFirstPosition,
		const Position &	aLastPosition,
		const PositionFunctor &	aPositionFunctor,
		OutputIterator	uIto,
		OutputIterator	lIto
	)

inline

Procedure that computes the lower and upper left hull of the left subsegment of a greater DSS characterized by the first upper leaning point U, the first positive Bezout point L and its direction vector V. Note that the so-called left subsegment is bounded on the one hand by the first point of the DSS located at aFirstPosition and on the other hand by the point located at position aLastPosition.

Parameters

U	last upper convex hull vertex
L	last lower convex hull vertex
V	last valid Bezout vector (main direction vector)
aFirstPosition	position of the first point of the subsegment
aLastPosition	position of the last point of the subsegment
aPositionFunctor	position functor, which returns the position of any given point/vector
uIto	output iterator used to store the vertices of the upper convex hull
lIto	output iterator used to store the vertices of the lower convex hull

Template Parameters

PointVector	a model of 2d point/vector
Position	a model of integer for the position of the point in the bounding DSS
PositionFunctor	a model of unary functor that returns the position of a point/vector
OutputIterator	a model of output iterator

Returns: last direction vector, ie. the rational slope of minimal denominator

Referenced by basicTest2(), and reversedSmartCHSubsegment().

◆ roundToUpperPowerOfTwo()

template<typename T >

T DGtal::functions::roundToUpperPowerOfTwo ( const T & n )

Compute the next higher power of two of the given argument n of type T.

Template Parameters

T	the type of the element T

Parameters

n	an element of type T (casted to unsigned integer).

Returns: the next higher power of two.

Definition at line 102 of file BasicMathFunctions.h.

                                          {
       return (T)  1 << (1+DGtal::Bits::mostSignificantBit( (unsigned int) n-1 ) );
     }

References DGtal::Bits::mostSignificantBit().

Referenced by DGtal::Viewer3D< TSpace, TKSpace >::GLTextureImage::GLTextureImage().

◆ selectFirst()

template<typename TComplex >

std::pair<typename TComplex::Cell, typename TComplex::Data> DGtal::functions::selectFirst ( const typename TComplex::Clique & clique )

Select first voxel of input clique.

Template Parameters

TComplex input CubicalComplex

Parameters

clique from where cell is chosen.

Returns: first voxel of clique.

◆ selectMaxValue()

template<typename TDistanceTransform , typename TComplex >

std::pair<typename TComplex::Cell, typename TComplex::Data> DGtal::functions::selectMaxValue	(	const TDistanceTransform &	dist_map,
		const typename TComplex::Clique &	clique
	)

Select cell from clique that has max value looking at the input dist_map. The points in the dist_map and in the clique must refer to the same position.

If you need to have a std::function<bool(const Clique &)> signature (for using it in thinning algorithms), use a lambda: subsitute skelRandom (for example) for:

auto selectDistMax =
[&dist_map](const Clique & clique){
    return selectMaxDistance<TDistMap, TComplex>(dist_map, clique);
}

Template Parameters

TDistanceTransform	Container type for the distance map.
TComplex	input CubicalComplex

Parameters

dist_map	container holding the values.
clique	from where cell is chosen.

Returns: cell from input clique with highest value.

See also: DistanceTransformation.h

◆ selectRandom() [1/2]

template<typename TComplex >

std::pair<typename TComplex::Cell, typename TComplex::Data> DGtal::functions::selectRandom ( const typename TComplex::Clique & clique )

Select random voxel from input clique.

Template Parameters

TComplex input CubicalComplex

Parameters

clique from where cell is chosen.

Returns: random voxel from input clique.

◆ selectRandom() [2/2]

template<typename TComplex , typename TRandomGenerator >

std::pair<typename TComplex::Cell, typename TComplex::Data> DGtal::functions::selectRandom	(	const typename TComplex::Clique &	clique,
		TRandomGenerator &	gen
	)

Select random voxel from input clique.

Template Parameters

TComplex	CubicalComplex
TRandomGenerator	RandomGenerator

Parameters

clique	from where cell is chosen
gen	random generator

Returns: random voxel from input clique.

◆ skelEnd()

template<typename TComplex >

bool DGtal::functions::skelEnd	(	const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Check if input cell only has one neighbor, using Object::topology.

Template Parameters

TComplex VoxelComplex

Parameters

vc	input voxel complex.
cell	c apply function on this voxel cell.

Returns: true if voxel cell only has neighbor.

◆ skelIsthmus()

template<typename TComplex >

bool DGtal::functions::skelIsthmus	(	const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Check if input cell is a 1 or 2 Isthmus.

Template Parameters

TComplex VoxelComplex.

Parameters

vc	input complex.
cell	apply function on input cell.

Returns: oneIsthmus || twoIsthmus

See also: oneIsthmus; twoIsthmus

Referenced by TEST_CASE_METHOD().

◆ skelSimple()

template<typename TComplex >

bool DGtal::functions::skelSimple	(	const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Check if input cell is simple using VoxelComplex::isSimple interface to Object::isSimple.

See also: VoxelComplex::isSimple; Object::isSimple

Template Parameters

TComplex VoxelComplex.

Parameters

vc	input complex.
cell	apply function on input cell.

Returns: true if voxel is simple.

◆ skelUltimate()

template<typename TComplex >

bool DGtal::functions::skelUltimate	(	const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Always returns false. Used in thinning schemes to calculate an ultimate skeleton. An ultimate skeleton only keeps voxels that don't change the topology.

Note: The number of cells of a thinning using this function is the same as the number of connected components of an object.

See also: asymetricThinningScheme

Template Parameters

TComplex VoxelComplex

Parameters

vc	input voxel complex.
cell	c apply function on this voxel cell.

Returns: always false.

◆ skelWithTable()

template<typename TComplex >

bool DGtal::functions::skelWithTable	(	const boost::dynamic_bitset<> &	table,
		const std::unordered_map< typename TComplex::Point, unsigned int > &	pointToMaskMap,
		const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Generic predicate to use external tables[configuration]->bool with skel functions. Can be adapted to any table using lambdas.

See also: LookUpTableFunctions.h; tests/topology/testVoxelComplex.h

If you need to have a std::function<bool(const Complex & vc, const Cell & c )> signature (for using it in thinning algorithms), use a lambda to capture values: subsitute skelIsthmus (for example) for:

auto skelWithTableIsthmus =
[&table, &pointToMaskMap](const Complex & vc, const Cell & cell){
    return skelWithTable<TComplex>(table, pointToMaskMap, vc, cell);
}

Template Parameters

TComplex input CubicalComplex type.

Parameters

table [configuration]->bool

See also: VoxelComplex::loadTable; LookUpTableFunctions.h::loadTable

Parameters

pointToMaskMap map[neighborhood points] to a bit mask. Used to get the neighborhood configuration.

See also: VoxelComplex::pointToMask; LookUpTableFunctions.h::mapPointToBitMask

Parameters

vc	input complex.
cell	input cell, center from where the neighborhood [configuration] will be checked. Note that only neighborhood are checked to belong to the complex, not the input cell.

Returns: bool from selected table[configuration].

Referenced by TEST_CASE_METHOD(), and thinningVoxelComplex().

◆ smartCH() [1/2]

template<typename DSL , typename OutputIterator >

DSL::Vector DGtal::functions::smartCH	(	const DSL &	aDSL,
		const typename DSL::Point &	aFirstPoint,
		const typename DSL::Position &	aLength,
		OutputIterator	uIto,
		OutputIterator	lIto
	)

inline

Procedure that computes the lower and upper left hull of a DSS of first point aFirstPoint, length aLength, contained in a DSL aDSL [Roussillon 2014 : [91]].

Parameters

aDSL	bounding DSL
aFirstPoint	first point of the DSS
aLength	(strictly positive) length of the DSS
uIto	output iterator used to store the vertices of the upper convex hull
lIto	output iterator used to store the vertices of the lower convex hull

Returns: last direction vector, ie. the rational slope of minimal denominator

Template Parameters

DSL	a model of arithmetical DSL
OutputIterator	a model of output iterator

◆ smartCH() [2/2]

template<typename PointVector , typename Coordinate , typename Position , typename PositionFunctor , typename OutputIterator >

PointVector DGtal::functions::smartCH	(	const PointVector &	aFirstPoint,
		const Coordinate &	aRemainderBound,
		const Position &	aPositionBound,
		const PointVector &	aStep,
		const Coordinate &	aRStep,
		const PointVector &	aShift,
		const Coordinate &	aRShift,
		const PositionFunctor &	aPositionFunctor,
		OutputIterator	uIto,
		OutputIterator	lIto
	)

inline

Procedure that computes the lower and upper left hull of a DSS of first point aFirstPoint, length aPositionBound, contained in a digital straight line described by aRStep, aRShift and aRemainderBound.

Parameters

aFirstPoint	first point of the DSS
aRemainderBound	difference between the intercept mu of the bounding DSL and the remainder of the first point.
aPositionBound	(strictly positive) length of the DSS
aStep	first step of the DSL
aRStep	remainder of the first step, ie. parameter \( a \) of the bounding DSL
aShift	shift vector of the DSL
aRShift	remainder of the shift vector, ie. parameter \( omega \) of the bounding DSL.
aPositionFunctor	position functor, which returns the position of any given point/vector
uIto	output iterator used to store the vertices of the upper convex hull
lIto	output iterator used to store the vertices of the lower convex hull

Returns: last direction vector, ie. the rational slope of minimal denominator of the DSS

Template Parameters

PointVector	a model of 2d point/vector
Coordinate	a model of integer for the coordinates of the point/vector
Position	a model of integer for locating points in the DSS
PositionFunctor	a model of unary functor that returns the position of a point/vector
OutputIterator	a model of output iterator

Referenced by basicTest(), comparisonLeftHull(), and smartCHSubsegment().

◆ smartCHNextVertex()

template<typename Position , typename Coordinate , typename PointVector , typename OutputIterator , typename PositionFunctor , typename TruncationFunctor1 , typename TruncationFunctor2 >

bool DGtal::functions::smartCHNextVertex	(	const Position &	positionBound,
		const Coordinate &	remainderBound,
		PointVector &	X,
		Coordinate &	rX,
		const PointVector &	Y,
		const Coordinate &	rY,
		PointVector &	V,
		Coordinate &	rV,
		OutputIterator	ito,
		const PositionFunctor &	pos,
		const TruncationFunctor1 &	f1,
		const TruncationFunctor2 &	f2
	)

inline

Procedure that computes the next (lower or upper) vertex of the left hull of a DSS.

Parameters

positionBound	position of the last point of the DSS
remainderBound	remainder of the lower leaning points contained in the DSS
X	(returned) last vertex of the considered side
rX	(returned) remainder of X
Y	last vertex of the opposite side
rY	remainder of Y
V	(returned) last direction vector (unimodular with (X - Y))
rV	(returned) remainder of V (not null)
ito	output iterator used to store the new vertex lying on the same side as X
pos	position functor, which returns the position of any given point/vector
f1	first floor function (for the vertex)
f2	second floor function (for the direction vector)

Returns: 'true' if the last vertex of the left hull has been reached, 'false' otherwise.

Template Parameters

Position	a model of integer for locating points in the DSS
PointVector	a model of 2d point/vector
Coordinate	a model of integer for the coordinates of the point/vector
OutputIterator	a model of output iterator
PositionFunctor	a model of unary functor that returns the position of a point/vector
TruncationFunctor1	a model of unary functor that implements an integer division
TruncationFunctor2	a model of unary functor that implements an integer division

◆ smartCHPreviousVertex()

template<typename PointVector , typename Position , typename OutputIterator , typename TruncationFunctor1 , typename TruncationFunctor2 , typename PositionFunctor >

bool DGtal::functions::smartCHPreviousVertex	(	PointVector &	X,
		const PointVector &	Y,
		PointVector &	V,
		const Position &	aFirstPosition,
		const Position &	aLastPosition,
		OutputIterator	ito,
		const PositionFunctor &	pos,
		const TruncationFunctor1 &	f1,
		const TruncationFunctor2 &	f2
	)

inline

Procedure that computes the previous vertex of the left hull of a DSS of main direction vector V , first upper leaning point U and first positive Bezout point L. The computation stops as soon as a computed vertex is located before aLastPosition.

Parameters

X	(returned) first vertex of the left hull on the considered side
Y	first vertex of the left hull on the opposite side
V	(returned) previous direction vector
aFirstPosition	position of the first point of the subsegment
aLastPosition	position of the last point of the subsegment
ito	output iterator used to store the vertices of the left hull lying on the same side as X
pos	position functor, which returns the position of any given point/vector
f1	integer divisor for the direction vector update
f2	integer divisor for the vertex update

Template Parameters

PointVector	a model of couple of coordinates
Position	a model of integer for the position of the points
OutputIterator	a model of output iterator
TruncationFunctor1	a model of functor for the integer division
TruncationFunctor2	a model of functor for the integer division
PositionFunctor	a model of functor returning the position of a point

Returns: 'true' if the last vertex has been reached, 'false' otherwise

◆ square()

template<typename T >

T DGtal::functions::square ( T x )

inline

Returns the value x * x

Template Parameters

T	a type with the multiply operator.

Parameters

x any value

Returns: the value x * x

Definition at line 133 of file BasicMathFunctions.h.

134 { return x * x; }

Referenced by DGtal::functors::HatPointFunction< TPoint, TScalar >::operator()(), and DGtal::functors::BallConstantPointFunction< TPoint, TScalar >::operator()().

◆ thinningVoxelComplex()

template<typename TComplex , typename TDistanceTransform = DistanceTransformation<Z3i::Space, Z3i::DigitalSet, ExactPredicateLpSeparableMetric<Z3i::Space, 3>>>

TComplex DGtal::functions::thinningVoxelComplex	(	TComplex &	vc,
		const std::string &	skel_type_str,
		const std::string &	skel_select_type_str,
		const std::string &	tables_folder,
		const int &	persistence = `0`,
		const TDistanceTransform *	distance_transform = `nullptr`,
		const bool	profile = `false`,
		const bool	verbose = `false`
	)

Definition at line 92 of file VoxelComplexThinning.h.

 {
   if(verbose) {
     using DGtal::trace;
     trace.beginBlock("thin_function parameters:");
     trace.info() << "skel_type_str: " << skel_type_str << std::endl;
     trace.info() << "skel_select_type_str: " << skel_select_type_str << std::endl;
     if(distance_transform) {
       trace.info() << " -- provided distance_transform." << std::endl;
     }
     trace.info() << "persistence: " << persistence << std::endl;
     trace.info() << "profile: " << profile << std::endl;
     trace.info() << "verbose: " << verbose << std::endl;
     trace.info() << "----------" << std::endl;
     trace.endBlock();
   }
  
   // Validate input skel method and skel_select
   const bool skel_type_str_is_valid =
     skel_type_str == "ultimate" ||
     skel_type_str == "end" ||
     skel_type_str == "isthmus" ||
     skel_type_str == "1isthmus" ||
     skel_type_str == "isthmus1";
   if(!skel_type_str_is_valid) {
     throw std::runtime_error("skel_type_str is not valid: \"" + skel_type_str + "\"");
   }
  
   const bool skel_select_type_str_is_valid =
     skel_select_type_str == "first" ||
     skel_select_type_str == "random" ||
     skel_select_type_str == "dmax";
   if(!skel_select_type_str_is_valid) {
     throw std::runtime_error("skel_select_type_str is not valid: \"" + skel_select_type_str + "\"");
   }
   // // No filesystem to check the tables folder exist. If incorrect, it will fail loading the table.
   // const fs::path tables_folder_path{tables_folder};
   // if(!fs::exists(tables_folder_path)) {
   //   throw std::runtime_error("tables_folder " + tables_folder_path.string() +
   //       " doesn't exist in the filesystem.\n"
   //       "tables_folder should point to the folder "
   //       "where DGtal tables are: i.e simplicity_table26_6.zlib");
   // }
  
   // Create a VoxelComplex from the set
   using KSpace = DGtal::Z3i::KSpace;
   using Complex = TComplex;
   using ComplexCell = typename Complex::Cell;
   using ComplexClique = typename Complex::Clique;
   using Point = DGtal::Z3i::Point;
  
   if(verbose) { DGtal::trace.beginBlock("load isthmus table"); }
   boost::dynamic_bitset<> isthmus_table;
   auto &sk = skel_type_str;
   if(sk == "isthmus") {
     const std::string tableIsthmus = tables_folder + "/isthmusicity_table26_6.zlib";
     isthmus_table = *DGtal::functions::loadTable(tableIsthmus);
   } else if(sk == "isthmus1" || sk == "1ishtmus") {
     const std::string tableOneIsthmus = tables_folder + "/isthmusicityOne_table26_6.zlib";
     isthmus_table = *DGtal::functions::loadTable(tableOneIsthmus);
   }
   if(verbose) { DGtal::trace.endBlock(); }
  
  
   // SKEL FUNCTION:
   // Load a look-up-table for the neighborgood of a point
   auto pointMap =
       *DGtal::functions::mapZeroPointNeighborhoodToConfigurationMask<Point>();
   std::function<bool(const Complex&, const ComplexCell&)> Skel;
   if(sk == "ultimate") {
     Skel = DGtal::functions::skelUltimate<Complex>;
   } else if(sk == "end") {
     Skel = DGtal::functions::skelEnd<Complex>;
   // else if (sk == "1is") Skel = oneIsthmus<Complex>;
   // else if (sk == "is") Skel = skelIsthmus<Complex>;
   } else if(sk == "isthmus1" || sk == "1ishtmus") {
     Skel = [&isthmus_table, &pointMap](const Complex& fc,
                                        const ComplexCell& c) {
       return DGtal::functions::skelWithTable(isthmus_table, pointMap, fc, c);
     };
   } else if(sk == "isthmus") {
     Skel = [&isthmus_table, &pointMap](const Complex& fc,
                                        const ComplexCell& c) {
       return DGtal::functions::skelWithTable(isthmus_table, pointMap, fc, c);
     };
   } else {
     throw std::runtime_error("Invalid skel string");
   }
  
   // SELECT FUNCTION
   std::function<std::pair<typename Complex::Cell, typename Complex::Data>(
       const ComplexClique&)>
       Select;
  
   // profile
   auto start = std::chrono::system_clock::now();
  
   // If dmax is chosen, but no distance_transform is provided, create one.
   using DT = TDistanceTransform;
   using DTDigitalSet = typename DT::PointPredicate;
   using DTDigitalSetDomain = typename DTDigitalSet::Domain;
   using Metric = typename DT::SeparableMetric;
   Metric l3;
   auto &sel = skel_select_type_str;
   const bool compute_distance_transform = !distance_transform && sel == "dmax";
   DTDigitalSetDomain vc_domain = compute_distance_transform ?
     DTDigitalSetDomain(vc.space().lowerBound(), vc.space().upperBound()) :
     // dummy domain
     DTDigitalSetDomain(Z3i::Point::zero, Z3i::Point::diagonal(1));
  
   DTDigitalSet image_set = DTDigitalSet(vc_domain);
   if(compute_distance_transform) {
     vc.dumpVoxels(image_set);
   }
   // Create the distance map here (computationally expensive if not dummy).
   DT dist_map(vc_domain, image_set, l3);
   if(compute_distance_transform) {
     distance_transform = &dist_map;
   }
  
   if(sel == "random") {
     Select = DGtal::functions::selectRandom<Complex>;
   } else if(sel == "first") {
     Select = DGtal::functions::selectFirst<Complex>;
   } else if(sel == "dmax") {
     Select = [&distance_transform](const ComplexClique& clique) {
       return selectMaxValue<TDistanceTransform, Complex>(*distance_transform, clique);
       };
   } else {
     throw std::runtime_error("Invalid skel select type");
   }
  
   // Perform the thin/skeletonization
   Complex vc_new(vc.space());
   if(persistence == 0) {
     vc_new = DGtal::functions::asymetricThinningScheme<Complex>(vc, Select, Skel, verbose);
   } else {
     vc_new = DGtal::functions::persistenceAsymetricThinningScheme<Complex>(vc, Select, Skel,
                                                          persistence, verbose);
   }
  
   // profile
   auto end = std::chrono::system_clock::now();
   auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(end - start);
   if(profile) {
     std::cout << "Time elapsed: " << elapsed.count() << std::endl;
   }
  
   return vc_new;
 }

References DGtal::Trace::beginBlock(), DGtal::PointVector< dim, Integer >::diagonal(), DGtal::Trace::endBlock(), DGtal::Trace::info(), loadTable(), skelWithTable(), DGtal::trace, and DGtal::PointVector< dim, Integer >::zero.

◆ twoIsthmus()

template<typename TComplex >

bool DGtal::functions::twoIsthmus	(	const TComplex &	vc,
		const typename TComplex::Cell &	cell
	)

Check if input cell is a 2-isthmus. A voxel is a 2-isthmus if, after a thinning, its proper neighborhood is a 1-Surface isOneSurface.

See also: isOneSurface; Object::properNeighborhood

Template Parameters

TComplex VoxelComplex.

Parameters

vc	input complex.
cell	apply function on input cell.

Returns: bool

Referenced by TEST_CASE_METHOD().

Namespaces

Functions

Detailed Description

Function Documentation

◆ abs()

◆ assignDifference() [1/2]

◆ assignDifference() [2/2]

◆ assignIntersection() [1/2]

◆ assignIntersection() [2/2]

◆ assignSymmetricDifference() [1/2]

◆ assignSymmetricDifference() [2/2]

◆ assignUnion() [1/2]

◆ assignUnion() [2/2]

◆ asymetricThinningScheme()

◆ checkAll()

◆ checkOnePoint()

◆ checkPointsPosition()

◆ checkPointsRemainder()

◆ collapse()

◆ connectedComponents()

◆ cube()

◆ filterCellsWithinBounds()

◆ generateSimplicityTable()

◆ generateVoxelComplexTable()

◆ getSpelNeighborhoodConfigurationOccupancy()

◆ isEqual() [1/2]

◆ isEqual() [2/2]

◆ isOneSurface()

◆ isSubset() [1/2]

◆ isSubset() [2/2]

◆ isZeroSurface()

◆ loadTable() [1/2]

◆ loadTable() [2/2]

◆ makeDifference() [1/2]

◆ makeDifference() [2/2]

◆ makeIntersection() [1/2]

◆ makeIntersection() [2/2]

◆ makeSymmetricDifference() [1/2]

◆ makeSymmetricDifference() [2/2]

◆ makeUnion() [1/2]

◆ makeUnion() [2/2]

◆ mapZeroPointNeighborhoodToConfigurationMask()

◆ objectFromSpels()

◆ oneIsthmus()

◆ persistenceAsymetricThinningScheme()

◆ power()

◆ reversedSmartCH() [1/2]

◆ reversedSmartCH() [2/2]

◆ roundToUpperPowerOfTwo()

◆ selectFirst()

◆ selectMaxValue()

◆ selectRandom() [1/2]

◆ selectRandom() [2/2]

◆ skelEnd()

◆ skelIsthmus()

◆ skelSimple()

◆ skelUltimate()

◆ skelWithTable()

◆ smartCH() [1/2]

◆ smartCH() [2/2]

◆ smartCHNextVertex()

◆ smartCHPreviousVertex()

◆ square()

◆ thinningVoxelComplex()

◆ twoIsthmus()