Geogram Version 1.8.5
A programming library of geometric algorithms
Loading...
Searching...
No Matches
GEO::PCK Namespace Reference

PCK (Predicate Construction Kit) implements a set of geometric predicates. PCK uses arithmetic filters (Meyer and Pion), expansion arithmetics (Shewchuk) and simulation of simplicity (Edelsbrunner). More...

Enumerations

enum  SOSMode { SOS_ADDRESS , SOS_LEXICO }
 Mode for symbolic perturbations. More...
 

Functions

template<class T >
bool same_point (const vecng< 3, T > &v1, const vecng< 3, T > &v2)
 
template<class T >
bool same_point (const vecng< 2, T > &v1, const vecng< 2, T > &v2)
 
bool same_point (const vec2HE &v1, const vec2HE &v2)
 
bool same_point (const vec3HE &v1, const vec3HE &v2)
 
Sign orient_2d (const vec2HE &p0, const vec2HE &p1, const vec2HE &p2)
 
Sign orient_2d_projected (const vec3HE &p0, const vec3HE &p1, const vec3HE &p2, coord_index_t axis)
 
Sign orient_3d (const vec3HE &p0, const vec3HE &p1, const vec3HE &p2, const vec3HE &p3)
 
Sign dot_2d (const vec2HE &p0, const vec2HE &p1, const vec2HE &p2)
 
Sign orient_2dlifted_SOS (const vec2HE &p0, const vec2HE &p1, const vec2HE &p2, const vec2HE &p3, double h0, double h1, double h2, double h3)
 Computes the 3d orientation test with lifted points.
 
Sign orient_2dlifted_SOS_projected (const vec3HE &p0, const vec3HE &p1, const vec3HE &p2, const vec3HE &p3, double h0, double h1, double h2, double h3, coord_index_t axis)
 
void set_SOS_mode (SOSMode m)
 Sets the current mode for handling symbolic perturbations (SOS for Simulation Of Simplicity).
 
SOSMode get_SOS_mode ()
 Gets the current mode for handling symbolic perturbations.
 
Sign side1_SOS (const double *p0, const double *p1, const double *q0, coord_index_t DIM)
 Computes the side of a point (given directly) relative to a bisector.
 
Sign side2_SOS (const double *p0, const double *p1, const double *p2, const double *q0, const double *q1, coord_index_t DIM)
 Computes the side of a point (given as the intersection between a segment and a bisector) relative to another bisector.
 
Sign side3_SOS (const double *p0, const double *p1, const double *p2, const double *p3, const double *q0, const double *q1, const double *q2, coord_index_t DIM)
 Computes the side of a point (given as the intersection between a facet and two bisectors) relative to another bisector.
 
Sign side3_3dlifted_SOS (const double *p0, const double *p1, const double *p2, const double *p3, double h0, double h1, double h2, double h3, const double *q0, const double *q1, const double *q2, bool SOS=true)
 Computes the side of a point (given as the intersection between a facet and two bisectors) relative to another bisector.
 
Sign side4_SOS (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4, const double *q0, const double *q1, const double *q2, const double *q3, coord_index_t DIM)
 Computes the side of a point (given as the intersection between a tetrahedron and three bisectors) relative to another bisector.
 
Sign side4_3d (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4)
 Computes the side of a point (given as the intersection between three bisectors) relative to another bisector.
 
Sign side4_3d_SOS (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4)
 Computes the side of a point (given as the intersection between three bisectors) relative to another bisector.
 
Sign in_sphere_3d_SOS (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4)
 Tests whether a 3d point is inside the circumscribed sphere of a 3d tetrahedron.
 
Sign in_circle_2d_SOS (const double *p0, const double *p1, const double *p2, const double *p3)
 Tests whether a 2d point is inside the circumscribed circle of a 3d triangle.
 
Sign in_circle_3d_SOS (const double *p0, const double *p1, const double *p2, const double *p3)
 Tests whether a 3d point is inside the circumscribed circle of a 3d triangle.
 
Sign in_circle_3dlifted_SOS (const double *p0, const double *p1, const double *p2, const double *p3, double h0, double h1, double h2, double h3, bool SOS=true)
 Tests whether a lifted 3d point is inside the circumscribed circle of a lifted 3d triangle.
 
