CGAL 6.2 - 2D and 3D Linear Geometry Kernel

Loading...
Searching...
No Matches
Classes | Typedefs | Enumerations | Functions | Variables
CGAL Namespace Reference

## Classes
class | Aff_transformation_2
| The class `Aff_transformation_2` represents two-dimensional affine transformations. More...
class | Aff_transformation_3
| The class `Aff_transformation_3` represents three-dimensional affine transformations. More...
struct | Ambient_dimension
| The class `Ambient_dimension` allows to retrieve the dimension of the ambient space of a type `T` in a kernel `K`. More...
class | Bbox_2
| An object `b` of the class `Bbox_2` is a bounding box in the two-dimensional Euclidean plane \( \E^2\). More...
class | Bbox_3
| An object `b` of the class `Bbox_3` is a bounding box in the three-dimensional Euclidean space \( \E^3\). More...
struct | Cartesian
| A model for `Kernel` that uses Cartesian coordinates to represent the geometric objects. More...
class | Cartesian_converter
| `Cartesian_converter` converts objects from the kernel traits `K1` to the kernel traits `K2` using `NTConverter` to do the conversion. More...
class | Circle_2
| An object `c` of type `Circle_2` is a circle in the two-dimensional Euclidean plane \( \E^2\). More...
class | Circle_3
| An object `c` of type `Circle_3` is a circle in the three-dimensional Euclidean space \( \E^3\). More...
struct | Dimension_tag
| An object of the class `Dimension_tag` is an empty object which can be used for dispatching functions based on the dimension of an object, as provided by the `dim` parameter. More...
class | Direction_2
| An object `d` of the class `Direction_2` is a vector in the two-dimensional vector space \( \mathbb{R}^2\) where we forget about its length. More...
class | Direction_3
| An object of the class `Direction_3` is a vector in the three-dimensional vector space \( \mathbb{R}^3\) where we forget about their length. More...
struct | Dynamic_dimension_tag
| An object of the class `Dynamic_dimension_tag` is an empty object which can be used for dispatching functions based on the dimension of an object. More...
class | Exact_predicates_exact_constructions_kernel
| A typedef to a kernel which has the following properties: More...
class | Exact_predicates_exact_constructions_kernel_with_kth_root
| A typedef to a kernel which has the following properties: More...
class | Exact_predicates_exact_constructions_kernel_with_root_of
| A typedef to a kernel which has the following properties: More...
class | Exact_predicates_exact_constructions_kernel_with_sqrt
| A typedef to a kernel which has the following properties: More...
class | Exact_predicates_inexact_constructions_kernel
| A typedef to a kernel that has the following properties: More...
struct | Feature_dimension
| The class `Feature_dimension` allows to retrieve the geometric dimension of a type `T` in a kernel `K`. More...
struct | Filtered_kernel
| `Filtered_kernel` is a kernel that uses a filtering technique based on interval arithmetic form to achieve exact and efficient predicates. More...
struct | Filtered_kernel_adaptor
| `Filtered_kernel_adaptor` is a kernel that uses a filtering technique to obtain a kernel with exact and efficient predicate functors. More...
class | Filtered_predicate
| `Filtered_predicate` is an adaptor for predicate function objects that allows one to produce efficient and exact predicates. More...
struct | Homogeneous
| A model for a `Kernel` using homogeneous coordinates to represent the geometric objects. More...
class | Homogeneous_converter
| `Homogeneous_converter` converts objects from the kernel traits `K1` to the kernel traits `K2`. More...
class | Identity_transformation
| Tag class for affine transformations. More...
class | Iso_cuboid_3
| An object `c` of the data type `Iso_cuboid_3` is a cuboid in the Euclidean space \( \E^3\) with edges parallel to the \( x\), \( y\) and \( z\) axis of the coordinate system. More...
class | Iso_rectangle_2
| An object `r` of the data type `Iso_rectangle_2` is a rectangle in the Euclidean plane \( \E^2\) with sides parallel to the \( x\) and \( y\) axis of the coordinate system. More...
struct | Kernel_traits
| The class `Kernel_traits` provides access to the kernel model to which the argument type `T` belongs. More...
class | Line_2
| An object `l` of the data type `Line_2` is a directed straight line in the two-dimensional Euclidean plane \( \E^2\). More...
class | Line_3
| An object `l` of the data type `Line_3` is a directed straight line in the three-dimensional Euclidean space \( \E^3\). More...
class | Null_vector
| CGAL defines a symbolic constant `NULL_VECTOR` to construct zero length vectors. More...
class | Origin
| CGAL defines a symbolic constant `ORIGIN` which denotes the point at the origin. More...
class | Plane_3
| An object `h` of the data type `Plane_3` is an oriented plane in the three-dimensional Euclidean space \( \E^3\). More...
class | Point_2
| An object `p` of the class `Point_2` is a point in the two-dimensional Euclidean plane \( \E^2\). More...
class | Point_3
| An object of the class `Point_3` is a point in the three-dimensional Euclidean space \( \E^3\). More...
class | Projection_traits_3
| The class `Projection_traits_3` works similarly to the `Projection_traits_xy_3`, `Projection_traits_xz_3`, and `Projection_traits_yz_3` traits classes, enabling the use of 2D algorithms on the projections of 3D data onto an arbitrary plane. More...
class | Projection_traits_xy_3
| The class `Projection_traits_xy_3` is an adapter to apply 2D algorithms to the projections of 3D data on the `xy`-plane. More...
class | Projection_traits_xz_3
| The class `Projection_traits_xz_3` is an adapter to apply 2D algorithms to the projections of 3D data on the `xz`-plane. More...
class | Projection_traits_yz_3
| The class `Projection_traits_yz_3` is an adapter to apply 2D algorithms to the projections of 3D data on the `yz`-plane. More...
class | Ray_2
| An object `r` of the data type `Ray_2` is a directed straight ray in the two-dimensional Euclidean plane \( \E^2\). More...
class | Ray_3
| An object `r` of the data type `Ray_3` is a directed straight ray in the three-dimensional Euclidean space \( \E^3\). More...
class | Reflection
| Tag class for affine transformations. More...
class | Rotation
| Tag class for affine transformations. More...
class | Scaling
| Tag class for affine transformations. More...
class | Segment_2
| An object `s` of the data type `Segment_2` is a directed straight line segment in the two-dimensional Euclidean plane \( \E^2\), i.e. a straight line segment \( [p,q]\) connecting two points \( p,q \in \mathbb{R}^2\). More...
class | Segment_3
| An object `s` of the data type `Segment_3` is a directed straight line segment in the three-dimensional Euclidean space \( \E^3\), that is a straight line segment \( [p,q]\) connecting two points \( p,q \in \R^3\). More...
struct | Simple_cartesian
| A model for a `Kernel` using Cartesian coordinates to represent the geometric objects. More...
struct | Simple_homogeneous
| A model for a `Kernel` using homogeneous coordinates to represent the geometric objects. More...
class | Sphere_3
| An object of type `Sphere_3` is a sphere in the three-dimensional Euclidean space \( \E^3\). More...
class | Tetrahedron_3
| An object `t` of the class `Tetrahedron_3` is an oriented tetrahedron in the three-dimensional Euclidean space \( \E^3\). More...
class | Translation
| Tag class for affine transformations. More...
class | Triangle_2
| An object `t` of the class `Triangle_2` is a triangle in the two-dimensional Euclidean plane \( \E^2\). More...
class | Triangle_3
| An object `t` of the class `Triangle_3` is a triangle in the three-dimensional Euclidean space \( \E^3\). More...
class | Vector_2
| An object `v` of the class `Vector_2` is a vector in the two-dimensional vector space \( \mathbb{R}^2\). More...
class | Vector_3
| An object of the class `Vector_3` is a vector in the three-dimensional vector space \( \mathbb{R}^3\). More...
class | Weighted_point_2
| An object of the class `Weighted_point_2` is a tuple of a two-dimensional point and a scalar weight. More...
class | Weighted_point_3
| An object of the class `Weighted_point_3` is a tuple of a three-dimensional point and a scalar weight. More...

