Aim: a geometric kernel to compute the Delaunay triangulation of a range of floating points with integer-only arithmetic. Floating points are approximated with rational points with fixed precision (a given number of bits), which are cast in a higher dimensional space and lifted onto the "norm" paraboloid, as classically done when computing a Delaunay triangulation from a convex hull. All remaining computations are exact, as long as there is no overflow. More...

#include <DGtal/geometry/tools/QuickHullKernels.h>

Inheritance diagram for DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >:

[legend]

Public Types
typedef ConvexHullCommonKernel< dim+1, TCoordinateInteger, TInternalInteger >	Base
typedef DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >	Self
typedef DelaunayRationalKernel< dim-1, TCoordinateInteger, TInternalInteger >	LowerSelf
Public Types inherited from DGtal::ConvexHullCommonKernel< dim+1, DGtal::int64_t, DGtal::int64_t >
typedef DGtal::int64_t	CoordinateInteger
typedef DGtal::int64_t	InternalInteger
typedef CoordinateInteger	CoordinateScalar
typedef InternalInteger	InternalScalar
typedef DGtal::PointVector< dim, CoordinateInteger >	CoordinatePoint
typedef DGtal::PointVector< dim, CoordinateInteger >	CoordinateVector
typedef DGtal::PointVector< dim, InternalInteger >	InternalPoint
typedef DGtal::PointVector< dim, InternalInteger >	InternalVector
typedef std::size_t	Size
typedef Size	Index
typedef std::vector< Index >	IndexRange
typedef std::array< Index, dim >	CombinatorialPlaneSimplex
typedef ConvexHullCommonKernel< dim, DGtal::int64_t, DGtal::int64_t >	Self
typedef ConvexHullCommonKernel< dim-1, DGtal::int64_t, DGtal::int64_t >	LowerSelf
typedef IntegerConverter< dim, CoordinateInteger >	Outer
	Converter to outer coordinate integers or lattice points / vector.
typedef IntegerConverter< dim, InternalInteger >	Inner
	Converter to inner internal integers or lattice points / vector.

Public Member Functions
	DelaunayRationalKernel (double aPrecision=1024.)
bool	hasInfiniteFacets () const
bool	isHalfSpaceFacetInfinite (const HalfSpace &hs) const
template<typename InputPoint>
void	makeInput (std::vector< CoordinatePoint > &processed_points, IndexRange &input2comp, IndexRange &comp2input, const std::vector< InputPoint > &input_points, bool remove_duplicates)
template<typename OutputPoint>
void	convertPointTo (const CoordinatePoint &p, OutputPoint &out_p) const
HalfSpace	compute (const std::vector< CoordinatePoint > &vpoints, const CombinatorialPlaneSimplex &simplex, Index idx_below)
HalfSpace	compute (const std::vector< CoordinatePoint > &vpoints, const CombinatorialPlaneSimplex &simplex)
CoordinateVector	normal (const HalfSpace &H) const
CoordinateScalar	intercept (const HalfSpace &H) const
InternalScalar	dot (const HalfSpace &H1, const HalfSpace &H2) const
bool	equal (const HalfSpace &H1, const HalfSpace &H2) const
InternalScalar	height (const HalfSpace &H, const CoordinatePoint &p) const
InternalScalar	volume (const HalfSpace &H, const CoordinatePoint &p) const
bool	above (const HalfSpace &H, const CoordinatePoint &p) const
bool	aboveOrOn (const HalfSpace &H, const CoordinatePoint &p) const
bool	on (const HalfSpace &H, const CoordinatePoint &p) const
Public Member Functions inherited from DGtal::ConvexHullCommonKernel< dim+1, DGtal::int64_t, DGtal::int64_t >
	BOOST_CONCEPT_ASSERT ((concepts::CInteger< DGtal::int64_t >))
	ConvexHullCommonKernel ()=default
	Default constructor.
HalfSpace	compute (const std::vector< CoordinatePoint > &vpoints, const CombinatorialPlaneSimplex &simplex, Index idx_below)
CoordinateVector	normal (const HalfSpace &H) const
CoordinateScalar	intercept (const HalfSpace &H) const
InternalScalar	dot (const HalfSpace &H1, const HalfSpace &H2) const
bool	equal (const HalfSpace &H1, const HalfSpace &H2) const
InternalScalar	height (const HalfSpace &H, const CoordinatePoint &p) const
InternalScalar	volume (const HalfSpace &H, const CoordinatePoint &p) const
bool	above (const HalfSpace &H, const CoordinatePoint &p) const
bool	aboveOrOn (const HalfSpace &H, const CoordinatePoint &p) const
bool	on (const HalfSpace &H, const CoordinatePoint &p) const