Sign orient_2d (const double *p0, const double *p1, const double *p2)
 Computes the orientation predicate in 3d.
 
Sign orient_2d (const vec2 &p0, const vec2 &p1, const vec2 &p2)
 Computes the orientation predicate in 2d.
 
Sign orient_2dlifted_SOS (const double *p0, const double *p1, const double *p2, const double *p3, double h0, double h1, double h2, double h3)
 Computes the 3d orientation test with lifted points.
 
Sign orient_3d (const double *p0, const double *p1, const double *p2, const double *p3)
 Computes the orientation predicate in 3d.
 
Sign orient_3d (const vec3 &p0, const vec3 &p1, const vec3 &p2, const vec3 &p3)
 Computes the orientation predicate in 3d.
 
Sign orient_3dlifted (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4, double h0, double h1, double h2, double h3, double h4)
 Computes the 4d orientation test.
 
Sign orient_3dlifted_SOS (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4, double h0, double h1, double h2, double h3, double h4)
 Computes the 4d orientation test with symbolic perturbation.
 
Sign det_3d (const double *p0, const double *p1, const double *p2)
 Computes the sign of the determinant of a 3x3 matrix formed by three 3d points.
 
Sign det_4d (const double *p0, const double *p1, const double *p2, const double *p3)
 Computes the sign of the determinant of a 4x4 matrix formed by four 4d points.
 
Sign det_compare_4d (const double *p0, const double *p1, const double *p2, const double *p3, const double *p4)
 Computes the sign of the determinant of a 4x4 matrix formed by three 4d points and the difference of two 4d points.
 
bool aligned_3d (const double *p0, const double *p1, const double *p2)
 Tests whether three points are aligned.
 
Sign dot_3d (const double *p0, const double *p1, const double *p2)
 Computes the sign of the dot product between two vectors.
 
bool aligned_3d (const vec3 &p0, const vec3 &p1, const vec3 &p2)
 Tests whether three points are aligned.
 
Sign dot_3d (const vec3 &p0, const vec3 &p1, const vec3 &p2)
 Computes the sign of the dot product between two vectors.
 
Sign dot_compare_3d (const double *v0, const double *v1, const double *v2)
 Compares two dot products.
 
bool points_are_identical_2d (const double *p1, const double *p2)
 Tests whether two 2d points are identical.
 
bool points_are_identical_3d (const double *p1, const double *p2)
 Tests whether two 3d points are identical.
 
bool points_are_colinear_3d (const double *p1, const double *p2, const double *p3)
 Tests whether three 3d points are colinear.
 
Sign orient_3d_inexact (const double *p0, const double *p1, const double *p2, const double *p3)
 Computes the (approximate) orientation predicate in 3d.
 
void show_stats ()
 Displays some statistics about predicates, including the number of calls, the number of exact arithmetics calls, and the number of Simulation of Simplicity calls.
 
void initialize ()
 Needs to be called before using any predicate.
 
void terminate ()
 Needs to be called at the end of the program.
 

Detailed Description

PCK (Predicate Construction Kit) implements a set of geometric predicates. PCK uses arithmetic filters (Meyer and Pion), expansion arithmetics (Shewchuk) and simulation of simplicity (Edelsbrunner).

Enumeration Type Documentation

◆ SOSMode

Mode for symbolic perturbations.

Definition at line 69 of file predicates.h.

Function Documentation

◆ aligned_3d() [1/2]

bool GEO::PCK::aligned_3d ( const double *  p0,
const double *  p1,
const double *  p2 
)

Tests whether three points are aligned.

Parameters
[in]p0,p1,p2the three points
Return values
trueif the three points are aligned.
falseotherwise.

Function to be tested, use points_are_colinear_3d() instead.

◆ aligned_3d() [2/2]

bool GEO::PCK::aligned_3d ( const vec3 p0,
const vec3 p1,
const vec3 p2 
)
inline

Tests whether three points are aligned.

Parameters
[in]p0,p1,p2the three points
Return values
trueif the three points are aligned.
falseotherwise.

Function to be tested, use points_are_colinear_3d() instead.

Definition at line 612 of file predicates.h.

◆ det_3d()

Sign GEO::PCK::det_3d ( const double *  p0,
const double *  p1,
const double *  p2 
)

