DGtal 1.3.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Data Fields | Static Public Attributes
DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger > Struct Template Reference

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 >:
DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >

Public Types

typedef ConvexHullCommonKernel< dim+1, TCoordinateInteger, TInternalInteger > Base
 
typedef DGtal::PointVector< dim, CoordinateIntegerCoordinatePoint
 
typedef DGtal::PointVector< dim, CoordinateIntegerCoordinateVector
 
typedef CoordinateInteger CoordinateScalar
 
typedef DGtal::PointVector< dim, InternalIntegerInternalPoint
 
typedef DGtal::PointVector< dim, InternalIntegerInternalVector
 
typedef InternalInteger InternalScalar
 
typedef std::size_t Size
 
typedef Size Index
 
typedef std::vector< IndexIndexRange
 
typedef std::array< Index, dimCombinatorialPlaneSimplex
 
- Public Types inherited from DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >
typedef TCoordinateInteger CoordinateInteger
 
typedef TInternalInteger InternalInteger
 
typedef CoordinateInteger CoordinateScalar
 
typedef InternalInteger InternalScalar
 
typedef DGtal::PointVector< dim, CoordinateIntegerCoordinatePoint
 
typedef DGtal::PointVector< dim, CoordinateIntegerCoordinateVector
 
typedef DGtal::PointVector< dim, InternalIntegerInternalPoint
 
typedef DGtal::PointVector< dim, InternalIntegerInternalVector
 
typedef std::size_t Size
 
typedef Size Index
 
typedef std::vector< IndexIndexRange
 
typedef std::array< Index, dimCombinatorialPlaneSimplex
 
typedef IntegerConverter< dim, CoordinateIntegerOuter
 Converter to outer coordinate integers or lattice points / vector. More...
 
typedef IntegerConverter< dim, InternalIntegerInner
 Converter to inner internal integers or lattice points / vector. More...
 

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, TCoordinateInteger, TInternalInteger >
 BOOST_CONCEPT_ASSERT ((concepts::CInteger< TCoordinateInteger >))
 
 BOOST_CONCEPT_ASSERT ((concepts::CInteger< TInternalInteger >))
 
 ConvexHullCommonKernel ()=default
 Default constructor. More...
 
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
 

Data Fields

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

Static Public Attributes

static const Dimension dimension
 
- Static Public Attributes inherited from DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >
static const Dimension dimension = dim
 

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
dimthe dimension of the space of processed points.
TCoordinateIntegerthe integer type that represents coordinates of lattice points, a model of concepts::CInteger.
TInternalIntegerthe 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 830 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 833 of file QuickHullKernels.h.

◆ CombinatorialPlaneSimplex

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef std::array< Index, dim > DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::CombinatorialPlaneSimplex

Definition at line 195 of file QuickHullKernels.h.

◆ CoordinatePoint

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef DGtal::PointVector< dim, CoordinateInteger > DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::CoordinatePoint

Definition at line 188 of file QuickHullKernels.h.

◆ CoordinateScalar

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef CoordinateInteger DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::CoordinateScalar

Definition at line 184 of file QuickHullKernels.h.

◆ CoordinateVector

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef DGtal::PointVector< dim, CoordinateInteger > DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::CoordinateVector

Definition at line 189 of file QuickHullKernels.h.

◆ Index

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef Size DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::Index

Definition at line 193 of file QuickHullKernels.h.

◆ IndexRange

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef std::vector< Index > DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::IndexRange

Definition at line 194 of file QuickHullKernels.h.

◆ InternalPoint

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef DGtal::PointVector< dim, InternalInteger > DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::InternalPoint

Definition at line 190 of file QuickHullKernels.h.

◆ InternalScalar

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef InternalInteger DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::InternalScalar

Definition at line 185 of file QuickHullKernels.h.

◆ InternalVector

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef DGtal::PointVector< dim, InternalInteger > DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::InternalVector

Definition at line 191 of file QuickHullKernels.h.

◆ Size

template<Dimension dim, typename TCoordinateInteger = DGtal::int64_t, typename TInternalInteger = DGtal::int64_t>
typedef std::size_t DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::Size

Definition at line 192 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]aPrecisionthe chosen precision as the common denominator of all rationals (by defaut, 1024).

Definition at line 870 of file QuickHullKernels.h.

871 : precision( aPrecision ) {}
double precision
The precision as the common denominator for all rational points.

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
Hthe half-space
pany point
Returns
'true' iff p is strictly above this plane (so in direction N ).

Definition at line 334 of file QuickHullKernels.h.

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

◆ 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
Hthe half-space
pany point
Returns
'true' iff p is above or lies on this plane (so in direction N ).

Definition at line 340 of file QuickHullKernels.h.