Data Fields
double	precision
	The precision as the common denominator for all rational points.

Static Public Attributes
static const Dimension	dimension
Static Public Attributes inherited from DGtal::ConvexHullCommonKernel< dim+1, DGtal::int64_t, DGtal::int64_t >
static const Dimension	dimension

Detailed Description

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
struct DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >

Aim: a geometric kernel to compute the Delaunay triangulation of a range of floating points with integer-only arithmetic. Floating points are approximated with rational points with fixed precision (a given number of bits), which are cast in a higher dimensional space and lifted onto the "norm" paraboloid, as classically done when computing a Delaunay triangulation from a convex hull. All remaining computations are exact, as long as there is no overflow.

Description of template class 'DelaunayRationalKernel'

Each floating point input coordinate x is converted to an integer through the following formula (Integer) round( x * precision ), where precision is the floating point value given at instanciation of the kernel.

Each output floating point coordinate is built from integer coordinates a through the formula ( (double) a ) / precision, where precision is the floating point value given at instanciation of the kernel.

See also: QuickHull algorithm in arbitrary dimension for convex hull and Delaunay cell complex computation

Template Parameters

dim	the dimension of the space of processed points.
TCoordinateInteger	the integer type that represents coordinates of lattice points, a model of concepts::CInteger.
TInternalInteger	the integer type that is used for internal computations of above/below plane tests, a model of concepts::CInteger. Must be at least as precise as TCoordinateInteger.

Definition at line 828 of file QuickHullKernels.h.

Member Typedef Documentation

◆ Base

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

typedef ConvexHullCommonKernel< dim+1, TCoordinateInteger, TInternalInteger > DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::Base

Definition at line 831 of file QuickHullKernels.h.

◆ LowerSelf

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

typedef DelaunayRationalKernel< dim-1, TCoordinateInteger, TInternalInteger > DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::LowerSelf

Definition at line 833 of file QuickHullKernels.h.

◆ Self

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

typedef DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger > DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::Self

Definition at line 832 of file QuickHullKernels.h.

Constructor & Destructor Documentation

◆ DelaunayRationalKernel()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::DelaunayRationalKernel ( double aPrecision = 1024. )

inline

Constructor with specified precision

Parameters

[in] aPrecision the chosen precision as the common denominator of all rationals (by defaut, 1024).

Definition at line 870 of file QuickHullKernels.h.

871 : precision( aPrecision ) {}

DGtal::DelaunayRationalKernel

Aim: a geometric kernel to compute the Delaunay triangulation of a range of floating points with inte...

Definition QuickHullKernels.h:830

DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::precision

double precision

Definition QuickHullKernels.h:864

Member Function Documentation

◆ above()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

bool DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::above	(	const HalfSpace &	H,
		const CoordinatePoint &	p ) const

inline

Parameters

H	the half-space
p	any point

Returns: 'true' iff p is strictly above this plane (so in direction N ).

Definition at line 329 of file QuickHullKernels.h.

330 { return height( H, p ) > 0; }

DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::height

InternalScalar height(const HalfSpace &H, const CoordinatePoint &p) const

◆ aboveOrOn()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

bool DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::aboveOrOn	(	const HalfSpace &	H,
		const CoordinatePoint &	p ) const

inline

Parameters

H	the half-space
p	any point

Returns: 'true' iff p is above or lies on this plane (so in direction N ).

Definition at line 335 of file QuickHullKernels.h.

336 { return height( H, p ) >= 0; }

◆ compute() [1/2]

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

HalfSpace DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::compute	(	const std::vector< CoordinatePoint > &	vpoints,
		const CombinatorialPlaneSimplex &	simplex )

inline

Computes an halfspace from dimension points specified by simplex with vertices in a range vpoints of Point. Orientation is induced by the order of the points. If the simplex is degenerated, the half-space is invalid and has null normal.

Parameters

[in]	vpoints	a range of points over which the simplex is defined.
[in]	simplex	a range of dimension indices of points defining an hyperplane.

Returns: the corresponding halfspace (has null normal vector if simplex was not full dimensional)