Computes the sign of the determinant of a 3x3 matrix formed by three 3d points.

Parameters
[in]p0,p1,p2the three points
Returns
the sign of the determinant of the matrix.

◆ det_4d()

Sign GEO::PCK::det_4d ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3 
)

Computes the sign of the determinant of a 4x4 matrix formed by four 4d points.

Parameters
[in]p0,p1,p2,p3the four points
Returns
the sign of the determinant of the matrix.

◆ det_compare_4d()

Sign GEO::PCK::det_compare_4d ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4 
)

Computes the sign of the determinant of a 4x4 matrix formed by three 4d points and the difference of two 4d points.

Parameters
[in]p0,p1,p2,p3,p4the four points
Returns
the sign of the determinant of the matrix p0 p1 p2 p4-p3

◆ dot_3d() [1/2]

Sign GEO::PCK::dot_3d ( const double *  p0,
const double *  p1,
const double *  p2 
)

Computes the sign of the dot product between two vectors.

Parameters
[in]p0,p1,p2three 3d points.
Returns
the sign of the dot product between the vectors p0p1 and p0p2.

◆ dot_3d() [2/2]

Sign GEO::PCK::dot_3d ( const vec3 p0,
const vec3 p1,
const vec3 p2 
)
inline

Computes the sign of the dot product between two vectors.

Parameters
[in]p0,p1,p2three 3d points.
Returns
the sign of the dot product between the vectors p0p1 and p0p2.

Definition at line 625 of file predicates.h.

◆ dot_compare_3d()

Sign GEO::PCK::dot_compare_3d ( const double *  v0,
const double *  v1,
const double *  v2 
)

Compares two dot products.

Parameters
[in]v0,v1,v2three vectors.
Returns
the sign of v0.v1 - v0.v2

◆ get_SOS_mode()

SOSMode GEO::PCK::get_SOS_mode ( )

Gets the current mode for handling symbolic perturbations.

Returns
one of SOS_ADDRESS, SOS_LEXICO
See also
set_SOS_mode()

◆ in_circle_2d_SOS()

Sign GEO::PCK::in_circle_2d_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3 
)

Tests whether a 2d point is inside the circumscribed circle of a 3d triangle.

Parameters
[in]p0,p1,p2vertices of the triangle
[in]p3the point to be tested
Return values
POSITIVEwhenever p3 is inside the circumscribed circle of the triangle p0, p1, p2
NEGATIVEwhenever p2 is outside the circumscribed circle of the triangle p0, p1, p2
perturb()if p3 is exactly on the circumscribed circle of the triangle p0, p1, p2, where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Precondition
p3 belongs to the plane yielded by p0, p1 and p2

◆ in_circle_3d_SOS()

Sign GEO::PCK::in_circle_3d_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3 
)

Tests whether a 3d point is inside the circumscribed circle of a 3d triangle.

Parameters
[in]p0,p1,p2vertices of the triangle
[in]p3the point to be tested
Return values
POSITIVEwhenever p3 is inside the circumscribed circle of the triangle p0, p1, p2
NEGATIVEwhenever p2 is outside the circumscribed circle of the triangle p0, p1, p2
perturb()if p3 is exactly on the circumscribed circle of the triangle p0, p1, p2, where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Precondition
p3 belongs to the plane yielded by p0, p1 and p2

◆ in_circle_3dlifted_SOS()

Sign GEO::PCK::in_circle_3dlifted_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
double  h0,
double  h1,
double  h2,
double  h3,
bool  SOS = true 
)

Tests whether a lifted 3d point is inside the circumscribed circle of a lifted 3d triangle.

Parameters
[in]p0,p1,p2vertices of the triangle
[in]p3the point to be tested
[in]h0,h1,h2lifted coordinate of the triangle vertices
[in]h3lifted coordinate of the point to be tested
[in]SOSif true, do the symbolic perturbation in the degenerate cases
Return values
POSITIVEwhenever (p3, h3) is inside the circumscribed circle of the triangle (p0,h0) (p1,h1), (p2, h2)
NEGATIVEwhenever (p3, h3) is outside the circumscribed circle of the triangle (p0,h0) (p1,h1), (p2, h2)
perturb()if (p3, h3) is exactly on the circumscribed circle of the triangle (p0,h0) (p1,h1), (p2, h2) where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Precondition
(p3, h3) belongs to the hyperplane yielded by (p0, h0), (p1, h1) and (p2, h2)

