CGAL 6.0.1 - dD Geometry Kernel
|
Functions | |
template<class ForwardIterator > | |
Point_d< R > | CGAL::center_of_sphere (ForwardIterator first, ForwardIterator last) |
returns the center of the sphere spanned by the points in A = tuple[first,last) . | |
Point_d< R > | CGAL::lift_to_paraboloid (const Point_d< R > &p) |
returns the projection of p = (x_0,\ldots,x_{d-1}) onto the paraboloid of revolution which is the point (p_0,
\ldots,p_{d-1},\sum_{0 \le i < d}p_i^2) in (d+1)-space. | |
template<class ForwardIterator , class OutputIterator > | |
OutputIterator | CGAL::linear_base (ForwardIterator first, ForwardIterator last, OutputIterator result) |
computes a basis of the linear space spanned by the vectors in A = tuple [first,last) and returns it via an iterator range starting in result . | |
Point_d< R > | CGAL::midpoint (const Point_d< R > &p, const Point_d< R > &q) |
computes the midpoint of the segment pq. | |
Point_d< R > | CGAL::project_along_d_axis (const Point_d< R > &p) |
returns p projected along the d-axis onto the hyperspace spanned by the first d-1 standard base vectors. | |
FT | CGAL::squared_distance (Point_d< R > p, Point_d< R > q) |
computes the square of the Euclidean distance between the two points p and q. | |
bool | CGAL::do_intersect (Type1< R > obj1, Type2< R > obj2) |
checks whether obj1 and obj2 intersect. | |
decltype(auto) | CGAL::intersection (Type1< R > f1, Type2< R > f2) |
returns the intersection between f1 and f2 . | |
template<class ForwardIterator > | |
bool | CGAL::affinely_independent (ForwardIterator first, ForwardIterator last) |
returns true iff the points in A = tuple [first,last) are affinely independent. | |
template<class ForwardIterator > | |
int | CGAL::affine_rank (ForwardIterator first, ForwardIterator last) |
computes the affine rank of the points in A = tuple [first,last) . | |
Comparison_result | CGAL::compare_lexicographically (const Point_d< R > &p, const Point_d< R > &q) |
Compares the Cartesian coordinates of points p and q lexicographically in ascending order of its Cartesian components p[i] and q[i] for i = 0,\ldots,d-1. | |
template<class ForwardIterator > | |
bool | CGAL::contained_in_affine_hull (ForwardIterator first, ForwardIterator last, const Point_d< R > &p) |
determines whether p is contained in the affine hull of the points in A = tuple [first,last) . | |
template<class ForwardIterator > | |
bool | CGAL::contained_in_linear_hull (ForwardIterator first, ForwardIterator last, const Vector_d< R > &v) |
determines whether v is contained in the linear hull of the vectors in A = tuple [first,last) . | |
template<class ForwardIterator > | |
bool | CGAL::contained_in_simplex (ForwardIterator first, ForwardIterator last, const Point_d< R > &p) |
determines whether p is contained in the simplex of the points in A = tuple [first,last) . | |
bool | CGAL::lexicographically_smaller (const Point_d< R > &p, const Point_d< R > &q) |
returns true iff p is lexicographically smaller than q with respect to Cartesian lexicographic order of points. | |
bool | CGAL::lexicographically_smaller_or_equal (const Point_d< R > &p, const Point_d< R > &q) |
returns true iff p is lexicographically smaller than q with respect to Cartesian lexicographic order of points or equal to q. | |
template<class ForwardIterator > | |
bool | CGAL::linearly_independent (ForwardIterator first, ForwardIterator last) |
decides whether the vectors in A = tuple [first,last) are linearly independent. | |
template<class ForwardIterator > | |
int | CGAL::linear_rank (ForwardIterator first, ForwardIterator last) |
computes the linear rank of the vectors in A = tuple [first,last) . | |
template<class ForwardIterator > | |
Orientation | CGAL::orientation (ForwardIterator first, ForwardIterator last) |
determines the orientation of the points of the tuple A = tuple [first,last) where A consists of d+1 points in d-space. | |
template<class ForwardIterator > | |
Bounded_side | CGAL::side_of_bounded_sphere (ForwardIterator first, ForwardIterator last, const Point_d< R > &p) |
returns the relative position of point p to the sphere defined by A = tuple [first,last) . | |
template<class ForwardIterator > | |
Oriented_side | CGAL::side_of_oriented_sphere (ForwardIterator first, ForwardIterator last, const Point_d< R > &p) |
returns the relative position of point p to the oriented sphere defined by the points in A = tuple [first,last) The order of the points in A is important, since it determines the orientation of the implicitly constructed sphere. | |
int CGAL::affine_rank | ( | ForwardIterator | first, |
ForwardIterator | last | ||
) |
#include <CGAL/predicates_d.h>
computes the affine rank of the points in A = tuple [first,last)
.
ForwardIterator | has Point_d<R> as value type. |
bool CGAL::affinely_independent | ( | ForwardIterator | first, |
ForwardIterator | last | ||
) |
#include <CGAL/predicates_d.h>
returns true iff the points in A = tuple [first,last)
are affinely independent.
ForwardIterator | has Point_d<R> as value type. |
Point_d< R > CGAL::center_of_sphere | ( | ForwardIterator | first, |
ForwardIterator | last | ||
) |
#include <CGAL/constructions_d.h>
returns the center of the sphere spanned by the points in A = tuple[first,last)
.
ForwardIterator | has Point_d<R> as value type. |
Comparison_result CGAL::compare_lexicographically | ( | const Point_d< R > & | p, |
const Point_d< R > & | q | ||
) |
#include <CGAL/predicates_d.h>
Compares the Cartesian coordinates of points p
and q
lexicographically in ascending order of its Cartesian components p[i]
and q[i]
for i = 0,\ldots,d-1.
p.dimension() == q.dimension()
. bool CGAL::contained_in_affine_hull | ( | ForwardIterator | first, |
ForwardIterator | last, | ||
const Point_d< R > & | p | ||
) |
#include <CGAL/predicates_d.h>
determines whether p is contained in the affine hull of the points in A = tuple [first,last)
.
A
are of the same dimension.ForwardIterator | has Point_d<R> as value type. |
bool CGAL::contained_in_linear_hull | ( | ForwardIterator | first, |
ForwardIterator | last, | ||
const Vector_d< R > & | v | ||
) |
#include <CGAL/predicates_d.h>
determines whether v is contained in the linear hull of the vectors in A = tuple [first,last)
.
ForwardIterator | has Vector_d<R> as value type. |
bool CGAL::contained_in_simplex | ( | ForwardIterator | first, |
ForwardIterator | last, | ||
const Point_d< R > & | p | ||
) |
#include <CGAL/predicates_d.h>
determines whether p is contained in the simplex of the points in A = tuple [first,last)
.
ForwardIterator | has Point_d<R> as value type. |
bool CGAL::do_intersect | ( | Type1< R > | obj1, |
Type2< R > | obj2 | ||
) |
#include <CGAL/intersections_d.h>
checks whether obj1
and obj2
intersect.
Two objects obj1
and obj2
intersect if there is a point p
that is part of both obj1
and obj2
. The intersection region of those two objects is defined as the set of all points p
that are part of both obj1
and obj2
.
The types Type1
and Type2
can be any of the following:
Point_d<R>
Line_d<R>
Ray_d<R>
Segment_d<R>
Hyperplane_d<R>
intersection
decltype(auto) CGAL::intersection | ( | Type1< R > | f1, |
Type2< R > | f2 | ||
) |
#include <CGAL/intersections_d.h>
returns the intersection between f1
and f2
.
The same functionality is also available through the functor Kernel::Intersect_d
.
The following table gives the possible values for Type1
and Type2
.
The return type of intersecting two objects of the types Type1
and Type2
can be specified through the placeholder type specifier auto
. It is equivalent to std::optional< std::variant< T... > >
, the last column in the table providing the template parameter pack.
Example
The following example demonstrates the most common use of intersection
routines.
#include <CGAL/predicates_d.h>
returns true
iff p
is lexicographically smaller than q
with respect to Cartesian lexicographic order of points.
p.dimension() == q.dimension()
. #include <CGAL/predicates_d.h>
returns true
iff p is lexicographically smaller than q with respect to Cartesian lexicographic order of points or equal to q.
p.dimension() == q.dimension()
. OutputIterator CGAL::linear_base | ( | ForwardIterator | first, |
ForwardIterator | last, | ||
OutputIterator | result | ||
) |
#include <CGAL/constructions_d.h>
computes a basis of the linear space spanned by the vectors in A = tuple [first,last)
and returns it via an iterator range starting in result
.
The returned iterator marks the end of the output.
ForwardIterator | has Vector_d<R> as value type. |
int CGAL::linear_rank | ( | ForwardIterator | first, |
ForwardIterator | last | ||
) |
#include <CGAL/predicates_d.h>
computes the linear rank of the vectors in A = tuple [first,last)
.
ForwardIterator | has Vector_d<R> as value type. |
bool CGAL::linearly_independent | ( | ForwardIterator | first, |
ForwardIterator | last | ||
) |
#include <CGAL/predicates_d.h>
decides whether the vectors in A = tuple [first,last)
are linearly independent.
A
are of the same dimension. ForwardIterator | has Vector_d<R> as value type. |
#include <CGAL/constructions_d.h>
computes the midpoint of the segment pq.
p.dimension() == q.dimension()
. Orientation CGAL::orientation | ( | ForwardIterator | first, |
ForwardIterator | last | ||
) |
#include <CGAL/predicates_d.h>
determines the orientation of the points of the tuple A = tuple [first,last)
where A consists of d+1 points in d-space.
This is the sign of the determinant
\left| \begin{array}{cccc} 1 & 1 & 1 & 1 \\ A[0] & A[1] & \dots& A[d] \end{array} \right|
where A[i]
denotes the Cartesian coordinate vector of the i-th point in A.
size [first,last) == d+1
and A[i].dimension() == d
\forall0 \leq i \leq d.ForwardIterator | has Point_d<R> as value type. |
Bounded_side CGAL::side_of_bounded_sphere | ( | ForwardIterator | first, |
ForwardIterator | last, | ||
const Point_d< R > & | p | ||
) |
#include <CGAL/predicates_d.h>
returns the relative position of point p
to the sphere defined by A = tuple [first,last)
.
The order of the points of A does not matter.
orientation(first,last)
is not ZERO
. ForwardIterator | has Point_d<R> as value type. |
Oriented_side CGAL::side_of_oriented_sphere | ( | ForwardIterator | first, |
ForwardIterator | last, | ||
const Point_d< R > & | p | ||
) |
#include <CGAL/predicates_d.h>
returns the relative position of point p
to the oriented sphere defined by the points in A = tuple [first,last)
The order of the points in A is important, since it determines the orientation of the implicitly constructed sphere.
If the points in A are positively oriented, the positive side is the bounded interior of the sphere.
A
contains d+1 points in d-space. ForwardIterator | has Point_d<R> as value type. |