DGtal::detail::RecursivePConvexity< dim, TInteger > Struct Template Reference

#include <DGtal/geometry/volumes/PConvexity.h>

Inheritance diagram for DGtal::detail::RecursivePConvexity< dim, TInteger >:

Public Types
using	Integer = TInteger
using	Point = DGtal::PointVector< dim, Integer >
using	ProjPoint = DGtal::PointVector< dim-1, Integer >
using	ProjPConvexity = DGtal::detail::RecursivePConvexity< dim - 1, Integer >

Public Member Functions
	BOOST_CONCEPT_ASSERT ((concepts::CInteger< TInteger >))
	Integer must be a model of the concept CInteger.
	RecursivePConvexity (Dimension bd=dim)
void	init (Dimension bd=dim)
bool	isPConvex (const std::vector< Point > &X, bool safe) const
double	fullConvexityMeasure (const std::vector< Point > &X, bool safe) const

Static Public Member Functions
static bool	is0Convex (const std::vector< Point > &X, bool safe)
static double	convexityMeasure (const std::vector< Point > &X, bool safe)
static ProjPoint	project (const Point &p, Dimension a)
static std::vector< ProjPoint >	project (const std::vector< Point > &p, Dimension a)

Data Fields
std::vector< ProjPConvexity >	projp
	The array of lower dimensional P-convexities.

Detailed Description

template<Dimension dim, typename TInteger = DGtal::int32_t>
struct DGtal::detail::RecursivePConvexity< dim, TInteger >

Hidden class to represent the P-convexity in a recursive way. Only used to compute P-convexity, but not exposed to users.

Note

This d-dimensional object builds d (d-1)-dimensional similar objects, but the k-th remembers to build only k lower dimensional ones.

Template Parameters

dim	the dimension of the digital space
TInteger	any model of integer (used to represent digital point coordinates).

Definition at line 66 of file PConvexity.h.

Member Typedef Documentation

Integer

template<Dimension dim, typename TInteger = DGtal::int32_t>

using DGtal::detail::RecursivePConvexity< dim, TInteger >::Integer = TInteger

Definition at line 69 of file PConvexity.h.

Point

template<Dimension dim, typename TInteger = DGtal::int32_t>

using DGtal::detail::RecursivePConvexity< dim, TInteger >::Point = DGtal::PointVector< dim, Integer >

Definition at line 70 of file PConvexity.h.

ProjPConvexity

template<Dimension dim, typename TInteger = DGtal::int32_t>

using DGtal::detail::RecursivePConvexity< dim, TInteger >::ProjPConvexity = DGtal::detail::RecursivePConvexity< dim - 1, Integer >

Definition at line 72 of file PConvexity.h.

ProjPoint

template<Dimension dim, typename TInteger = DGtal::int32_t>

using DGtal::detail::RecursivePConvexity< dim, TInteger >::ProjPoint = DGtal::PointVector< dim-1, Integer >

Definition at line 71 of file PConvexity.h.

Constructor & Destructor Documentation

RecursivePConvexity()

template<Dimension dim, typename TInteger = DGtal::int32_t>

DGtal::detail::RecursivePConvexity< dim, TInteger >::RecursivePConvexity ( Dimension bd = dim )

inline

Parameter bd is used to build exactly 2^d - 1 PConvexity objects when starting at dimension d.

Parameters

bd	the maximum axis of projection.

Definition at line 77 of file PConvexity.h.

      {
        init( bd );
      }

Member Function Documentation

BOOST_CONCEPT_ASSERT()

template<Dimension dim, typename TInteger = DGtal::int32_t>

DGtal::detail::RecursivePConvexity< dim, TInteger >::BOOST_CONCEPT_ASSERT

(

(concepts::CInteger< TInteger >)

)

Integer must be a model of the concept CInteger.

convexityMeasure()

template<Dimension dim, typename TInteger = DGtal::int32_t>