341 { 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 degenrated, the half-space is invalid and has null normal.

Parameters
[in]vpointsa range of points over which the simplex is defined.
[in]simplexa 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 257 of file QuickHullKernels.h.

259 {
261 Matrix A;
264 for ( Dimension i = 1; i < dimension; i++ )
265 for ( Dimension j = 0; j < dimension; j++ )
266 A.setComponent( i-1, j,
267 Inner::cast( vpoints[ simplex[ i ] ][ j ]
268 - vpoints[ simplex[ 0 ] ][ j ] ) );
269 for ( Dimension j = 0; j < dimension; j++ )
270 N[ j ] = A.cofactor( dimension-1, j );
271 const InternalPoint ip = Inner::cast( vpoints[ simplex[ 0 ] ] );
272 // c = N.dot( vpoints[ simplex[ 0 ] ] );
273 return HalfSpace { N, N.dot( ip ) };
274 }
Aim: implements basic MxN Matrix services (M,N>=1).
Definition: SimpleMatrix.h:76
DGtal::uint32_t Dimension
Definition: Common.h:137
DGtal::PointVector< dim, InternalInteger > InternalVector
DGtal::PointVector< dim, InternalInteger > InternalPoint
static const Dimension dimension
static Integer cast(Integer i)

◆ 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]vpointsa range of points over which the simplex is defined.
[in]simplexa range of dimension indices of points defining an hyperplane.
[in]idx_belowthe 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 230 of file QuickHullKernels.h.

233 {
234 HalfSpace hs = compute( vpoints, simplex );
235 if ( hs.N != InternalVector::zero )
236 {
237 const InternalPoint ip = Inner::cast( vpoints[ idx_below ] );
238 const InternalScalar nu = hs.N.dot( ip );
239 //const Scalar nu = hs.N.dot( vpoints[ idx_below ] );
240 if ( nu > hs.c ) { hs.N = -hs.N; hs.c = -hs.c; }
241 }
242 return hs;
243 }
static Self zero
Static const for zero PointVector.
Definition: PointVector.h:1595
HalfSpace compute(const std::vector< CoordinatePoint > &vpoints, const CombinatorialPlaneSimplex &simplex, Index idx_below)

◆ 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
OutputPointa model of point such that processing type Point is convertible to it.
Parameters
[in]pan integral point (as represented internally for QuickHull computations)
[out]out_pits 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.

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

References DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::dimension, and DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::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
H1an half-space
H2an 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 298 of file QuickHullKernels.h.

299 {
300 return H1.N.dot( H2.N );
301 }

◆ 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
H1an half-space
H2an 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 311 of file QuickHullKernels.h.

312 {
313 return H1.c == H2.c && H1.N == H2.N;
314 }

◆ 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
Hthe half-space
pany point
Returns
the (signed) height of p wrt this plane.

Definition at line 319 of file QuickHullKernels.h.

320 { 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
Hthe half-space
Returns
the intercept of this facet.

Definition at line 285 of file QuickHullKernels.h.

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

◆ 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]hsan 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.

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

References DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::dimension, and DGtal::ConvexHullCommonKernel< dim, TCoordinateInteger, TInternalInteger >::HalfSpace::internalNormal().

◆ 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
InputPointany model of point whose components are convertible to Scalar.
Parameters
[out]processed_pointsthe range of points prepared for a process by QuickHull.
[out]input2compthe surjective mapping between the input_points range and the processed_points range used for computation.
[out]comp2inputthe injective mapping between the processed_points range used for computation and the input_points range.
[in]input_pointsthe range of input points.
[in]remove_duplicateswhen '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.

928 {
929 const auto F = [&] ( InputPoint input ) -> CoordinatePoint
930 {
932 CoordinateScalar z = 0;
933 for ( Dimension i = 0; i < dimension - 1; i++ ) {
934 const CoordinateScalar x
935 = CoordinateScalar( round( input[ i ] * precision ) );
936 p[ i ] = x;
937 z += x*x;
938 }
939 p[ dimension-1 ] = z;
940 return p;
941 };
942 DGtal::detail::transform( processed_points, input2comp, comp2input,
943 input_points.cbegin(), input_points.cend(),
944 F, remove_duplicates );
945 }
void transform(std::vector< OutputValue > &output_values, std::vector< std::size_t > &input2output, std::vector< std::size_t > &output2input, ForwardIterator itb, ForwardIterator ite, const ConversionFct &F, bool remove_duplicates)
CoordinateInteger CoordinateScalar
DGtal::PointVector< dim, CoordinateInteger > CoordinatePoint

References DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::dimension, and DGtal::detail::transform().

◆ 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
Hthe half-space
Returns
the normal to this facet.

Definition at line 278 of file QuickHullKernels.h.

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

◆ 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
Hthe half-space
pany point
Returns
'true' iff p lies on this plane.

Definition at line 346 of file QuickHullKernels.h.

347 { 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
Hthe half-space
pany point
Returns
the volume of the vectors spanned by the simplex and this point.

Definition at line 325 of file QuickHullKernels.h.

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

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

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

Referenced by DGtal::DelaunayRationalKernel< dim, TCoordinateInteger, TInternalInteger >::convertPointTo().


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