◆ in_sphere_3d_SOS()

Sign GEO::PCK::in_sphere_3d_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4 
)

Tests whether a 3d point is inside the circumscribed sphere of a 3d tetrahedron.

Parameters
[in]p0first vertex of the tetrahedron
[in]p1second vertex of the tetrahedron
[in]p2third vertex of the tetrahedron
[in]p3fourth vertex of the tetrahedron
[in]p4the point to be tested
Return values
POSITIVEwhenever p4 is inside the circumscribed sphere of the tetrahedron p0, p1, p2, p3
NEGATIVEwhenever p4 is outside the circumscribed sphere of the tetrahedron p0, p1, p2, p3
perturb()if p4 is exactly on the circumscribed sphere of the tetrahedron p0, p1, p2, p3, where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Precondition
orient_3d(p0,p1,p2,p3) > 0

◆ orient_2d() [1/2]

Sign GEO::PCK::orient_2d ( const double *  p0,
const double *  p1,
const double *  p2 
)

Computes the orientation predicate in 3d.

Computes the sign of the signed area of the triangle p0, p1, p2.

Parameters
[in]p0,p1,p2vertices of the triangle
Return values
POSITIVEif the triangle is oriented positively
ZEROif the triangle is flat
NEGATIVEif the triangle is oriented negatively
Todo:
check whether orientation is inverted as compared to Shewchuk's version.

◆ orient_2d() [2/2]

Sign GEO::PCK::orient_2d ( const vec2 p0,
const vec2 p1,
const vec2 p2 
)
inline

Computes the orientation predicate in 2d.

Computes the sign of the signed area of the triangle p0, p1, p2.

Parameters
[in]p0,p1,p2vertices of the triangle
Return values
POSITIVEif the triangle is oriented positively
ZEROif the triangle is flat
NEGATIVEif the triangle is oriented negatively
Todo:
check whether orientation is inverted as compared to Shewchuk's version.

Definition at line 425 of file predicates.h.

◆ orient_2dlifted_SOS() [1/2]

Sign GEO::PCK::orient_2dlifted_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
double  h0,
double  h1,
double  h2,
double  h3 
)

Computes the 3d orientation test with lifted points.

Given three lifted points p0', p1', p2' in R^2, tests if the lifted point p3' in R^3 lies below or above the plane passing through the three points p0', p1', p2'. The first two coordinates and the third one are specified in separate arguments for each vertex.

Parameters
[in]p0,p1,p2,p3first 2 coordinates of the vertices of the 3-simplex
[in]h0,h1,h2,h3heights of the vertices of the 3-simplex
Return values
POSITIVEif p3' lies below the plane
NEGATIVEif p3' lies above the plane
perturb()if p3' lies exactly on the hyperplane where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE

◆ orient_2dlifted_SOS() [2/2]

Sign GEO::PCK::orient_2dlifted_SOS ( const vec2HE p0,
const vec2HE p1,
const vec2HE p2,
const vec2HE p3,
double  h0,
double  h1,
double  h2,
double  h3 
)

Computes the 3d orientation test with lifted points.

Given three lifted points p0', p1', p2' in R^2, tests if the lifted point p3' in R^3 lies below or above the plane passing through the three points p0', p1', p2'. The first two coordinates and the third one are specified in separate arguments for each vertex.

Parameters
[in]p0,p1,p2,p3first 2 coordinates of the vertices of the 3-simplex
[in]h0,h1,h2,h3heights of the vertices of the 3-simplex
Return values
POSITIVEif p3' lies below the plane
NEGATIVEif p3' lies above the plane
perturb()if p3' lies exactly on the hyperplane where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE

◆ orient_3d() [1/2]

Sign GEO::PCK::orient_3d ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3 
)

Computes the orientation predicate in 3d.

Computes the sign of the signed volume of the tetrahedron p0, p1, p2, p3.

Parameters
[in]p0,p1,p2,p3vertices of the tetrahedron
Return values
POSITIVEif the tetrahedron is oriented positively
ZEROif the tetrahedron is flat
NEGATIVEif the tetrahedron is oriented negatively
Todo:
check whether orientation is inverted as compared to Shewchuk's version.