double DGtal::detail::RecursivePConvexity< dim, TInteger >::convexityMeasure ( const std::vector< Point > & X, bool safe )

inlinestatic

Parameters

X	any range of lattice points (without duplicates)
safe	when 'true' performs convex hull computations with arbitrary precision integer (if available), otherwise chooses a compromise between speed and precision (int64_t).

Precondition

X must not contain any duplicates.

Returns

a measure that has value 1.0 when X is digitally convex, and less otherwise.

Definition at line 155 of file PConvexity.h.

      {
        if ( X.empty() ) return 1.0;
        // Build polytope according to internal integer type.
        if ( safe )
          {
            typedef typename DGtal::detail::ConvexityHelperInternalInteger< Integer, true >::Type
              InternalInteger;
            const auto P = ConvexityHelper< dim, Integer, InternalInteger >::
         computeLatticePolytope( X, false, false );
            const std::size_t number_lattice_points_in_P = P.count();
            return double( X.size() ) / double( number_lattice_points_in_P );
          }
        else
          {
            typedef typename DGtal::detail::ConvexityHelperInternalInteger< Integer, false >::Type
              InternalInteger;
            const auto P = ConvexityHelper< dim, Integer, InternalInteger >::
         computeLatticePolytope( X, false, false );
            const std::size_t number_lattice_points_in_P = P.count();
            return double( X.size() ) / double( number_lattice_points_in_P );
          }
      }

Referenced by DGtal::detail::RecursivePConvexity< 1, TInteger >::fullConvexityMeasure(), and DGtal::detail::RecursivePConvexity< dim - 1, Integer >::fullConvexityMeasure().

fullConvexityMeasure()

template<Dimension dim, typename TInteger = DGtal::int32_t>

double DGtal::detail::RecursivePConvexity< dim, TInteger >::fullConvexityMeasure ( const std::vector< Point > & X, bool safe ) const

inline

Parameters

X	any range of lattice points (without duplicates)
safe	when 'true' performs convex hull computations with arbitrary precision integer (if available), otherwise chooses a compromise between speed and precision (int64_t).

Precondition

X must not contain any duplicates.

Returns

a measure that has value 1.0 when X is P-convex (or equivalently fully convex), and less otherwise.

Definition at line 189 of file PConvexity.h.

      {
        double m = convexityMeasure( X, safe );
        for ( std::size_t j = 0; j < projp.size(); j++ )
          {
            auto pX = project( X, j );
            m      *= projp[ j ].fullConvexityMeasure( pX, safe );
          }
        return m;
      }

init()

template<Dimension dim, typename TInteger = DGtal::int32_t>

void DGtal::detail::RecursivePConvexity< dim, TInteger >::init ( Dimension bd = dim )

inline

Parameters

bd	the maximum axis of projection.

Definition at line 83 of file PConvexity.h.

      {
        for ( Dimension j = 0; j < bd; j++ )
          projp.push_back( ProjPConvexity( j ) );
      }

Referenced by DGtal::detail::RecursivePConvexity< dim - 1, Integer >::RecursivePConvexity().

is0Convex()

template<Dimension dim, typename TInteger = DGtal::int32_t>

bool DGtal::detail::RecursivePConvexity< dim, TInteger >::is0Convex ( const std::vector< Point > & X, bool safe )

inlinestatic

Parameters

X	any range of lattice points (without duplicates)
safe	when 'true' performs convex hull computations with arbitrary precision integer (if available), otherwise chooses a compromise between speed and precision (int64_t).

Returns

'true' if and only if X is a digitally convex set in the classic sense, i.e. \( Conv(X) \cap Z^d = X \).

Precondition

X must not contain any duplicates.