Definition at line 261 of file QuickHullKernels.h.

    {
      // More robust method than SimpleMatrix::cofactor and faster for higher dimension.
      InternalVector N; // null normal
      const InternalPoint ip = Inner::cast( vpoints[ simplex[ 0 ] ] );
      functions::getOrthogonalVector( N, vpoints, simplex );
      return HalfSpace { N, N.dot( ip ) };
    }

◆ compute() [2/2]

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

HalfSpace DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::compute	(	const std::vector< CoordinatePoint > &	vpoints,
		const CombinatorialPlaneSimplex &	simplex,
		Index	idx_below )

inline

Computes an halfspace from dimension points specified by simplex with vertices in a range vpoints of Point. It is oriented such that the point of index idx_below is included in the half-space (i.e. below).

Parameters

[in]	vpoints	a range of points over which the simplex is defined.
[in]	simplex	a range of dimension indices of points defining an hyperplane.
[in]	idx_below	the index of a p-oint that is below the hyperplane.

Returns: the corresponding halfspace (has null normal vector if simplex was not full dimensional)

Definition at line 234 of file QuickHullKernels.h.

    {
      HalfSpace hs = compute( vpoints, simplex );
      if ( hs.N != InternalVector::zero ) 
        {
          const InternalPoint  ip = Inner::cast( vpoints[ idx_below ] );
          const InternalScalar nu = hs.N.dot( ip );
          //const Scalar nu = hs.N.dot( vpoints[ idx_below ] );
          if ( nu > hs.c ) { hs.N = -hs.N; hs.c = -hs.c; }
        }
      return hs;
    }

◆ convertPointTo()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

template<typename OutputPoint>

void DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::convertPointTo	(	const CoordinatePoint &	p,
		OutputPoint &	out_p ) const

inline

Converts an integral point (as represented internally for QuickHull computations) to its corresponding output point representation.

Template Parameters

OutputPoint a model of point such that processing type Point is convertible to it.

Parameters

[in]	p	an integral point (as represented internally for QuickHull computations)
[out]	out_p	its corresponding output point representation.

Note: Each output floating point coordinate is built from integer coordinates a through the formula ( (double) a ) / precision, where precision is the floating point value given at instanciation of the kernel. The last coordinate is not used since it was just related to the lifting of the point onto the "norm" paraboloid, as classically done when computing the Delaunay triangulation from a convex hull.

Definition at line 967 of file QuickHullKernels.h.

    {
      for ( Dimension k = 0; k < dimension - 1; k++ )
        out_p[ k ] = ( (double) p[ k ] ) / precision;
    }

◆ dot()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

InternalScalar DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::dot	(	const HalfSpace &	H1,
		const HalfSpace &	H2 ) const

inline

Equivalent of the dot product of the normals of the half-spaces.

Parameters

H1	an half-space
H2	an half-space

Returns: a positive scalar if both half-spaces points to to the same hemisphere, a negative scalar if they point to opposite hemispheres, and zero if they are orthogonal.

Definition at line 293 of file QuickHullKernels.h.

    {
      return H1.N.dot( H2.N );
    }

◆ equal()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

bool DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::equal	(	const HalfSpace &	H1,
		const HalfSpace &	H2 ) const

inline

Parameters

H1	an half-space
H2	an half-space

Returns: 'true' if the half-spaces have the smae members.

Note: two half-spaces may be not equal but may represent the same set of points. For instance H1={{1,0},3} and H1={{2,0},6}.

Definition at line 306 of file QuickHullKernels.h.

    {
      return H1.c == H2.c && H1.N == H2.N;
    }

◆ hasInfiniteFacets()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

bool DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::hasInfiniteFacets ( ) const

inline

Returns: 'true' if a kernel may induce infinite facets. This is typically the case of a Delaunay computation kernel, which casts points in higher dimension.

Definition at line 876 of file QuickHullKernels.h.

877 { return true; }

◆ height()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

InternalScalar DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::height	(	const HalfSpace &	H,
		const CoordinatePoint &	p ) const

inline

Parameters

H	the half-space
p	any point

Returns: the (signed) height of p wrt this plane.

Definition at line 314 of file QuickHullKernels.h.

315 { return H.N.dot( Inner::cast( p ) ) - H.c; }

◆ intercept()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

CoordinateScalar DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::intercept ( const HalfSpace & H ) const

inline

Parameters

H	the half-space

Returns: the intercept of this facet.

Definition at line 280 of file QuickHullKernels.h.

    {
      return Outer::cast( H.c );
    }