◆ orient_3d() [2/2]

Sign GEO::PCK::orient_3d ( const vec3 p0,
const vec3 p1,
const vec3 p2,
const vec3 p3 
)
inline

Computes the orientation predicate in 3d.

Computes the sign of the signed volume of the tetrahedron p0, p1, p2, p3.

Parameters
[in]p0,p1,p2,p3vertices of the tetrahedron
Return values
POSITIVEif the tetrahedron is oriented positively
ZEROif the tetrahedron is flat
NEGATIVEif the tetrahedron is oriented negatively
Todo:
check whether orientation is inverted as compared to Shewchuk's version.

Definition at line 486 of file predicates.h.

◆ orient_3d_inexact()

Sign GEO::PCK::orient_3d_inexact ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3 
)
inline

Computes the (approximate) orientation predicate in 3d.

Computes the sign of the (approximate) signed volume of the tetrahedron p0, p1, p2, p3.

Parameters
[in]p0first vertex of the tetrahedron
[in]p1second vertex of the tetrahedron
[in]p2third vertex of the tetrahedron
[in]p3fourth vertex of the tetrahedron
Return values
POSITIVEif the tetrahedron is oriented positively
ZEROif the tetrahedron is flat
NEGATIVEif the tetrahedron is oriented negatively
Todo:
check whether orientation is inverted as compared to Shewchuk's version.

Definition at line 695 of file predicates.h.

◆ orient_3dlifted()

Sign GEO::PCK::orient_3dlifted ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4,
double  h0,
double  h1,
double  h2,
double  h3,
double  h4 
)

Computes the 4d orientation test.

Given four lifted points p0', p1', p2', and p3' in R^4, tests if the lifted point p4' in R^4 lies below or above the hyperplance passing through the four points p0', p1', p2', and p3'. This version does not apply symbolic perturbation. The first three coordinates and the fourth one are specified in separate arguments for each vertex.

Parameters
[in]p0,p1,p2,p3,p4first 3 coordinates of the vertices of the 4-simplex
[in]h0,h1,h2,h3,h4heights of the vertices of the 4-simplex
Return values
POSITIVEif p4' lies below the hyperplane
NEGATIVEif p4' lies above the hyperplane
ZEROif p4' lies exactly on the hyperplane

◆ orient_3dlifted_SOS()

Sign GEO::PCK::orient_3dlifted_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4,
double  h0,
double  h1,
double  h2,
double  h3,
double  h4 
)

Computes the 4d orientation test with symbolic perturbation.

Given four lifted points p0', p1', p2', and p3' in R^4, tests if the lifted point p4' in R^4 lies below or above the hyperplance passing through the four points p0', p1', p2', and p3'. Symbolic perturbation is applied whenever the 5 vertices are not linearly independent. The first three coordinates and the fourth one are specified in separate arguments for each vertex.

Parameters
[in]p0,p1,p2,p3,p4first 3 coordinates of the vertices of the 4-simplex
[in]h0,h1,h2,h3,h4heights of the vertices of the 4-simplex
Return values
POSITIVEif p4' lies below the hyperplane
NEGATIVEif p4' lies above the hyperplane
perturb()if p4' lies exactly on the hyperplane where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE

◆ points_are_colinear_3d()

bool GEO::PCK::points_are_colinear_3d ( const double *  p1,
const double *  p2,
const double *  p3 
)

Tests whether three 3d points are colinear.

Parameters
[in]p1first point
[in]p2second point
[in]p3third point
Return values
trueif p1, p2 and p3 are colinear \retbal false otherwise

◆ points_are_identical_2d()

bool GEO::PCK::points_are_identical_2d ( const double *  p1,
const double *  p2 
)

Tests whether two 2d points are identical.

Parameters
[in]p1first point
[in]p2second point
Return values
trueif p1 and p2 have exactly the same coordinates
falseotherwise

◆ points_are_identical_3d()

bool GEO::PCK::points_are_identical_3d ( const double *  p1,
const double *  p2 
)

Tests whether two 3d points are identical.

Parameters
[in]p1first point
[in]p2second point
Return values
trueif p1 and p2 have exactly the same coordinates
falseotherwise

◆ same_point() [1/2]