Definition at line 100 of file PConvexity.h.

      {
        if ( X.empty() ) return true;
        // Build polytope according to internal integer type.
        if ( safe )
          {
            typedef typename DGtal::detail::ConvexityHelperInternalInteger< Integer, true >::Type
              InternalInteger;
            const auto P = ConvexityHelper< dim, Integer, InternalInteger >::
         computeLatticePolytope( X, false, false );
            const std::size_t number_lattice_points_in_P = P.count();
            return number_lattice_points_in_P == X.size();
          }
        else
          {
            typedef typename DGtal::detail::ConvexityHelperInternalInteger< Integer, false >::Type
              InternalInteger;
            const auto P = ConvexityHelper< dim, Integer, InternalInteger >::
         computeLatticePolytope( X, false, false );
            const std::size_t number_lattice_points_in_P = P.count();
            return number_lattice_points_in_P == X.size();
          }
      }

Referenced by DGtal::detail::RecursivePConvexity< 1, TInteger >::isPConvex(), and DGtal::detail::RecursivePConvexity< dim - 1, Integer >::isPConvex().

isPConvex()

template<Dimension dim, typename TInteger = DGtal::int32_t>

bool DGtal::detail::RecursivePConvexity< dim, TInteger >::isPConvex ( const std::vector< Point > & X, bool safe ) const

inline

Parameters

X	any range of lattice points (without duplicates)
safe	when 'true' performs convex hull computations with arbitrary precision integer (if available), otherwise chooses a compromise between speed and precision (int64_t).

Returns

'true' if and only if X is a P-convex digital set.

Precondition

X must not contain any duplicates.

Definition at line 133 of file PConvexity.h.

      {
        if ( ! is0Convex( X, safe ) ) return false;
        for ( std::size_t j = 0; j < projp.size(); j++ )
          {
            const auto pi_j_X = project( X, j );
            if ( ! projp[ j ].isPConvex( pi_j_X, safe ) ) return false;
          }
        return true;
      }

Referenced by DGtal::detail::RecursivePConvexity< dim - 1, Integer >::isPConvex().

project() [1/2]

template<Dimension dim, typename TInteger = DGtal::int32_t>

ProjPoint DGtal::detail::RecursivePConvexity< dim, TInteger >::project ( const Point & p, Dimension a )

inlinestatic

Projects a point p along dimension a.

Parameters

[in]	p	any digital point
[in]	a	any dimension

Returns

the digital point of dimension (d-1) with omitted a-th coordinate.

Definition at line 206 of file PConvexity.h.

      {
        ProjPoint pp;
        Dimension j = 0;
        for ( Dimension i = 0; i < Point::dimension; i++ )
          if ( i != a ) pp[ j++ ] = p[ i ];
        return pp;
      }

Referenced by DGtal::detail::RecursivePConvexity< dim - 1, Integer >::fullConvexityMeasure(), DGtal::detail::RecursivePConvexity< dim - 1, Integer >::isPConvex(), and DGtal::detail::RecursivePConvexity< dim - 1, Integer >::project().

project() [2/2]

template<Dimension dim, typename TInteger = DGtal::int32_t>

std::vector< ProjPoint > DGtal::detail::RecursivePConvexity< dim, TInteger >::project ( const std::vector< Point > & p, Dimension a )

inlinestatic

Projects the range of points p along dimension a.

Parameters

[in]	p	any range of digital points
[in]	a	any dimension

Returns

the range of digital points of dimension (d-1) with omitted a-th coordinate.

Postcondition

the returned range has no duplicates.

Definition at line 225 of file PConvexity.h.

      {
        std::vector< ProjPoint > pp( p.size() );
        for ( std::size_t i = 0; i < p.size(); i++ )
          pp[ i ] = project( p[ i ], a );
        std::sort( pp.begin(), pp.end() );
        auto last = std::unique( pp.begin(), pp.end() );
        pp.erase( last, pp.end() );
        return pp;
      }

Field Documentation

projp

template<Dimension dim, typename TInteger = DGtal::int32_t>

std::vector< ProjPConvexity > DGtal::detail::RecursivePConvexity< dim, TInteger >::projp

The array of lower dimensional P-convexities.

Definition at line 237 of file PConvexity.h.

---

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

• PConvexity.h