◆ isHalfSpaceFacetInfinite()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

bool DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::isHalfSpaceFacetInfinite ( const HalfSpace & hs ) const

inline

Parameters

[in] hs an half-space corresponding to a facet.

Returns: 'true' if the facet associated to this half-space correspond to an infinite facet.

Definition at line 883 of file QuickHullKernels.h.

    {
      return hs.internalNormal()[ dimension - 1 ] >= InternalScalar( 0 );
    }

◆ makeInput()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

template<typename InputPoint>

void DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::makeInput	(	std::vector< CoordinatePoint > &	processed_points,
		IndexRange &	input2comp,
		IndexRange &	comp2input,
		const std::vector< InputPoint > &	input_points,
		bool	remove_duplicates )

inline

Transforms a range input_points of input points to a range processed_points of points adapted to a processing by QuickHull convex hull algorithm. Keep the mapping information between input and processed points. This kernel transforms dim-dimensional into dim+1-dimensional points, where the last coordinate lies on a paraboloid. This is the classical way for computing a Delaunay triangulation as the convex hull of the points onto a paraboloid of higher dimension.

Template Parameters

InputPoint any model of point whose components are convertible to Scalar.

Parameters

[out]	processed_points	the range of points prepared for a process by QuickHull.
[out]	input2comp	the surjective mapping between the input_points range and the processed_points range used for computation.
[out]	comp2input	the injective mapping between the processed_points range used for computation and the input_points range.
[in]	input_points	the range of input points.
[in]	remove_duplicates	when 'true', this method removes possible duplicates in input_points and processed_points may thus be of smaller size, otherwise, when 'false', it means that there are no duplicates in input_points.

Note: Each floating point input coordinate x is converted to an integer through the following formula (Integer) round( x * precision ), where precision is the floating point value given at instanciation of the kernel. A new coordinate is added so that the point is lifted onto the "norm" paraboloid.

Definition at line 924 of file QuickHullKernels.h.

    {
      const auto F = [&] ( InputPoint input ) -> CoordinatePoint
        {
          CoordinatePoint p;
          CoordinateScalar z = 0;
          for ( Dimension i = 0; i < dimension - 1; i++ ) {
            const CoordinateScalar x
              = CoordinateScalar( round( input[ i ] * precision ) );
            p[ i ] = x;
            z     += x*x;
          }
          p[ dimension-1 ] = z;
          return p;
        };
      DGtal::detail::transform( processed_points, input2comp, comp2input,
                                input_points.cbegin(), input_points.cend(),
                                F, remove_duplicates );
    }

◆ normal()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

CoordinateVector DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::normal ( const HalfSpace & H ) const

inline

Parameters

H	the half-space

Returns: the normal to this facet.

Definition at line 273 of file QuickHullKernels.h.

    {
      return Outer::cast( H.N );
    }

◆ on()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

bool DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::on	(	const HalfSpace &	H,
		const CoordinatePoint &	p ) const

inline

Parameters

H	the half-space
p	any point

Returns: 'true' iff p lies on this plane.

Definition at line 341 of file QuickHullKernels.h.

342 { return height( H, p ) == 0; }

◆ volume()

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

InternalScalar DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::volume	(	const HalfSpace &	H,
		const CoordinatePoint &	p ) const

inline

Parameters

H	the half-space
p	any point

Returns: the volume of the vectors spanned by the simplex and this point.

Definition at line 320 of file QuickHullKernels.h.

    {
      InternalScalar v = height( H, p );
      return v < InternalScalar( 0 ) ? -v : v;
    }

Field Documentation

◆ dimension

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

const Dimension DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::dimension

static

Definition at line 198 of file QuickHullKernels.h.

◆ precision

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>

double DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::precision

The precision as the common denominator for all rational points.

Definition at line 864 of file QuickHullKernels.h.

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

QuickHullKernels.h

Public Types

Public Member Functions

Data Fields

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ Base

◆ LowerSelf

◆ Self

Constructor & Destructor Documentation

◆ DelaunayRationalKernel()

Member Function Documentation

◆ above()

◆ aboveOrOn()

◆ compute() [1/2]

◆ compute() [2/2]

◆ convertPointTo()

◆ dot()

◆ equal()

◆ hasInfiniteFacets()

◆ height()

◆ intercept()

◆ isHalfSpaceFacetInfinite()

◆ makeInput()

◆ normal()

◆ on()

◆ volume()

Field Documentation

◆ dimension

◆ precision