DGtal::functions Namespace Reference

functions namespace gathers all DGtal functionsxs. More...

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

Functions
template<typename T >
constexpr T	const_pow (T b, unsigned int e)
template<typename T >
constexpr T	const_middle (T K, unsigned int e)
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.
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.
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 : [108]].
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.
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.
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 : [108]].
template<typename TPoint >
DGtal::int64_t	computeAffineDimension (const std::vector< TPoint > &X, const double tolerance=1e-12)
template<typename TPoint >
std::vector< std::size_t >	computeAffineSubset (const std::vector< TPoint > &X, const double tolerance=1e-12)
template<typename TPoint , typename TIndexRange >
static std::vector< std::size_t >	computeAffineSubset (const std::vector< TPoint > &X, const TIndexRange &I, const double tolerance=1e-12)
template<typename TPoint , typename TInputPoint >
void	getAffineBasis (TInputPoint &o, std::vector< TPoint > &basis, const std::vector< TInputPoint > &X, const double tolerance=1e-12)
template<typename TPoint , typename TInputPoint , typename TIndexRange >
static void	getAffineBasis (TInputPoint &o, std::vector< TPoint > &basis, const std::vector< TInputPoint > &X, const TIndexRange &I, const double tolerance=1e-12)
template<typename TPoint >
TPoint	computeIndependentVector (const std::vector< TPoint > &basis, const double tolerance=1e-12)
template<typename TPoint >
static void	getCompleteBasis (std::vector< TPoint > &basis, bool normal_vector, const double tolerance=1e-12)
template<typename TPoint >
static TPoint	computeOrthogonalVectorToBasis (const std::vector< TPoint > &basis)
template<typename TPoint , typename TInputPoint , typename TIndexRange >
static void	getOrthogonalVector (TPoint &w, const std::vector< TInputPoint > &X, const TIndexRange &I, const double tolerance=1e-12)
template<typename TPoint , typename TInputPoint >
static void	getOrthogonalVector (TPoint &w, const std::vector< TInputPoint > &X, const double tolerance=1e-12)
template<typename TPoint , typename TInputPoint >
static void	getOrthogonalLatticeBasis (std::vector< TPoint > &B, const TInputPoint &N, bool shortened=false)
template<typename TPoint >
TPoint	computeSimplifiedVector (const TPoint &v)
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 TComponent >
void	negate (std::vector< TComponent > &V)
template<typename TComponent >
bool	equals (const std::vector< TComponent > &a, const std::vector< TComponent > &b)
template<typename T , typename U >
DGtal::ArithmeticConversionTraits< T, U >::type	dotProduct (const std::vector< T > &a, const std::vector< U > &b)
double	dotProduct (const std::vector< BigInteger > &a, const std::vector< double > &b)
double	dotProduct (const std::vector< double > &a, const std::vector< BigInteger > &b)
template<typename T , typename U >
std::vector< typename DGtal::ArithmeticConversionTraits< T, U >::type >	crossProduct (const std::vector< T > &a, const std::vector< U > &b)
template<typename T , typename U , typename Op2 >
std::vector< typename DGtal::ArithmeticConversionTraits< T, U >::type >	apply (const std::vector< T > &a, const std::vector< U > &b, Op2 op2)
template<typename T >
T	squaredNormL2 (const std::vector< T > &a)
template<typename T >
T	normL1 (const std::vector< T > &a)
template<typename T >
T	normLoo (const std::vector< T > &a)
template<typename TOutput , typename T >
void	getSquaredNormL2 (TOutput &n, const std::vector< T > &a)
template<typename TOutput , DGtal::Dimension dim, typename TEuclideanRing , typename TContainer >
void	getSquaredNormL2 (TOutput &n, const DGtal::PointVector< dim, TEuclideanRing, TContainer > &a)
template<typename TComponent , DGtal::Dimension TN, typename TInternalNumber >
void	getDeterminantBareiss (TInternalNumber &result, const SimpleMatrix< TComponent, TN, TN > &matrix)
template<typename TComponent , typename TInternalNumber >
void	getDeterminantBareiss (TInternalNumber &result, const std::vector< std::vector< TComponent > > &matrix)
template<typename TComponent >
std::vector< std::vector< TComponent > >	matrixAsVectorVector (std::size_t m, std::size_t n, const std::vector< TComponent > &c)
template<typename TComponent , DGtal::Dimension TM, DGtal::Dimension TN>
std::vector< std::vector< TComponent > >	matrixAsVectorVector (const SimpleMatrix< TComponent, TM, TN > &M)
template<typename TComponent , typename TDouble = long double>
std::vector< std::vector< TComponent > >	computeLLLBasis (const std::vector< std::vector< TComponent > > &B, TDouble delta=0.75)
template<typename TComponent , typename TDouble = long double>
void	reduceBasisWithLLL (std::vector< std::vector< TComponent > > &B, TDouble delta=0.75)
template<typename TComponent >
TComponent	makePrimitive (std::vector< TComponent > &N)
template<typename TComponent >
TComponent	extendedGcd (TComponent &x, TComponent &y, TComponent a, TComponent b)
template<typename TComponent >
TComponent	extendedGcd (std::vector< TComponent > &C, const std::vector< TComponent > &A)
template<typename TComponent >
std::vector< std::vector< TComponent > >	computeOrthogonalLattice (std::vector< TComponent > N)
template<typename TComponent >
bool	shortenVectors (std::vector< TComponent > &u, std::vector< TComponent > &v)
template<typename TComponent >
std::size_t	shortenBasis (std::vector< std::vector< TComponent > > &B)
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;
    }