template<class T >
bool GEO::PCK::same_point ( const vecng< 2, T > &  v1,
const vecng< 2, T > &  v2 
)
inline

Definition at line 372 of file exact_geometry.h.

◆ same_point() [2/2]

template<class T >
bool GEO::PCK::same_point ( const vecng< 3, T > &  v1,
const vecng< 3, T > &  v2 
)
inline

Definition at line 365 of file exact_geometry.h.

◆ set_SOS_mode()

void GEO::PCK::set_SOS_mode ( SOSMode  m)

Sets the current mode for handling symbolic perturbations (SOS for Simulation Of Simplicity).

Parameters
[in]mone of SOS_ADDRESS, SOS_LEXICO

If SOS_ADDRESS mode is used, then points are supposed to be allocated in a fixed array, and the same point always designated by the same address. If SOS_LEXICO is used then points are sorted in lexicographic order for computing the symbolic perturbation. SOS_LEXICO works for points that are generated dynamically (with no fixed address).

◆ side1_SOS()

Sign GEO::PCK::side1_SOS ( const double *  p0,
const double *  p1,
const double *  q0,
coord_index_t  DIM 
)

Computes the side of a point (given directly) relative to a bisector.

Computes the side of \( q0 \) relative to \( \Pi(p0,p1) \). Symbolic perturbation is applied whenever equality holds.

Parameters
[in]p0,p1extremities of the bisector
[in]q0point to be tested
[in]DIMnumber of coordinates of the point
Return values
POSITIVEif d(p0,q0) < d(p1,q0)
NEGATIVEif d(p0,q0) > d(p1,q1)
perturb()if f(p0,q0) = d(p1,q1), where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Note
Only some specific dimensions are implemented (3,4,6 and 7)

◆ side2_SOS()

Sign GEO::PCK::side2_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  q0,
const double *  q1,
coord_index_t  DIM 
)

Computes the side of a point (given as the intersection between a segment and a bisector) relative to another bisector.

Computes the side of \( q = \Pi(p0,p1) \cap [q0,q1] \) relative to \( \Pi(p0,p2) \). Symbolic perturbation is applied whenever equality holds.

Parameters
[in]p0first extremity of the bisectors
[in]p1second extremity of the first bisector (that defines the intersection q)
[in]p2second extremity of the second bisector (against which orientation is tested)
[in]q0,q1extremities of the segment (that defines the intersection q)
Return values
POSITIVEif d(p0,q) < d(p2,q)
NEGATIVEif d(p0,q) > d(p2,q)
perturb()if d(p0,q) = d(p2,q), where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Note
Only some specific dimensions are implemented (3,4,6 and 7)

◆ side3_3dlifted_SOS()

Sign GEO::PCK::side3_3dlifted_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
double  h0,
double  h1,
double  h2,
double  h3,
const double *  q0,
const double *  q1,
const double *  q2,
bool  SOS = true 
)

Computes the side of a point (given as the intersection between a facet and two bisectors) relative to another bisector.

Computes the side of \( q = \Pi(p0 h0,p1 h1) \cap Pi(p0 h0,p2 h2) \cap \Delta[q0, q1, q2] \) relative to \( \Pi(p0 hp0,p3 hp3) \). Symbolic perturbation is applied whenever equality holds.

Parameters
[in]p0first extremity of the bisectors
[in]p1second extremity of the first bisector (that defines the intersection q)
[in]p2second extremity of the second bisector (that defines the intersection q)
[in]p3second extremity of the third bisector (against which orientation is tested)
h0,h1,h2,h3lifted coordinates of p0, p1, p2 and p3
[in]q0,q1,q2vertices of the triangle (that defines the intersection q)
[in]SOSif true, do the symbolic perturbation in the degenerate case
Return values
POSITIVEif d(p0 hp0,q) < d(p3 hp3, q)
NEGATIVEif d(p0 hp0,q) > d(p3 hp3, q)
perturb()if d(p0 hp0,q) = d(p3 hp3, q), where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE

◆ side3_SOS()

Sign GEO::PCK::side3_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  q0,
const double *  q1,
const double *  q2,
coord_index_t  DIM 
)

Computes the side of a point (given as the intersection between a facet and two bisectors) relative to another bisector.