## Typedefs
typedef Sign | Orientation

## Enumerations
enum | Angle { OBTUSE , RIGHT , ACUTE }
enum | Bounded_side { ON_UNBOUNDED_SIDE , ON_BOUNDARY , ON_BOUNDED_SIDE }
enum | Comparison_result { SMALLER , EQUAL , LARGER }
enum | Sign { NEGATIVE , ZERO , POSITIVE }
enum | Oriented_side { ON_NEGATIVE_SIDE , ON_ORIENTED_BOUNDARY , ON_POSITIVE_SIDE }
enum | Box_parameter_space_2 { LEFT_BOUNDARY = 0 , RIGHT_BOUNDARY , BOTTOM_BOUNDARY , TOP_BOUNDARY , INTERIOR , EXTERIOR }

## Functions
template<typename T , typename U >
T | enum_cast (const U &u)
| converts between the various enums provided by the CGAL kernel.
Oriented_side | opposite (const Oriented_side &o)
| returns the opposite side (for example `CGAL::ON_POSITIVE_SIDE` if `o`==`CGAL::ON_NEGATIVE_SIDE`), or `CGAL::ON_ORIENTED_BOUNDARY` if `o`==`CGAL::ON_ORIENTED_BOUNDARY`.
Bounded_side | opposite (const Bounded_side &o)
| returns the opposite side (for example `CGAL::ON_BOUNDED_SIDE` if `o`==`CGAL::ON_UNBOUNDED_SIDE`), or returns `CGAL::ON_BOUNDARY` if `o`==`CGAL::ON_BOUNDARY`.
bool | do_intersect (Type1< Kernel > obj1, Type2< Kernel > obj2)
| checks whether `obj1` and `obj2` intersect.
bool | do_intersect (Plane_3< Kernel > obj1, Plane_3< Kernel > obj2, Plane_3< Kernel > obj3)
| checks whether `obj1`, `obj2` and `obj3` intersect.
template<typename Kernel >
decltype(auto) | intersection (Type1< Kernel > obj1, Type2< Kernel > obj2)
| Two objects `obj1` and `obj2` intersect if there is a point `p` that is part of both `obj1` and `obj2`.
template<typename Kernel >
decltype(auto) | intersection (const Plane_3< Kernel > &pl1, const Plane_3< Kernel > &pl2, const Plane_3< Kernel > &pl3)
| returns the intersection of 3 planes, which can be a point, a line, a plane, or empty.
template<typename Kernel >
Angle | angle (const CGAL::Vector_2< Kernel > &u, const CGAL::Vector_2< Kernel > &v)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the two vectors `u` and `v`.
template<typename Kernel >
Angle | angle (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the three points `p`, `q`, `r` (`q` being the vertex of the angle).
template<typename Kernel >
Angle | angle (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &s)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the two vectors `pq`, `rs`.
template<typename Kernel >
Angle | angle (const CGAL::Vector_3< Kernel > &u, const CGAL::Vector_3< Kernel > &v)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the two vectors `u` and `v`.
template<typename Kernel >
Angle | angle (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the three points `p`, `q`, `r` (`q` being the vertex of the angle).
template<typename Kernel >
Angle | angle (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the two vectors `pq`, `rs`.
template<typename Kernel >
Angle | angle (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Vector_3< Kernel > &v)
| returns `CGAL::OBTUSE`, `CGAL::RIGHT` or `CGAL::ACUTE` depending on the angle formed by the normal of the triangle `pqr` and the vector `v`.
template<typename Kernel >
Kernel::FT | approximate_angle (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns an approximation of the angle between `p-q` and `r-q`.
template<typename Kernel >
Kernel::FT | approximate_angle (const CGAL::Vector_3< Kernel > &u, const CGAL::Vector_3< Kernel > &v)
| returns an approximation of the angle between `u` and `v`.
template<typename Kernel >
Kernel::FT | approximate_dihedral_angle (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| returns an approximation of the signed dihedral angle in the tetrahedron `pqrs` of edge `pq`.
template<typename Kernel >
Kernel::FT | area (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns the signed area of the triangle defined by the points `p`, `q` and `r`.
template<typename Kernel >
bool | are_ordered_along_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true`, iff the three points are collinear and `q` lies between `p` and `r`.
template<typename Kernel >
bool | are_ordered_along_line (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true`, iff the three points are collinear and `q` lies between `p` and `r`.
template<typename Kernel >
bool | are_strictly_ordered_along_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true`, iff the three points are collinear and `q` lies strictly between `p` and `r`.
template<typename Kernel >
bool | are_strictly_ordered_along_line (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true`, iff the three points are collinear and `q` lies strictly between `p` and `r`.
template<typename Kernel >
CGAL::Point_2< Kernel > | barycenter (const CGAL::Point_2< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_2< Kernel > &p2)
| compute the barycenter of the points `p1` and `p2` with corresponding weights `w1` and `1-w1`.
template<typename Kernel >
CGAL::Point_2< Kernel > | barycenter (const CGAL::Point_2< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_2< Kernel > &p2, const Kernel::FT &w2)
| compute the barycenter of the points `p1` and `p2` with corresponding weights `w1` and `w2`.
template<typename Kernel >
CGAL::Point_2< Kernel > | barycenter (const CGAL::Point_2< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_2< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_2< Kernel > &p3)
| compute the barycenter of the points `p1`, `p2` and `p3` with corresponding weights `w1`, `w2` and `1-w1-w2`.
template<typename Kernel >
CGAL::Point_2< Kernel > | barycenter (const CGAL::Point_2< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_2< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_2< Kernel > &p3, const Kernel::FT &w3)
| compute the barycenter of the points `p1`, `p2` and `p3` with corresponding weights `w1`, `w2` and `w3`.
template<typename Kernel >
CGAL::Point_2< Kernel > | barycenter (const CGAL::Point_2< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_2< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_2< Kernel > &p3, const Kernel::FT &w3, const CGAL::Point_2< Kernel > &p4)
| compute the barycenter of the points `p1`, `p2`, `p3` and `p4` with corresponding weights `w1`, `w2`, `w3` and `1-w1-w2-w3`.
template<typename Kernel >
CGAL::Point_2< Kernel > | barycenter (const CGAL::Point_2< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_2< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_2< Kernel > &p3, const Kernel::FT &w3, const CGAL::Point_2< Kernel > &p4, const Kernel::FT &w4)
| compute the barycenter of the points `p1`, `p2`, `p3` and `p4` with corresponding weights `w1`, `w2`, `w3` and `w4`.
template<typename Kernel >
CGAL::Point_3< Kernel > | barycenter (const CGAL::Point_3< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_3< Kernel > &p2)
| compute the barycenter of the points `p1` and `p2` with corresponding weights `w1` and `1-w1`.
template<typename Kernel >
CGAL::Point_3< Kernel > | barycenter (const CGAL::Point_3< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_3< Kernel > &p2, const Kernel::FT &w2)
| compute the barycenter of the points `p1` and `p2` with corresponding weights `w1` and `w2`.
template<typename Kernel >
CGAL::Point_3< Kernel > | barycenter (const CGAL::Point_3< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_3< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_3< Kernel > &p3)
| compute the barycenter of the points `p1`, `p2` and `p3` with corresponding weights `w1`, `w2` and `1-w1-w2`.
template<typename Kernel >
CGAL::Point_3< Kernel > | barycenter (const CGAL::Point_3< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_3< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_3< Kernel > &p3, const Kernel::FT &w3)
| compute the barycenter of the points `p1`, `p2` and `p3` with corresponding weights `w1`, `w2` and `w3`.
template<typename Kernel >
CGAL::Point_3< Kernel > | barycenter (const CGAL::Point_3< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_3< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_3< Kernel > &p3, const Kernel::FT &w3, const CGAL::Point_3< Kernel > &p4)
| compute the barycenter of the points `p1`, `p2`, `p3` and `p4` with corresponding weights `w1`, `w2`, `w3` and `1-w1-w2-w3`.
template<typename Kernel >
CGAL::Point_3< Kernel > | barycenter (const CGAL::Point_3< Kernel > &p1, const Kernel::FT &w1, const CGAL::Point_3< Kernel > &p2, const Kernel::FT &w2, const CGAL::Point_3< Kernel > &p3, const Kernel::FT &w3, const CGAL::Point_3< Kernel > &p4, const Kernel::FT &w4)
| compute the barycenter of the points `p1`, `p2`, `p3` and `p4` with corresponding weights `w1`, `w2`, `w3` and `w4`.
template<typename Kernel >
CGAL::Line_2< Kernel > | bisector (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| constructs the bisector line of the two points `p` and `q`.
template<typename Kernel >
CGAL::Line_2< Kernel > | bisector (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2)
| constructs the bisector of the two lines `l1` and `l2`.
template<typename Kernel >
CGAL::Plane_3< Kernel > | bisector (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| constructs the bisector plane of the two points `p` and `q`.
template<typename Kernel >
CGAL::Plane_3< Kernel > | bisector (const CGAL::Plane_3< Kernel > &h1, const CGAL::Plane_3< Kernel > &h2)
| constructs the bisector of the two planes `h1` and `h2`.
template<typename Kernel >
CGAL::Point_2< Kernel > | centroid (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| compute the centroid of the points `p`, `q`, and `r`.
template<typename Kernel >
CGAL::Point_2< Kernel > | centroid (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &s)
| compute the centroid of the points `p`, `q`, `r`, and `s`.
template<typename Kernel >
CGAL::Point_2< Kernel > | centroid (const CGAL::Triangle_2< Kernel > &t)
| compute the centroid of the triangle `t`.
template<typename Kernel >
CGAL::Point_3< Kernel > | centroid (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| compute the centroid of the points `p`, `q`, and `r`.
template<typename Kernel >
CGAL::Point_3< Kernel > | centroid (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| compute the centroid of the points `p`, `q`, `r`, and `s`.
template<typename Kernel >
CGAL::Point_3< Kernel > | centroid (const CGAL::Triangle_3< Kernel > &t)
| compute the centroid of the triangle `t`.
template<typename Kernel >
CGAL::Point_3< Kernel > | centroid (const CGAL::Tetrahedron_3< Kernel > &t)
| compute the centroid of the tetrahedron `t`.
template<typename Kernel >
CGAL::Point_2< Kernel > | circumcenter (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| compute the center of the smallest circle passing through the points `p` and `q`.
template<typename Kernel >
CGAL::Point_2< Kernel > | circumcenter (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| compute the center of the circle passing through the points `p`, `q`, and `r`.
template<typename Kernel >
CGAL::Point_2< Kernel > | circumcenter (const CGAL::Triangle_2< Kernel > &t)
| compute the center of the circle passing through the vertices of `t`.
template<typename Kernel >
CGAL::Point_3< Kernel > | circumcenter (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| compute the center of the smallest sphere passing through the points `p` and `q`.
template<typename Kernel >
CGAL::Point_3< Kernel > | circumcenter (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| compute the center of the circle passing through the points `p`, `q`, and `r`.
template<typename Kernel >
CGAL::Point_3< Kernel > | circumcenter (const CGAL::Triangle_3< Kernel > &t)
| compute the center of the circle passing through the vertices of `t`.
template<typename Kernel >
CGAL::Point_3< Kernel > | circumcenter (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| compute the center of the sphere passing through the points `p`, `q`, `r`, and `s`.
template<typename Kernel >
CGAL::Point_3< Kernel > | circumcenter (const CGAL::Tetrahedron_3< Kernel > &t)
| compute the center of the sphere passing through the vertices of `t`.
template<typename Kernel >
bool | collinear_are_ordered_along_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true`, iff `q` lies between `p` and `r`.
template<typename Kernel >
bool | collinear_are_ordered_along_line (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true`, iff `q` lies between `p` and `r`.
template<typename Kernel >
bool | collinear_are_strictly_ordered_along_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true`, iff `q` lies strictly between `p` and `r`.
template<typename Kernel >
bool | collinear_are_strictly_ordered_along_line (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true`, iff `q` lies strictly between `p` and `r`.
template<typename Kernel >
bool | collinear (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true`, iff `p`, `q`, and `r` are collinear.
template<typename Kernel >
bool | collinear (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true`, iff `p`, `q`, and `r` are collinear.
template<typename Kernel >
Comparison_result | compare_angle (const CGAL::Point_3< Kernel > &a, const CGAL::Point_3< Kernel > &b, const CGAL::Point_3< Kernel > &c, const Kernel::FT &cosine)
| compares the angles \( \theta_1\) and \( \theta_2\), where \( \theta_1\) is the angle in \( [0, \pi]\) of the triangle \( (a, b, c)\) at the vertex `b`, and \( \theta_2\) is the angle in \( [0, \pi]\) such that \( cos(\theta_2) = cosine\).
template<typename Kernel >
Comparison_result | compare_dihedral_angle (const CGAL::Point_3< Kernel > &a1, const CGAL::Point_3< Kernel > &b1, const CGAL::Point_3< Kernel > &c1, const CGAL::Point_3< Kernel > &d1, const Kernel::FT &cosine)
| compares the dihedral angles \( \theta_1\) and \( \theta_2\), where \( \theta_1\) is the dihedral angle, in \( [0, \pi]\), of the tetrahedron `(a1, b1, c1, d1)` at the edge `(a1, b1)`, and \( \theta_2\) is the angle in \( [0, \pi]\) such that \( cos(\theta_2) = cosine\).
template<typename Kernel >
Comparison_result | compare_dihedral_angle (const CGAL::Point_3< Kernel > &a1, const CGAL::Point_3< Kernel > &b1, const CGAL::Point_3< Kernel > &c1, const CGAL::Point_3< Kernel > &d1, const CGAL::Point_3< Kernel > &a2, const CGAL::Point_3< Kernel > &b2, const CGAL::Point_3< Kernel > &c2, const CGAL::Point_3< Kernel > &d2)
| compares the dihedral angles \( \theta_1\) and \( \theta_2\), where \( \theta_i\) is the dihedral angle in the tetrahedron `(a_i, b_i, c_i, d_i)` at the edge `(a_i, b_i)`.
template<typename Kernel >
Comparison_result | compare_dihedral_angle (const CGAL::Vector_3< Kernel > &u1, const CGAL::Vector_3< Kernel > &v1, const CGAL::Vector_3< Kernel > &w1, const Kernel::FT &cosine)
| compares the dihedral angles \( \theta_1\) and \( \theta_2\), where \( \theta_1\) is the dihedral angle, in \( [0, \pi]\), between the vectorial planes defined by `(u_1, v_1)` and `(u_1, w_1)`, and \( \theta_2\) is the angle in \( [0, \pi]\) such that \( cos(\theta_2) = cosine\).
template<typename Kernel >
Comparison_result | compare_dihedral_angle (const CGAL::Vector_3< Kernel > &u1, const CGAL::Vector_3< Kernel > &v1, const CGAL::Vector_3< Kernel > &w1, const CGAL::Vector_3< Kernel > &u2, const CGAL::Vector_3< Kernel > &v2, const CGAL::Vector_3< Kernel > &w2)
| compares the dihedral angles \( \theta_1\) and \( \theta_2\), where \( \theta_i\) is the dihedral angle between the vectorial planes defined by `(u_i, v_i)` and `(u_i, w_i)`.
template<typename Kernel >
Comparison_result | compare_distance_to_point (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| compares the distances of points `q` and `r` to point `p`.
template<typename Kernel >
Comparison_result | compare_distance_to_point (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| compares the distances of points `q` and `r` to point `p`.
template<typename Kernel >
Comparison_result | compare_lexicographically (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically in \( xy\) order: first \( x\)-coordinates are compared, if they are equal, \( y\)-coordinates are compared.
template<typename Kernel >
Comparison_result | compare_lexicographically (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically in \( xyz\) order: first \( x\)-coordinates are compared, if they are equal, \( y\)-coordinates are compared, and if both \( x\)- and \( y\)- coordinate are equal, \( z\)-coordinates are compared.
template<typename Kernel >
Comparison_result | compare_signed_distance_to_line (const CGAL::Line_2< Kernel > &l, const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `CGAL::LARGER` iff the signed distance of `p` and `l` is larger than the signed distance of `q` and `l`, `CGAL::SMALLER`, iff it is smaller, and `CGAL::EQUAL` iff both are equal.
template<typename Kernel >
Comparison_result | compare_signed_distance_to_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &s)
| returns `CGAL::LARGER` iff the signed distance of `r` and `l` is larger than the signed distance of `s` and `l`, `CGAL::SMALLER`, iff it is smaller, and `CGAL::EQUAL` iff both are equal, where `l` is the directed line through `p` and `q`.
template<typename Kernel >
Comparison_result | compare_signed_distance_to_plane (const CGAL::Plane_3< Kernel > &h, const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `CGAL::LARGER` iff the signed distance of `p` and `h` is larger than the signed distance of `q` and `h`, `CGAL::SMALLER`, iff it is smaller, and `CGAL::EQUAL` iff both are equal.
template<typename Kernel >
Comparison_result | compare_signed_distance_to_plane (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s, const CGAL::Point_3< Kernel > &t)
| returns `CGAL::LARGER` iff the signed distance of `s` and `h` is larger than the signed distance of `t` and `h`, `CGAL::SMALLER`, iff it is smaller, and `CGAL::EQUAL` iff both are equal, where `h` is the oriented plane through `p`, `q` and `r`.
template<typename Kernel >
Comparison_result | compare_projection_along_direction_3 (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Direction_3< Kernel > &dir)
| returns `CGAL::SMALLER`, `CGAL::EQUAL`, or `CGAL::LARGER` if the projection of `p` onto a line with direction `dir` precedes, coincides, or follows that of `q` in the direction pointed by `dir`.
template<typename Kernel >
Comparison_result | compare_slope (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2)
| compares the slopes of the lines `l1` and `l2`
template<typename Kernel >
Comparison_result | compare_slope (const CGAL::Segment_2< Kernel > &s1, const CGAL::Segment_2< Kernel > &s2)
| compares the slopes of the segments `s1` and `s2`, where the slope is the variation of the `y`-coordinate from the left to the right endpoint of the segments.
template<typename Kernel >
Comparison_result | compare_slope (const CGAL::Point_2< Kernel > &s1s, const CGAL::Point_2< Kernel > &s1t, const CGAL::Point_2< Kernel > &s2s, const CGAL::Point_2< Kernel > &s2t)
| compares the slopes of the segments `(s1s,s1t)` and `(s2s,s2t)`, where the slope is the variation of the `y`-coordinate from the left to the right endpoint of the segments.
template<typename Kernel >
Comparison_result | compare_slope (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| compares the slopes of the segments `(p,q)` and `(r,s)`, where the slope is the variation of the `z`-coordinate from the first to the second point of the segment divided by the length of the segment.
template<typename Kernel >
Comparison_result | compare_squared_distance (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const typename Kernel::FT &d2)
| compares the squared distance of points `p` and `q` to `d2`.
template<typename Kernel >
Comparison_result | compare_squared_distance (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const typename Kernel::FT &d2)
| compares the squared distance of points `p` and `q` to `d2`.
template<typename Kernel >
Comparison_result | compare_squared_radius (const CGAL::Point_3< Kernel > &p, const typename Kernel::FT &sr)
| compares the squared radius of the sphere of radius 0 centered at `p` to `sr`.
template<typename Kernel >
Comparison_result | compare_squared_radius (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const typename Kernel::FT &sr)
| compares the squared radius of the sphere defined by the points `p` and `q` to `sr`.
template<typename Kernel >
Comparison_result | compare_squared_radius (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const typename Kernel::FT &sr)
| compares the squared radius of the sphere defined by the points `p`, `q`, and `r` to `sr`.
template<typename Kernel >
Comparison_result | compare_squared_radius (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s, const typename Kernel::FT &sr)
| compares the squared radius of the sphere defined by the points `p`, `q`, `r`, and `r` to `sr`.
template<typename Kernel >
Comparison_result | compare_x (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| compares the \( x\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_x (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| compares the \( x\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_x (const CGAL::Point_2< Kernel > &p, const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2)
| compares the \( x\)-coordinates of `p` and the intersection of lines `l1` and `l2`.
template<typename Kernel >
Comparison_result | compare_x (const CGAL::Line_2< Kernel > &l, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| compares the \( x\)-coordinates of the intersection of line `l` with line `h1` and with line `h2`.
template<typename Kernel >
Comparison_result | compare_x (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| compares the \( x\)-coordinates of the intersection of lines `l1` and `l2` and the intersection of lines `h1` and `h2`.
template<typename CircularKernel >
Comparison_result | compare_x (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Circular_arc_point_2< CircularKernel > &q)
| compares the \( x\)-coordinates of `p` and `q`.
template<typename CircularKernel >
Comparison_result | compare_x (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Point_2< CircularKernel > &q)
| compares the \( x\)-coordinates of `p` and `q`.
template<typename SphericalKernel >
Comparison_result | compare_x (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Circular_arc_point_3< SphericalKernel > &q)
| compares the \( x\)-coordinates of `p` and `q`.
template<typename SphericalKernel >
Comparison_result | compare_x (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Point_3< SphericalKernel > &q)
| compares the \( x\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_xy (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically in \( xy\) order: first \( x\)-coordinates are compared, if they are equal, \( y\)-coordinates are compared.
template<typename Kernel >
Comparison_result | compare_xy (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically in \( xy\) order: first \( x\)-coordinates are compared, if they are equal, \( y\)-coordinates are compared.
template<typename CircularKernel >
Comparison_result | compare_xy (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Circular_arc_point_2< CircularKernel > &q)
| Compares the \( x\) and \( y\) Cartesian coordinates of points `p` and `q` lexicographically.
template<typename CircularKernel >
Comparison_result | compare_xy (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Point_2< CircularKernel > &q)
| Compares the \( x\) and \( y\) Cartesian coordinates of points `p` and `q` lexicographically.
template<typename SphericalKernel >
Comparison_result | compare_xy (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Circular_arc_point_3< SphericalKernel > &q)
| Compares the \( x\) and \( y\) Cartesian coordinates of points `p` and `q` lexicographically.
template<typename SphericalKernel >
Comparison_result | compare_xy (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Point_3< SphericalKernel > &q)
| Compares the \( x\) and \( y\) Cartesian coordinates of points `p` and `q` lexicographically.
template<typename Kernel >
Comparison_result | compare_x_at_y (const CGAL::Point_2< Kernel > &p, const CGAL::Line_2< Kernel > &h)
| compares the \( x\)-coordinates of `p` and the horizontal projection of `p` on `h`.
template<typename Kernel >
Comparison_result | compare_x_at_y (const CGAL::Point_2< Kernel > &p, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| This function compares the \( x\)-coordinates of the horizontal projection of `p` on `h1` and on `h2`.
template<typename Kernel >
Comparison_result | compare_x_at_y (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2, const CGAL::Line_2< Kernel > &h)
| Let `p` be the intersection of lines `l1` and `l2`.
template<typename Kernel >
Comparison_result | compare_x_at_y (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| Let `p` be the intersection of lines `l1` and `l2`.
template<typename Kernel >
Comparison_result | compare_y_at_x (const CGAL::Point_2< Kernel > &p, const CGAL::Line_2< Kernel > &h)
| compares the \( y\)-coordinates of `p` and the vertical projection of `p` on `h`.
template<typename Kernel >
Comparison_result | compare_y_at_x (const CGAL::Point_2< Kernel > &p, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| compares the \( y\)-coordinates of the vertical projection of `p` on `h1` and on `h2`.
template<typename Kernel >
Comparison_result | compare_y_at_x (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2, const CGAL::Line_2< Kernel > &h)
| Let `p` be the `intersection` of lines `l1` and `l2`.
template<typename Kernel >
Comparison_result | compare_y_at_x (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| Let `p` be the `intersection` of lines `l1` and `l2`.
template<typename Kernel >
Comparison_result | compare_y_at_x (const CGAL::Point_2< Kernel > &p, const CGAL::Segment_2< Kernel > &s)
| compares the \( y\)-coordinates of `p` and the vertical projection of `p` on `s`.
template<typename Kernel >
Comparison_result | compare_y_at_x (const CGAL::Point_2< Kernel > &p, const CGAL::Segment_2< Kernel > &s1, const CGAL::Segment_2< Kernel > &s2)
| compares the \( y\)-coordinates of the vertical projection of `p` on `s1` and on `s2`.
template<typename Kernel >
Comparison_result | compare_y (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| compares Cartesian \( y\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_y (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| compares Cartesian \( y\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_y (const CGAL::Point_2< Kernel > &p, const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2)
| compares the \( y\)-coordinates of `p` and the intersection of lines `l1` and `l2`.
template<typename Kernel >
Comparison_result | compare_y (const CGAL::Line_2< Kernel > &l, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| compares the \( y\)-coordinates of the intersection of line `l` with line `h1` and with line `h2`.
template<typename Kernel >
Comparison_result | compare_y (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2, const CGAL::Line_2< Kernel > &h1, const CGAL::Line_2< Kernel > &h2)
| compares the \( y\)-coordinates of the intersection of lines `l1` and `l2` and the intersection of lines `h1` and `h2`.
template<typename CircularKernel >
Comparison_result | compare_y (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Circular_arc_point_2< CircularKernel > &q)
| compares the \( y\)-coordinates of `p` and `q`.
template<typename CircularKernel >
Comparison_result | compare_y (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Point_2< CircularKernel > &q)
| compares the \( y\)-coordinates of `p` and `q`.
template<typename SphericalKernel >
Comparison_result | compare_y (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Circular_arc_point_3< SphericalKernel > &q)
| compares the \( y\)-coordinates of `p` and `q`.
template<typename SphericalKernel >
Comparison_result | compare_y (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Point_3< SphericalKernel > &q)
| compares the \( y\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_xyz (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically in \( xyz\) order: first \( x\)-coordinates are compared, if they are equal, \( y\)-coordinates are compared, and if both \( x\)- and \( y\)- coordinate are equal, \( z\)-coordinates are compared.
template<typename SphericalKernel >
Comparison_result | compare_xyz (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Circular_arc_point_3< SphericalKernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically.
template<typename SphericalKernel >
Comparison_result | compare_xyz (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Point_3< SphericalKernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically.
template<typename Kernel >
Comparison_result | compare_z (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| compares the \( z\)-coordinates of `p` and `q`.
template<typename SphericalKernel >
Comparison_result | compare_z (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Circular_arc_point_3< SphericalKernel > &q)
| compares the \( z\)-coordinates of `p` and `q`.
template<typename SphericalKernel >
Comparison_result | compare_z (const CGAL::Circular_arc_point_3< SphericalKernel > &p, const CGAL::Point_3< SphericalKernel > &q)
| compares the \( z\)-coordinates of `p` and `q`.
template<typename Kernel >
Comparison_result | compare_yx (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| Compares the Cartesian coordinates of points `p` and `q` lexicographically in \( yx\) order: first \( y\)-coordinates are compared, if they are equal, \( x\)-coordinates are compared.
template<typename Kernel >
bool | coplanar (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| returns `true`, if `p`, `q`, `r`, and `s` are coplanar.
template<typename Kernel >
Orientation | coplanar_orientation (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| Let `P` be the plane defined by the points `p`, `q`, and `r`.
template<typename Kernel >
Orientation | coplanar_orientation (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| If `p,q,r` are collinear, then `CGAL::COLLINEAR` is returned.
template<typename Kernel >
Bounded_side | coplanar_side_of_bounded_circle (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| returns the bounded side of the circle defined by `p`, `q`, and `r` on which `s` lies.
template<typename Kernel >
CGAL::Vector_3< Kernel > | cross_product (const CGAL::Vector_3< Kernel > &u, const CGAL::Vector_3< Kernel > &v)
| returns the cross product of `u` and `v`.
template<typename Kernel >
Kernel::FT | determinant (const CGAL::Vector_2< Kernel > &v, const CGAL::Vector_2< Kernel > &w)
| returns the determinant of `v` and `w`.
template<typename Kernel >
Kernel::FT | determinant (const CGAL::Vector_3< Kernel > &u, const CGAL::Vector_3< Kernel > &v, const CGAL::Vector_3< Kernel > &w)
| returns the determinant of `u`, `v` and `w`.
template<typename Kernel >
CGAL::Line_3< Kernel > | equidistant_line (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| constructs the line which is at the same distance from the three points `p`, `q` and `r`.
template<typename Kernel >
bool | has_larger_distance_to_point (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true` iff the distance between `q` and `p` is larger than the distance between `r` and `p`.
template<typename Kernel >
bool | has_larger_distance_to_point (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true` iff the distance between `q` and `p` is larger than the distance between `r` and `p`.
template<typename Kernel >
bool | has_larger_signed_distance_to_line (const CGAL::Line_2< Kernel > &l, const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true` iff the signed distance of `p` and `l` is larger than the signed distance of `q` and `l`.
template<typename Kernel >
bool | has_larger_signed_distance_to_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &s)
| returns `true` iff the signed distance of `r` and `l` is larger than the signed distance of `s` and `l`, where `l` is the directed line through points `p` and `q`.
template<typename Kernel >
bool | has_larger_signed_distance_to_plane (const CGAL::Plane_3< Kernel > &h, const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true` iff the signed distance of `p` and `h` is larger than the signed distance of `q` and `h`.
template<typename Kernel >
bool | has_larger_signed_distance_to_plane (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s, const CGAL::Point_3< Kernel > &t)
| returns `true` iff the signed distance of `s` and `h` is larger than the signed distance of `t` and `h`, where `h` is the oriented plane through `p`, `q` and `r`.
template<typename Kernel >
bool | has_smaller_distance_to_point (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true` iff the distance between `q` and `p` is smaller than the distance between `r` and `p`.
template<typename Kernel >
bool | has_smaller_distance_to_point (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns `true` iff the distance between `q` and `p` is smaller than the distance between `r` and `p`.
template<typename Kernel >
bool | has_smaller_signed_distance_to_line (const CGAL::Line_2< Kernel > &l, const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true` iff the signed distance of `p` and `l` is smaller than the signed distance of `q` and `l`.
template<typename Kernel >
bool | has_smaller_signed_distance_to_line (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &s)
| returns `true` iff the signed distance of `r` and `l` is smaller than the signed distance of `s` and `l`, where `l` is the oriented line through `p` and `q`.
template<typename Kernel >
bool | has_smaller_signed_distance_to_plane (const CGAL::Plane_3< Kernel > &h, const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true` iff the signed distance of `p` and `h` is smaller than the signed distance of `q` and `h`.
template<typename Kernel >
bool | has_smaller_signed_distance_to_plane (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s, const CGAL::Point_3< Kernel > &t)
| returns `true` iff the signed distance of `p` and `h` is smaller than the signed distance of `q` and `h`, where `h` is the oriented plane through `p`, `q` and `r`.
template<typename Kernel >
Kernel::FT | l_infinity_distance (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns the distance between `p` and `q` in the L-infinity metric.
template<typename Kernel >
Kernel::FT | l_infinity_distance (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns the distance between `p` and `q` in the L-infinity metric.
template<typename Kernel >
bool | left_turn (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true` iff `p`, `q`, and `r` form a left turn.
template<typename Kernel >
bool | lexicographically_xy_larger (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true` iff `p` is lexicographically larger than `q` with respect to \( xy\) order.
template<typename Kernel >
bool | lexicographically_xy_larger_or_equal (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true` iff `p` is lexicographically not smaller than `q` with respect to \( xy\) order.
template<typename Kernel >
bool | lexicographically_xy_smaller (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true` iff `p` is lexicographically smaller than `q` with respect to \( xy\) order.
template<typename Kernel >
bool | lexicographically_xy_smaller_or_equal (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true` iff `p` is lexicographically not larger than `q` with respect to \( xy\) order.
template<typename Kernel >
bool | lexicographically_xyz_smaller (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true` iff `p` is lexicographically smaller than `q` with respect to \( xyz\) order.
template<typename Kernel >
bool | lexicographically_xyz_smaller_or_equal (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true` iff `p` is lexicographically not larger than `q` with respect to \( xyz\) order.
template<typename Kernel >
CGAL::Point_2< Kernel > | max_vertex (const CGAL::Iso_rectangle_2< Kernel > &ir)
| computes the vertex with the lexicographically largest coordinates of the iso rectangle `ir`.
template<typename Kernel >
CGAL::Point_3< Kernel > | max_vertex (const CGAL::Iso_cuboid_3< Kernel > &ic)
| computes the vertex with the lexicographically largest coordinates of the iso cuboid `ic`.
template<typename Kernel >
CGAL::Point_2< Kernel > | midpoint (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| computes the midpoint of the segment `pq`.
template<typename Kernel >
CGAL::Point_2< Kernel > | midpoint (const CGAL::Segment_2< Kernel > &s)
| computes the midpoint of the segment `s`.
template<typename Kernel >
CGAL::Point_3< Kernel > | midpoint (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| computes the midpoint of the segment `pq`.
template<typename Kernel >
CGAL::Point_3< Kernel > | midpoint (const CGAL::Segment_3< Kernel > &s)
| computes the midpoint of the segment `s`.
template<typename Kernel >
CGAL::Point_2< Kernel > | min_vertex (const CGAL::Iso_rectangle_2< Kernel > &ir)
| computes the vertex with the lexicographically smallest coordinates of the iso rectangle `ir`.
template<typename Kernel >
CGAL::Point_3< Kernel > | min_vertex (const CGAL::Iso_cuboid_3< Kernel > &ic)
| computes the vertex with the lexicographically smallest coordinates of the iso cuboid `ic`.
template<typename Kernel >
CGAL::Vector_3< Kernel > | normal (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| computes the normal vector for the vectors `q-p` and `r-p`.
template<typename Kernel >
Orientation | orientation (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `CGAL::LEFT_TURN`, if `r` lies to the left of the oriented line `l` defined by `p` and `q`, returns `CGAL::RIGHT_TURN` if `r` lies to the right of `l`, and returns `CGAL::COLLINEAR` if `r` lies on `l`.
template<typename Kernel >
Orientation | orientation (const CGAL::Vector_2< Kernel > &u, const CGAL::Vector_2< Kernel > &v)
| returns `CGAL::LEFT_TURN` if `u` and `v` form a left turn, returns `CGAL::RIGHT_TURN` if `u` and `v` form a right turn, and returns `CGAL::COLLINEAR` if `u` and `v` are collinear.
template<typename Kernel >
Orientation | orientation (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| returns `CGAL::POSITIVE`, if `s` lies on the positive side of the oriented plane `h` defined by `p`, `q`, and `r`, returns `CGAL::NEGATIVE` if `s` lies on the negative side of `h`, and returns `CGAL::COPLANAR` if `s` lies on `h`.
template<typename Kernel >
Orientation | orientation (const CGAL::Vector_3< Kernel > &u, const CGAL::Vector_3< Kernel > &v, const CGAL::Vector_3< Kernel > &w)
| returns `CGAL::NEGATIVE` if `u`, `v` and `w` are negatively oriented, `CGAL::POSITIVE` if `u`, `v` and `w` are positively oriented, and `CGAL::COPLANAR` if `u`, `v` and `w` are coplanar.
template<typename Kernel >
CGAL::Vector_3< Kernel > | orthogonal_vector (const CGAL::Plane_3< Kernel > &p)
| computes an orthogonal vector of the plane `p`, which is directed to the positive side of this plane.
template<typename Kernel >
CGAL::Vector_3< Kernel > | orthogonal_vector (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| computes an orthogonal vector of the plane defined by `p`, `q` and `r`, which is directed to the positive side of this plane.
template<typename Kernel >
bool | parallel (const CGAL::Line_2< Kernel > &l1, const CGAL::Line_2< Kernel > &l2)
| returns `true`, if `l1` and `l2` are parallel or if one of those (or both) is degenerate.
template<typename Kernel >
bool | parallel (const CGAL::Ray_2< Kernel > &r1, const CGAL::Ray_2< Kernel > &r2)
| returns `true`, if `r1` and `r2` are parallel or if one of those (or both) is degenerate.
template<typename Kernel >
bool | parallel (const CGAL::Segment_2< Kernel > &s1, const CGAL::Segment_2< Kernel > &s2)
| returns `true`, if `s1` and `s2` are parallel or if one of those (or both) is degenerate.
template<typename Kernel >
bool | parallel (const CGAL::Line_3< Kernel > &l1, const CGAL::Line_3< Kernel > &l2)
| returns `true`, if `l1` and `l2` are parallel or if one of those (or both) is degenerate.
template<typename Kernel >
bool | parallel (const CGAL::Plane_3< Kernel > &h1, const CGAL::Plane_3< Kernel > &h2)
| returns `true`, if `h1` and `h2` are parallel or if one of those (or both) is degenerate.
template<typename Kernel >
bool | parallel (const CGAL::Ray_3< Kernel > &r1, const CGAL::Ray_3< Kernel > &r2)
| returns `true`, if `r1` and `r2` are parallel or if one of those (or both) is degenerate.
template<typename Kernel >
bool | parallel (const CGAL::Segment_3< Kernel > &s1, const CGAL::Segment_3< Kernel > &s2)
| returns `true`, if `s1` and `s2` are parallel or if one of those (or both) is degenerate.
CGAL::Plane_3< Kernel > | radical_plane (const CGAL::Sphere_3< Kernel > &s1, const CGAL::Sphere_3< Kernel > &s2)
| returns the radical plane of the two spheres.
template<typename Kernel >
CGAL::Line_2< Kernel > | radical_line (const CGAL::Circle_2< Kernel > &c1, const CGAL::Circle_2< Kernel > &c2)
| returns the radical line of the two circles.
template<typename Kernel >
bool | right_turn (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| returns `true` iff `p`, `q`, and `r` form a right turn.
template<typename Kernel >
Kernel::FT | scalar_product (const CGAL::Vector_2< Kernel > &u, const CGAL::Vector_2< Kernel > &v)
| returns the scalar product of `u` and `v`.
template<typename Kernel >
Kernel::FT | scalar_product (const CGAL::Vector_3< Kernel > &u, const CGAL::Vector_3< Kernel > &v)
| returns the scalar product of `u` and `v`.
template<typename Kernel >
Bounded_side | side_of_bounded_circle (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &t)
| returns the relative position of point `t` to the circle defined by `p`, `q` and `r`.
template<typename Kernel >
Bounded_side | side_of_bounded_circle (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &t)
| returns the position of the point `t` relative to the circle that has `pq` as its diameter.
template<typename Kernel >
Bounded_side | side_of_bounded_sphere (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s, const CGAL::Point_3< Kernel > &t)
| returns the relative position of point `t` to the sphere defined by `p`, `q`, `r`, and `s`.
template<typename Kernel >
Bounded_side | side_of_bounded_sphere (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &t)
| returns the position of the point `t` relative to the sphere passing through `p`, `q`, and `r` and whose center is in the plane defined by these three points.
template<typename Kernel >
Bounded_side | side_of_bounded_sphere (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &t)
| returns the position of the point `t` relative to the sphere that has `pq` as its diameter.
template<typename Kernel >
Oriented_side | side_of_oriented_circle (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r, const CGAL::Point_2< Kernel > &test)
| returns the relative position of point `test` to the oriented circle defined by `p`, `q` and `r`.
template<typename Kernel >
Oriented_side | side_of_oriented_sphere (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s, const CGAL::Point_3< Kernel > &test)
| returns the relative position of point `test` to the oriented sphere defined by `p`, `q`, `r` and `s`.
template<typename Kernel >
Kernel::FT | squared_area (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| returns the squared area of the triangle defined by the points `p`, `q` and `r`.
template<typename Kernel >
FT | squared_length (const CGAL::Vector_2< Kernel > &v)
| compute the squared length of vector `v`.
template<typename Kernel >
FT | squared_length (const CGAL::Segment_2< Kernel > &s)
| compute the squared length of segment `s`.
template<typename Kernel >
FT | squared_length (const CGAL::Vector_3< Kernel > &v)
| compute the squared length of vector `v`.
template<typename Kernel >
FT | squared_length (const CGAL::Segment_3< Kernel > &s)
| compute the squared length of segment `s`.
template<typename Kernel >
FT | squared_radius (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q, const CGAL::Point_2< Kernel > &r)
| compute the squared radius of the circle passing through the points `p`, `q`, and `r`.
template<typename Kernel >
FT | squared_radius (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| compute the squared radius of the smallest circle passing through `p`, and `q`, i.e. one fourth of the squared distance between `p` and `q`.
template<typename Kernel >
FT | squared_radius (const CGAL::Point_2< Kernel > &p)
| compute the squared radius of the smallest circle passing through `p`, i.e. \( 0\).
template<typename Kernel >
FT | squared_radius (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r, const CGAL::Point_3< Kernel > &s)
| compute the squared radius of the sphere passing through the points `p`, `q`, `r` and `s`.
template<typename Kernel >
FT | squared_radius (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| compute the squared radius of the sphere passing through the points `p`, `q`, and `r` and whose center is in the same plane as those three points.
template<typename Kernel >
FT | squared_radius (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| compute the squared radius of the smallest circle passing through `p`, and `q`, i.e. one fourth of the squared distance between `p` and `q`.
template<typename Kernel >
FT | squared_radius (const CGAL::Point_3< Kernel > &p)
| compute the squared radius of the smallest circle passing through `p`, i.e. \( 0\).
CGAL::Vector_3< Kernel > | unit_normal (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q, const CGAL::Point_3< Kernel > &r)
| computes the unit normal vector for the vectors `q-p` and `r-p`.
template<typename Kernel >
Kernel::FT | volume (const CGAL::Point_3< Kernel > &p0, const CGAL::Point_3< Kernel > &p1, const CGAL::Point_3< Kernel > &p2, const CGAL::Point_3< Kernel > &p3)
| Computes the signed volume of the tetrahedron defined by the four points `p0`, `p1`, `p2` and `p3`.
template<typename Kernel >
bool | x_equal (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true`, iff `p` and `q` have the same `x`-coordinate.
template<typename Kernel >
bool | x_equal (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true`, iff `p` and `q` have the same `x`-coordinate.
template<typename Kernel >
bool | y_equal (const CGAL::Point_2< Kernel > &p, const CGAL::Point_2< Kernel > &q)
| returns `true`, iff `p` and `q` have the same `y`-coordinate.
template<typename Kernel >
bool | y_equal (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true`, iff `p` and `q` have the same `y`-coordinate.
template<typename Kernel >
bool | z_equal (const CGAL::Point_3< Kernel > &p, const CGAL::Point_3< Kernel > &q)
| returns `true`, iff `p` and `q` have the same `z`-coordinate.
template<RingNumberType >
void | rational_rotation_approximation (const RingNumberType &dirx, const RingNumberType &diry, RingNumberType &sin_num, RingNumberType &cos_num, RingNumberType &denom, const RingNumberType &eps_num, const RingNumberType &eps_den)
| computes integers `sin_num`, `cos_num` and `denom`, such that `sin_num`/`denom` approximates the sine of direction \( (\)`dirx`,`diry` \( )\).
template<typename Kernel >
Kernel::FT | squared_distance (Type1< Kernel > obj1, Type2< Kernel > obj2)
| computes the square of the Euclidean distance between two geometric objects.

## Variables
const CGAL::Orientation | CLOCKWISE = NEGATIVE
const CGAL::Orientation | COUNTERCLOCKWISE = POSITIVE
const CGAL::Orientation | COLLINEAR = ZERO
const CGAL::Orientation | LEFT_TURN = POSITIVE
const CGAL::Orientation | RIGHT_TURN = NEGATIVE
const CGAL::Orientation | COPLANAR = ZERO
const CGAL::Orientation | DEGENERATE = ZERO
const CGAL::Null_vector | NULL_VECTOR
| A symbolic constant used to construct zero length vectors.
const CGAL::Origin | ORIGIN
| A symbolic constant which denotes the point at the origin.
template<typename RT >
Point_2< Homogeneous< RT > > | cartesian_to_homogeneous (const Point_2< Cartesian< RT > > &cp)
| Functions to convert between Cartesian and homogeneous kernels.
template<typename RT >
Point_3< Homogeneous< RT > > | cartesian_to_homogeneous (const Point_3< Cartesian< RT > > &cp)
| converts 3D point `cp` with Cartesian representation into a 3D point with homogeneous representation with the same number type.
template<typename FT >
Point_2< Cartesian< FT > > | homogeneous_to_cartesian (const Point_2< Homogeneous< FT > > &hp)
| converts 2D point `hp` with homogeneous representation into a 2D point with Cartesian representation with the same number type.
template<typename FT >
Point_3< Cartesian< FT > > | homogeneous_to_cartesian (const Point_3< Homogeneous< FT > > &hp)
| converts 3D point `hp` with homogeneous representation into a 3D point with Cartesian representation with the same number type.
template<typename RT >
Point_2< Cartesian< Quotient< RT > > > | homogeneous_to_quotient_cartesian (const Point_2< Homogeneous< RT > > &hp)
| converts the 2D point `hp` with homogeneous representation with number type `RT` into a 2D point with Cartesian representation with number type `Quotient<RT>`.
template<typename RT >
Point_3< Cartesian< Quotient< RT > > > | homogeneous_to_quotient_cartesian (const Point_3< Homogeneous< RT > > &hp)
| converts the 3D point `hp` with homogeneous representation with number type `RT` into a 3D point with Cartesian representation with number type `Quotient<RT>`.
template<typename RT >
Point_2< Homogeneous< RT > > | quotient_cartesian_to_homogeneous (const Point_2< Cartesian< Quotient< RT > > > &cp)
| converts 2D point `cp` with Cartesian representation with number type `Quotient<RT>` into a 2D point with homogeneous representation with number type `RT`.
template<typename RT >
Point_3< Homogeneous< RT > > | quotient_cartesian_to_homogeneous (const Point_3< Cartesian< Quotient< RT > > > &cp)
| converts 3D point `cp` with Cartesian representation with number type `Quotient<RT>` into a 3D point with homogeneous representation with number type `RT`.
bool | do_intersect (Type1< CircularKernel > obj1, Type2< CircularKernel > obj2)
| checks whether `obj1` and `obj2` intersect.
template<typename Type1 , typename Type2 , typename OutputIterator >
OutputIterator | intersection (const Type1 &obj1, const Type2 &obj2, OutputIterator intersections)
| Constructs the intersection elements between the two input objects and stores them in the OutputIterator in lexicographic order, where both, `Type1` and `Type2`, can be either.

## With the 2D Circular Kernel
See 2D Circular Geometry Kernel. #include <CGAL/global_functions_circular_kernel_2.h>
template<typename CircularKernel >
Comparison_result | compare_y_at_x (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Circular_arc_2< CircularKernel > &a)
| Same as above, for a point and a circular arc.
template<typename CircularKernel >
Comparison_result | compare_y_at_x (const CGAL::Circular_arc_point_2< CircularKernel > &p, const CGAL::Line_arc_2< CircularKernel > &a)
| Same as above, for a point and a line segment.
bool | do_intersect (Type1< SphericalKernel > obj1, Type2< SphericalKernel > obj2)
| checks whether `obj1` and `obj2` intersect.
bool | do_intersect (Type1< SphericalKernel > obj1, Type2< SphericalKernel > obj2, Type3< SphericalKernel > obj3)
| checks whether `obj1`, `obj2` and `obj3` intersect.
template<typename SphericalType1 , typename SphericalType1 , typename OutputIterator >
OutputIterator | intersection (const SphericalType1 &obj1, const SphericalType2 &obj2, OutputIterator intersections)
| Constructs the intersection elements between the two input objects and stores them in the OutputIterator in lexicographic order, where both, `SphericalType1` and `SphericalType2`, can be either.
template<typename Type1 , typename Type2 , typename Type3 , typename OutputIterator >
OutputIterator | intersection (const Type1 &obj1, const Type2 &obj2, const Type3 &obj3, OutputIterator intersections)
| Copies in the output iterator the intersection elements between the three objects.