apply()

template<typename T , typename U , typename Op2 >

std::vector< typename DGtal::ArithmeticConversionTraits< T, U >::type > DGtal::functions::apply	(	const std::vector< T > &	a,
		const std::vector< U > &	b,
		Op2	op2
	)

Applies the binary operation op2 to every pair of elements (a[i],b[i]) and returns the resulting range of values op2([a[0],b[0]), ..., op2([a[n-1],b[n-1]).

Template Parameters

T	the number type of the left operand vector.
U	the number type of the right operand vector.
Op2	the type for the binary operator.

Parameters

a	the range of values acting as left operands.
b	the range of values acting as rights operands.
op2	the binary operator (T,U) -> V, where V is the best possible type combining T and U.

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

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

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

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

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

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

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

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

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

Referenced by main(), main(), SCENARIO(), and SCENARIO().

computeAffineDimension()

template<typename TPoint >

DGtal::int64_t DGtal::functions::computeAffineDimension	(	const std::vector< TPoint > &	X,
		const double	tolerance = 1e-12
	)

Given a range of points X, returns the affine dimension of its spanned affine subspace.

Template Parameters

TPoint

any type of lattice point or real point.

Parameters

X	the range of input points (may be lattice points or not).
tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Returns

the affine dimension of X.

Note

Complexity is \(O( m n^2 )\), where m=Cardinal(X) and n=dimension.

Definition at line 1068 of file AffineGeometry.h.

    {
      return AffineGeometry<TPoint>::affineDimension( X, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::affineDimension().

Referenced by checkAffineGeometry(), SCENARIO(), and SCENARIO().

computeAffineSubset() [1/2]

template<typename TPoint >

std::vector< std::size_t > DGtal::functions::computeAffineSubset	(	const std::vector< TPoint > &	X,
		const double	tolerance = 1e-12
	)

Given a range of points X, returns a subset of these points that form an affine basis of X. Equivalently it is a simplex whose affine space spans all the points of X.

Template Parameters

TPoint

any type of lattice point or real point.

Parameters

X	the range of input points (may be lattice points or not).
tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Returns

a subset of these points as a range of indices.

Note

Complexity is \(O( m n^2 )\), where m=Cardinal(X) and n=dimension.

Definition at line 1089 of file AffineGeometry.h.

    {
      return AffineGeometry<TPoint>::affineSubset( X, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::affineSubset().

Referenced by checkAffineGeometry(), SCENARIO(), and SCENARIO().

computeAffineSubset() [2/2]

template<typename TPoint , typename TIndexRange >

static std::vector< std::size_t > DGtal::functions::computeAffineSubset ( const std::vector< TPoint > &  X, const TIndexRange &  I, const double  tolerance = 1e-12  )

static

Given a range of points X and a subset of it given by indices I, returns a subset of these points that form an affine basis of X[I]. Equivalently it is a simplex whose affine space spans all the points of X[I].

Template Parameters

TPoint	any type of lattice point or real point.
TIndexRange	any type of range of indices that specifies the subset of points of interest.

Parameters

[in]	X	the range of input points (may be lattice points or not).
[in]	I	the range of indices specifying the subset of interest.
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Returns

a subset of these points as a range of indices.

Note

Complexity is \(O( m n^2 )\), where m=Cardinal(X) and n=dimension.

Definition at line 1117 of file AffineGeometry.h.

    {
      return AffineGeometry<TPoint>::affineSubset( X, I, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::affineSubset().

computeIndependentVector()

template<typename TPoint >

TPoint DGtal::functions::computeIndependentVector	(	const std::vector< TPoint > &	basis,
		const double	tolerance = 1e-12
	)

Given a partial basis of vectors, returns a canonic unit vector that is independent.

Template Parameters

TPoint

any type of lattice point or real point.

Parameters

[in]	basis	a range of independent vectors that defines a partial basis of the space.
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Returns

a canonic unit vector independent of all vectors of basis, or the null vector if the basis was not partial.

Definition at line 1202 of file AffineGeometry.h.

    {
      return AffineGeometry<TPoint>::independentVector( basis, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::independentVector().

Referenced by checkAffineGeometry(), SCENARIO(), and SCENARIO().

computeLLLBasis()

template<typename TComponent , typename TDouble = long double>

std::vector< std::vector< TComponent > > DGtal::functions::computeLLLBasis	(	const std::vector< std::vector< TComponent > > &	B,
		TDouble	delta = 0.75
	)

Computes the \( \delta \)-LLL-reduced lattice of the input lattice B (represented as an integer matrix B whose rows are the lattice vectors), using the LLL algorithm.

Such lattice has "almost" orthogonal vectors, while minimizing their norm at most as possible.

Note

A lattice \((b_1,...,b_m)\) is \( \delta \)-LLL-reduced if (1), for any \( i>j, |\mu_{i,j}| \le 1/2 \), and (2), for any \( i<m , \delta |b^*_i|^2 \le |b^*_{i+1}+mu_{i+1,i} b^*_i|^2 \). Here \( \mu_{i,j} := \langle b_i, b_j^* \rangle / \langle b_j^*, b_j^* \rangle \) and \( b^*_i \) is the i-th vector of the Gram-Schmidt orthogonalisation of \( (b_1, ..., b_m) \).

Template Parameters

TComponent	the integer type of each coefficient of the integer matrix B.
TDouble	the floating-point number type used for the Gram-Schmidt orthogonalisation of B.

Parameters

[in]	B	the lattice of m vectors in Z^n represented as a mxn matrix.
[in]	delta	the parameter \( \delta \) of LLL-algorithm, which should be between 0.25 and 1 (value 0.99 is default in sagemath).

Returns

the \( delta \)-LLL-reduced lattice of B.

Warning

Computations requiring Gram-Schmidt orthogonalisation uses the floating-point number type TDouble.

Referenced by testLLL().

computeOrthogonalLattice()

template<typename TComponent >

std::vector< std::vector< TComponent > > DGtal::functions::computeOrthogonalLattice

(

std::vector< TComponent >

N

)

Computes a basis of the orthogonal lattice to the vector N, i.e. it has n-1 vectors if N had n components. It essentially follows https://math.stackexchange.com/questions/1049608/lattice-generated-by-vectors-orthogonal-to-an-integer-vector

Note

If N is a primitive 3D vector, then the returned basis has two vectors, whose cross product is N or -N.

Template Parameters

TComponent

the integer type for the input vector and for computations.

Parameters

[in]

N

the input normal vector, which should be non null. Even if N is not primitive, it is considered primitive in the function.

Returns

a basis \( (u_1, \dots, u_{n-1}) \) such that \( u_i \cdot N = 0 \). Because N is made primitive, the orthogonal lattice is the finest possible for the d-1 dimensional space. The returned basis is in echelon form.

Referenced by DGtal::AffineGeometry< TPoint >::orthogonalLatticeBasis(), and testOrthogonalLattice().

computeOrthogonalVectorToBasis()

template<typename TPoint >

static TPoint DGtal::functions::computeOrthogonalVectorToBasis ( const std::vector< TPoint > &  basis )

static

Given d-1 independent vectors in dD, outputs a vector that is orthogonal to each of them. This function signature allows automatic internal type computations deduction.

Note

In 3D, given two independent vectors as input, then the added vector is the (reduced for integers, normalized with 1 squared L2-norm for floats) cross product of these two vectors. In nD, it is thus a generalization of the cross product.

Template Parameters

TPoint

any type of lattice point or real point.

Parameters

[in]

basis

a range of independent vectors of size dimension-1.

Returns

an orthogonal vector to every vector of basis (reduced or normalized depending on integer/floating-point number type).

Definition at line 1262 of file AffineGeometry.h.

    {
      if ( ( basis.size() + 1 ) != TPoint::dimension ) return TPoint::zero;
      return AffineGeometry<TPoint>::orthogonalVector( basis );
    }

References DGtal::AffineGeometry< TPoint >::orthogonalVector().

Referenced by checkAffineGeometry(), SCENARIO(), and SCENARIO().

computeSimplifiedVector()

template<typename TPoint >

TPoint DGtal::functions::computeSimplifiedVector

(

const TPoint &

v

)

Given a vector, returns the aligned vector with its component simplified by the gcd of all components (when the components are integers) or the aligned vector with a squared L2-norm of 1 (when the components are floating-point numbers).

Template Parameters

TPoint

any type of lattice point or real point.

Parameters

[in]

v

any vector.

Returns

a simplified vector aligned with v.

Definition at line 1394 of file AffineGeometry.h.

    {
      return AffineGeometry<TPoint>::simplifiedVector( v );
    }

References DGtal::AffineGeometry< TPoint >::simplifiedVector().

Referenced by checkAffineGeometry(), SCENARIO(), and SCENARIO().

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

const_middle()

template<typename T >

constexpr T DGtal::functions::const_middle ( T  K, unsigned int  e  )

constexpr

Template Parameters

T	any model of bounded number.

Parameters

K	a non negative number
e	a non negative integer

Returns

the index of the middle element in the e-dimensional array of width \( 2K+1 \), computed at compile time.

auto m1 = functions::const_middle( 1, 2 ); // 4, dans le tableau 3x3
auto m2 = functions::const_middle( 2, 2 ); // 12, dans le tableau 5x5
auto m3 = functions::const_middle( 1, 3 ); // 13, dans le tableau 3x3x3

Definition at line 75 of file ConstExpressions.h.

                                                    {
      return e <= 1
        ? T( K )
        : K * const_pow( 2 * K + 1, e - 1 ) + const_middle( K, e - 1 );
    }

References const_middle(), const_pow(), and K.

Referenced by const_middle().

const_pow()

template<typename T >

constexpr T DGtal::functions::const_pow ( T  b, unsigned int  e  )

constexpr

Template Parameters

T	any model of bounded number.

Parameters

b	a number
e	a non negative integer

Returns

the constant expression \( b^e \), computed at compile time.

auto v = functions::const_pow( 5, 3 ); // 5^3

Definition at line 60 of file ConstExpressions.h.

                                                {
      return e == 0 ? T(1) : b * const_pow( b, e - 1 );
    }

References const_pow().

Referenced by const_middle(), and const_pow().

crossProduct()

template<typename T , typename U >

std::vector< typename DGtal::ArithmeticConversionTraits< T, U >::type > DGtal::functions::crossProduct	(	const std::vector< T > &	a,
		const std::vector< U > &	b
	)

Overloaded cross product operator for vector of numbers.

Template Parameters

T	the number type of the left operand vector.
U	the number type of the right operand vector.

Parameters

[in]	a	the left vector (must be of size 3 )
[in]	b	the right vector (must be of size 3 )

Returns

the cross product of a and b (a vector of size 3 ).

Referenced by testOrthogonalLattice().

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.

    { return x * x * x; }

dotProduct() [1/3]

double DGtal::functions::dotProduct	(	const std::vector< BigInteger > &	a,
		const std::vector< double > &	b
	)

Overloaded dot product operator for vector of big integers with vector of doubles.

Parameters

[in]	a	the left vector
[in]	b	the right vector

Returns

the dot product of a and b.

dotProduct() [2/3]

double DGtal::functions::dotProduct	(	const std::vector< double > &	a,
		const std::vector< BigInteger > &	b
	)

Overloaded dot product operator for vector of big integers with vector of doubles.

Parameters

[in]	a	the left vector
[in]	b	the right vector

Returns

the dot product of a and b.

dotProduct() [3/3]

template<typename T , typename U >

DGtal::ArithmeticConversionTraits< T, U >::type DGtal::functions::dotProduct	(	const std::vector< T > &	a,
		const std::vector< U > &	b
	)

Overloaded dot product operator for vector of numbers.

Template Parameters

T	the number type of the left operand vector.
U	the number type of the right operand vector.

Parameters

[in]	a	the left vector
[in]	b	the right vector

Returns

the dot product of a and b, a scalar value in the "best possible type" according to T and U.

Referenced by testOrthogonalLattice().

equals()

template<typename TComponent >

bool DGtal::functions::equals	(	const std::vector< TComponent > &	a,
		const std::vector< TComponent > &	b
	)

Returns 'true' iff all the components of the two vectors are equal.

Template Parameters

TComponent

the scalar type of each component.

Parameters

[in]	a	the left vector (same size)
[in]	b	the right vector (same size)

Returns

'true' iff all the components of the two vectors are equal.

Referenced by testOrthogonalLattice().

extendedGcd() [1/2]

template<typename TComponent >

TComponent DGtal::functions::extendedGcd	(	std::vector< TComponent > &	C,
		const std::vector< TComponent > &	A
	)

Extended Eucliden algorithm to compute the gcd g of n integers A as will as the vector of integers C such that C[0]*A[0]+...+C[n-1]*A[n-1]=g, where g is the gcd of A[0],...,A[n-1].

Parameters

[out]	C	the array of integers such that C[0]*A[0]+...+C[n-1]*A[n-1]=g
[in]	A	the array of input integers.

Returns

the greatest common divisor g of A, i.e. gcd( A[0], gcd( A[1], ... )).

extendedGcd() [2/2]

template<typename TComponent >

TComponent DGtal::functions::extendedGcd	(	TComponent &	x,
		TComponent &	y,
		TComponent	a,
		TComponent	b
	)

Extended Eucliden algorithm to compute the gcd g of two integers a and b as well as two other integers x and y such that a*x+b*y=g, where g the gcd of a and b.

Parameters

[out]	x,y	two integers x and y such that a*x+b*y=g.
[in]	a,b	any pair of integers.

Returns

the greatest common divisor g of a and b, i.e. gcd( a, b ).

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, dt, 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.

getAffineBasis() [1/2]

template<typename TPoint , typename TInputPoint >

void DGtal::functions::getAffineBasis	(	TInputPoint &	o,
		std::vector< TPoint > &	basis,
		const std::vector< TInputPoint > &	X,
		const double	tolerance = 1e-12
	)

Given a range of points X, returns a point and a range of vectors forming an affine basis containing X.

Template Parameters

TPoint	any type of lattice point or real point (but one may choose a more precise type than TInputPoint.
TInputPoint	any type of lattice point or real point.

Parameters

[out]	o	the origin point
[out]	basis	a range of vectors forming an affine basis containing X.
[in]	X	the range of input points (may be lattice points or not).
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Note

Complexity is O( m n^2 ), where m=Cardinal(X) and n=dimension.

Definition at line 1145 of file AffineGeometry.h.

    {
      std::tie( o, basis ) = AffineGeometry<TPoint>::affineBasis( X, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::affineBasis().

Referenced by checkAffineGeometry(), SCENARIO(), SCENARIO(), and SCENARIO().

getAffineBasis() [2/2]

template<typename TPoint , typename TInputPoint , typename TIndexRange >

static void DGtal::functions::getAffineBasis ( TInputPoint &  o, std::vector< TPoint > &  basis, const std::vector< TInputPoint > &  X, const TIndexRange &  I, const double  tolerance = 1e-12  )

static

Given a range of points X, returns a point and a range of vectors forming an affine basis containing X.

Template Parameters

TPoint	any type of lattice point or real point (but one may choose a more precise type than TInputPoint.
TInputPoint	any type of lattice point or real point.
TIndexRange	any type of range of indices.

Parameters

[out]	o	the origin point
[out]	basis	a range of vectors forming an affine basis containing X.
[in]	X	the range of input points (may be lattice points or not).
[in]	I	the range of indices within X that specifies the subset of interest.
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Note

Complexity is O( m n^2 ), where m=Cardinal(I) and n=dimension.

Definition at line 1178 of file AffineGeometry.h.

    {
      std::tie( o, basis ) = AffineGeometry<TPoint>::affineBasis( X, I, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::affineBasis().

getCompleteBasis()

template<typename TPoint >

static void DGtal::functions::getCompleteBasis ( std::vector< TPoint > &  basis, bool  normal_vector, const double  tolerance = 1e-12  )

static

Complete the vectors basis with independent vectors so as to form a basis of the space. When normal_vector is true, the last added vector is guaranteed to be orthogonal to all the previous vectors, otherwise it is just an independent canonic vector.

Note

In 3D, given two independent vectors as input, then the added vector is the (reduced for integers, normalized with 1 squared L2-norm for floats) cross product of these two vectors. In nD, it is thus a generalization of the cross product.

Template Parameters

TPoint

any type of lattice point or real point.

Parameters

[in,out]	basis	a range of independent vectors of size less than dimension, which is completed so as to be a basis of the full space.
[in]	normal_vector	when 'true', the last vector of the basis is orthogonal to all the other vectors of the basis, otherwise it is just an independent canonic vector.
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Definition at line 1235 of file AffineGeometry.h.

    {
      AffineGeometry<TPoint>::completeBasis( basis, normal_vector, tolerance );
    }

References DGtal::AffineGeometry< TPoint >::completeBasis().

getDeterminantBareiss() [1/2]

template<typename TComponent , DGtal::Dimension TN, typename TInternalNumber >

void DGtal::functions::getDeterminantBareiss	(	TInternalNumber &	result,
		const SimpleMatrix< TComponent, TN, TN > &	matrix
	)

Computes the determinant of a squared matrix with integer or floating-point coefficients using Bareiss method. Complexity is in O(n^3) if you assume O(1) for each arithmetic operation.

Template Parameters

TComponent	the number type.
TN	the order of the squared matrix.
TInternalNumber	the number type used for internal computations and for the output.

Parameters

[out]	result	the determinant of this matrix.
[in]	matrix	a squared matrix.

Note

In case of integer coefficients, intermediate integer values may grow quickly. Use int64_t or even boost::multiprecision::cpp_int to get robust result.

Referenced by DGtal::AffineGeometry< TPoint >::orthogonalVector(), testBareissDeterminant(), and testLLL().

getDeterminantBareiss() [2/2]

template<typename TComponent , typename TInternalNumber >

void DGtal::functions::getDeterminantBareiss	(	TInternalNumber &	result,
		const std::vector< std::vector< TComponent > > &	matrix
	)

Computes the determinant of a squared matrix with integer or floating-point coefficients using Bareiss method. Complexity is in O(n^3) if you assume O(1) for each arithmetic operation.

Template Parameters

TComponent	the number type.
TInternalNumber	the number type used for internal computations and for the output.

Parameters

[in]	matrix	a squared matrix, represented as a vector of row vectors.
[out]	result	the determinant of this matrix.

Note

In case of integer coefficients, intermediate integer values may grow quickly. Use int64_t or even boost::multiprecision::cpp_int to get robust result.

getOrthogonalLatticeBasis()

template<typename TPoint , typename TInputPoint >

static void DGtal::functions::getOrthogonalLatticeBasis ( std::vector< TPoint > &  B, const TInputPoint &  N, bool  shortened = false  )

static

Given a primitive lattice vector N, returns a possible basis for its orthogonal d-1 dimensional lattice.

Template Parameters

TPoint	any type of lattice point (type for computations and output).
TInputPoint	any type of lattice point

Parameters

[out]	B	the d-1 dimension basis of the orthognal lattice to N.
[in]	N	a non null primitive lattice vector
[in]	shortened	when 'false', the basis is in row echelon form, when 'true', the basis is shortened (with pairwise shortenings, may not be optimal, except in 3D).

Definition at line 1375 of file AffineGeometry.h.

    {
      B = AffineGeometry<TPoint>::orthogonalLatticeBasis( N, shortened );
    }

References DGtal::AffineGeometry< TPoint >::orthogonalLatticeBasis().

getOrthogonalVector() [1/2]

template<typename TPoint , typename TInputPoint >

static void DGtal::functions::getOrthogonalVector ( TPoint &  w, const std::vector< TInputPoint > &  X, const double  tolerance = 1e-12  )

static

Given a range of points X, returns a vector that is orthogonal to this affine set, if it is d-1-dimensional.

Template Parameters

TPoint	any type of lattice point or real point (type for computations and output).
TInputPoint	any type of lattice point or real point.

Parameters

[out]	w	an orthogonal vector to every vector of the affine subset (reduced or normalized depending on integer/floating-point number type).
[in]	X	the range of input points (may be lattice points or not).
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Note

The orthogonal vector is computed as follows: (i) identifies an affine subset J of maximal affine dimension, (ii) computes the basis (X_J_k - X_J_0), k>0, (iii) computes the cofactors using Bareiss determinant. This method induces smaller integers than (i) reducing the basis, (ii) using cofactors with Bareiss determinant, or the method that solely cofactors with standard determinant computation.

Definition at line 1344 of file AffineGeometry.h.

    { 
      typedef AffineGeometry<TPoint> Affine;
      w = TPoint::zero;
      TInputPoint o;
      auto subset = AffineGeometry<TPoint>::affineSubset( X, tolerance );
      if ( ( subset.size() ) != TPoint::dimension ) return;
      std::vector<TPoint> basis( TPoint::dimension - 1);
      for ( auto i = 0; i < basis.size(); i++ )
        basis[ i ] = Affine::transform( X[ subset[ i+1 ] ] - X[ subset[ 0 ] ] );
      w = Affine::orthogonalVector( basis );
    }

References DGtal::AffineGeometry< TPoint >::affineSubset().

getOrthogonalVector() [2/2]

template<typename TPoint , typename TInputPoint , typename TIndexRange >

static void DGtal::functions::getOrthogonalVector ( TPoint &  w, const std::vector< TInputPoint > &  X, const TIndexRange &  I, const double  tolerance = 1e-12  )

static

Given a range of points X, a range of indices I specifying the affine subset of interest, returns a vector that is orthogonal to this affine subset, if it is d-1-dimensional.

Template Parameters

TPoint	any type of lattice point or real point.
TInputPoint	any type of lattice point or real point.
TIndexRange	any type of range of indices that specifies the subset of points of interest.

Parameters

[out]	w	an orthogonal vector to every vector of the affine subset (reduced or normalized depending on integer/floating-point number type).
[in]	X	the range of input points (may be lattice points or not).
[in]	I	the range of indices within X that specifies the subset of interest.
[in]	tolerance	the accepted squared L2-norm below which the vector is null (used only for points with float/double coordinates).

Note

The orthogonal vector is computed as follows: (i) identifies an affine subset J of maximal affine dimension, (ii) computes the basis (X_J_k - X_J_0), k>0, (iii) computes the cofactors using Bareiss determinant. This method induces smaller integers than (i) reducing the basis, (ii) using cofactors with Bareiss determinant, or the method that solely cofactors with standard determinant computation.

Definition at line 1301 of file AffineGeometry.h.

    {
      typedef AffineGeometry<TPoint> Affine;
      w = TPoint::zero;
      TInputPoint o;
      auto subset = Affine::affineSubset( X, I, tolerance );
      if ( ( subset.size() ) != TPoint::dimension ) return;
      std::vector<TPoint> basis( TPoint::dimension - 1);
      for ( auto i = 0; i < basis.size(); i++ )
        basis[ i ] = Affine::transform( X[ subset[ i+1 ] ] - X[ subset[ 0 ] ] );
      w = Affine::orthogonalVector( basis );
    }

Referenced by DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::compute(), DGtal::detail::GenericLatticeConvexHullComputers< dim, TCoordinateInteger, TInternalInteger, K >::compute(), and SCENARIO().

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

getSquaredNormL2() [1/2]

template<typename TOutput , DGtal::Dimension dim, typename TEuclideanRing , typename TContainer >

void DGtal::functions::getSquaredNormL2	(	TOutput &	n,
		const DGtal::PointVector< dim, TEuclideanRing, TContainer > &	a
	)

Overloaded squared L2-norm operator for a vector of numbers.

Template Parameters

TOutput	the desired number type for output.
dim	static constant of type DGtal::Dimension that specifies the static dimension of the space and thus the number of elements of the Point or Vector.
TEuclideanRing	speficies the number type assoicated to an Euclidean domain (or Euclidean ring) algebraic structure (commutative unitary ring with no zero divisors and with a division operator but not necessarily an inverse for the multiplication operator). This type is used to represent PointVector elements (Coordinate for Point and Component for Vector) and define operations on Point or Vectors.
TContainer	specifies the container to be used to store the point coordinates. At this point, such container must be a random access bidirectionnal a-la STL containers (e.g. vector, boost/array). If TContainer implements comparison operators == != < <= > <=, then PointVector will also implements it and with the exact same behaviour.

Parameters

[out]	n	the dot product a.a, i.e. the squared L2-norm of a.
[in]	a	the vector of numbers.

getSquaredNormL2() [2/2]

template<typename TOutput , typename T >

void DGtal::functions::getSquaredNormL2	(	TOutput &	n,
		const std::vector< T > &	a
	)

Overloaded squared L2-norm operator for a vector of numbers.

Template Parameters

TOutput	the desired number type for output.
T	the number type of the input vector.

Parameters

[out]	n	the dot product a.a, i.e. the squared L2-norm of a.
[in]	a	the vector of numbers.

Referenced by DGtal::AffineGeometry< TPoint >::addIfIndependent(), DGtal::AffineGeometry< TPoint >::independentVector(), and DGtal::AffineGeometry< TPoint >::simplifiedVector().

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

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

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

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

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

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

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(), SCENARIO(), TEST_CASE_METHOD(), TEST_CASE_METHOD(), TEST_CASE_METHOD(), TEST_CASE_METHOD(), 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().

makePrimitive()

template<typename TComponent >

TComponent DGtal::functions::makePrimitive

(

std::vector< TComponent > &

N

)

Makes a lattice vector primitive.

Template Parameters

TComponent

the integer type for the input vector and for computations.

Parameters

[in,out]

N

the input vector, that is modified to be N/g, where g is the gcd of its components.

Returns

the gcd of the components.

Referenced by testOrthogonalLattice().

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.

matrixAsVectorVector() [1/2]

template<typename TComponent , DGtal::Dimension TM, DGtal::Dimension TN>

std::vector< std::vector< TComponent > > DGtal::functions::matrixAsVectorVector

(

const SimpleMatrix< TComponent, TM, TN > &

M

)

Outputs the matrix of size m x n with coefficients c, as a vector of vector representation.

Template Parameters

TComponent	the number type.
TN	the number of rows
TM	the number of columns

Parameters

[in]

M

any matrix

Returns

the m x n matrix cloning the coefficients of M.

matrixAsVectorVector() [2/2]

template<typename TComponent >

std::vector< std::vector< TComponent > > DGtal::functions::matrixAsVectorVector	(	std::size_t	m,
		std::size_t	n,
		const std::vector< TComponent > &	c
	)

Outputs the matrix M of size m x n with coefficients c, as a vector of vector representation.

Template Parameters

TComponent

the number type.

Parameters

[in]	m,n	the number of rows and columns of the matrix M.
[in]	c	the coefficients of the matrix in order c_00, c01, etc.

Returns

the m x n matrix with coefficients c filled row per row, and potentially completed with zero.

Referenced by testBareissDeterminant().

negate()

template<typename TComponent >

void DGtal::functions::negate

(

std::vector< TComponent > &

V

)

Negates the components of the input vector.

Template Parameters

TComponent

the scalar type of each component.

Parameters

[in,out]

V

the vector as input, outputed as -V.

Referenced by testOrthogonalLattice().

normL1()

template<typename T >

T DGtal::functions::normL1

(

const std::vector< T > &

a

)

Overloaded L1-norm operator for a vector of numbers.

Template Parameters

T	the number type of the input vector.

Parameters

[in]

a

the vector of numbers

Returns

the L1-norm of a, i.e. \( \sum_i |a_i| \), sometimes called block distance.

Referenced by testLLL().

normLoo()

template<typename T >

T DGtal::functions::normLoo

(

const std::vector< T > &

a

)

Overloaded Loo-norm operator for a vector of numbers.

Template Parameters

T	the number type of the input vector.

Parameters

[in]

a

the vector of numbers

Returns

the \( L_\infinity \)-norm of a, i.e. \( \max_i |a_i| \).

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

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

Referenced by testBasicMathFunctions().

reduceBasisWithLLL()

template<typename TComponent , typename TDouble = long double>

void DGtal::functions::reduceBasisWithLLL	(	std::vector< std::vector< TComponent > > &	B,
		TDouble	delta = 0.75
	)

Computes the \( \delta \)-LLL-reduced lattice of the input lattice B (represented as an integer matrix B whose rows are the lattice vectors), using the LLL algorithm.

Such lattice has "almost" orthogonal vectors, while minimizing their norm at most as possible.

Note

A lattice \((b_1,...,b_m)\) is \( \delta \)-LLL-reduced if (1), for any \( i>j, |\mu_{i,j}| \le 1/2 \), and (2), for any \( i<m , \delta |b^*_i|^2 \le |b^*_{i+1}+mu_{i+1,i} b^*_i|^2 \). Here \( \mu_{i,j} := \langle b_i, b_j^* \rangle / \langle b_j^*, b_j^* \rangle \) and \( b^*_i \) is the i-th vector of the Gram-Schmidt orthogonalisation of \( (b_1, ..., b_m) \).

Template Parameters

TComponent	the integer type of each coefficient of the integer matrix B.
TDouble	the floating-point number type used for the Gram-Schmidt orthogonalisation of B.

Parameters

[in,out]	B	as input, the lattice of m vectors in Z^n represented as a mxn matrix, as output the \( delta \)-LLL-reduced lattice of B.
[in]	delta	the parameter \( \delta \) of LLL-algorithm, which should be between 0.25 and 1 (value 0.99 is default in sagemath).

Warning

Computations requiring Gram-Schmidt orthogonalisation uses the floating-point number type TDouble.

Referenced by DGtal::AffineBasis< TPoint >::reduceAsLLL().

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 : [108]].

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

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.

shortenBasis()

template<typename TComponent >

std::size_t DGtal::functions::shortenBasis

(

std::vector< std::vector< TComponent > > &

B

)

Shortens the vectors of the basis B (by pairwise shortenings) until no further shortening pairs are found, and returns the number of shortening operations.

Template Parameters

TComponent

the integer type for the input vector and for computations.

Parameters

[in,out]

B

a range of vectors forming a basis, which is shorten as much as possible in terms of L2-norm. Note that the output basis is not in echelon form in general.

Returns

the number of pairwise shortenings done.

Referenced by DGtal::AffineGeometry< TPoint >::orthogonalLatticeBasis(), testLLL(), and testOrthogonalLattice().

shortenVectors()

template<typename TComponent >

bool DGtal::functions::shortenVectors	(	std::vector< TComponent > &	u,
		std::vector< TComponent > &	v
	)

Tries to shorten u and v while preserving their vector span by trying u+v and u-v.

Template Parameters

TComponent

the integer type for the input vector and for computations.

Parameters

[in,out]	u	any vector
[in,out]	v	any vector

Returns

'true' if one shortening was possible, then at least one of u and v is modified.

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

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 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 : [108]].

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.

    { return x * x; }

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

squaredNormL2()

template<typename T >

T DGtal::functions::squaredNormL2

(

const std::vector< T > &

a

)

Overloaded squared L2-norm operator for a vector of numbers.

Template Parameters

T	the number type of the input vector.

Parameters

[in]

a

the vector of numbers

Returns

the dot product a.a, i.e. the squared L2-norm of a.

See also

getSquaredNormL2 if you wish to use another type for computation.

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