Computes the side of \( q = \Pi(p0,p1) \cap Pi(p0,p2) \cap \Delta[q0,q1,q2] \) relative to \( \Pi(p0,p3) \). Symbolic perturbation is applied whenever equality holds.

Parameters
[in]p0first extremity of the bisectors
[in]p1second extremity of the first bisector (that defines the intersection q)
[in]p2second extremity of the second bisector (that defines the intersection q)
[in]p3second extremity of the third bisector (against which orientation is tested)
[in]q0,q1,q2vertices of the triangle (that defines the intersection q)
Return values
POSITIVEif d(p0,q) < d(p3,q)
NEGATIVEif d(p0,q) > d(p3,q)
perturb()if d(p0,q) = d(p3,q), where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Note
Only some specific dimensions are implemented (3,4,6 and 7)

◆ side4_3d()

Sign GEO::PCK::side4_3d ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4 
)

Computes the side of a point (given as the intersection between three bisectors) relative to another bisector.

Computes the side of \( q = \Pi(p0,p1) \cap \Pi(p0,p2) \cap \Pi(p0,p3) \) relative to \( Pi(p0,p4) \). This version does not apply symbolic perturbation when equality holds. side4_3d() is a special case of side4(), where the ambient and intrinsic dimensions coincide (therefore no embedding tetrahedron is needed).

Parameters
[in]p0first extremity of the bisectors
[in]p1second extremity of the first bisector (that defines the intersection q)
[in]p2second extremity of the second bisector (that defines the intersection q)
[in]p3second extremity of the third bisector (that defines the intersection q)
[in]p4second extremity of the fourth bisector (against which orientation is tested)
Return values
POSITIVEif d(p0,q) < d(p4,q)
NEGATIVEif d(p0,q) > d(p4,q)
ZEROif d(p0,q) = d(p4,q),

◆ side4_3d_SOS()

Sign GEO::PCK::side4_3d_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4 
)

Computes the side of a point (given as the intersection between three bisectors) relative to another bisector.

Computes the side of \( q = \Pi(p0,p1) \cap \Pi(p0,p2) \cap \Pi(p0,p3) \) relative to \( Pi(p0,p4) \). Symbolic perturbation is applied whenever equality holds. side4_3d() is a special case of side4(), where the ambient and intrinsic dimensions coincide (therefore no embedding tetrahedron is needed).

Parameters
[in]p0first extremity of the bisectors
[in]p1second extremity of the first bisector (that defines the intersection q)
[in]p2second extremity of the second bisector (that defines the intersection q)
[in]p3second extremity of the third bisector (that defines the intersection q)
[in]p4second extremity of the fourth bisector (against which orientation is tested)
Return values
POSITIVEif d(p0,q) < d(p4,q)
NEGATIVEif d(p0,q) > d(p4,q)
perturb()if d(p0,q) = d(p4,q), where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE

◆ side4_SOS()

Sign GEO::PCK::side4_SOS ( const double *  p0,
const double *  p1,
const double *  p2,
const double *  p3,
const double *  p4,
const double *  q0,
const double *  q1,
const double *  q2,
const double *  q3,
coord_index_t  DIM 
)

Computes the side of a point (given as the intersection between a tetrahedron and three bisectors) relative to another bisector.

Computes the side of \( q = \Pi(p0,p1) \cap Pi(p0,p2) \cap Pi(p0,p3) \cap \Delta[q0,q1,q2,q3] \) relative to \( \Pi(p0,p4) \). Symbolic perturbation is applied whenever equality holds.

Parameters
[in]p0first extremity of the bisectors
[in]p1second extremity of the first bisector (that defines the intersection q)
[in]p2second extremity of the second bisector (that defines the intersection q)
[in]p3second extremity of the third bisector (that defines the intersection q)
[in]p4second extremity of the fourth bisector (against which orientation is tested)
[in]q0,q1,q2,q3vertices of the tetrahedron (that defines the intersection q) (that defines the intersection q)
Return values
POSITIVEif d(p0,q) < d(p4,q)
NEGATIVEif d(p0,q) > d(p4,q)
perturb()if d(p0,q) = d(p4,q), where perturb() denotes a globally consistent perturbation, that returns either POSITIVE or NEGATIVE
Note
Only some specific dimensions are implemented (3,4,6 and 7)