CGAL 6.2 - 3D Triangulations

Loading...
Searching...
No Matches
List of all members
CGAL::Regular_triangulation_3< Traits, TDS, SLDS > Class Template Reference
Reference Manual » Triangulation Classes

`#include <CGAL/Regular_triangulation_3.h>`

## Inherits from

CGAL::Triangulation_3< Traits, TDS, SLDS >.

## Definition

template<typename Traits, typename TDS, typename SLDS>
class CGAL::Regular_triangulation_3< Traits, TDS, SLDS >

Let \( {S}^{(w)}\) be a set of weighted points in \( \mathbb{R}^3\).

Let \( {p}^{(w)}=(p,w_p), p\in\mathbb{R}^3, w_p\in\mathbb{R}\) and \( {z}^{(w)}=(z,w_z), z\in\mathbb{R}^3, w_z\in\mathbb{R}\) be two weighted points. A weighted point \( {p}^{(w)}=(p,w_p)\) can also be seen as a sphere of center \( p\) and radius \( \sqrt{w_p}\). The power product (or power distance ) between \( {p}^{(w)}\) and \( {z}^{(w)}\) is defined as

\[ \Pi({p}^{(w)},{z}^{(w)}) = {\|{p-z}\|^2-w_p-w_z} \]

where \( \|{p-z}\|\) is the Euclidean distance between \( p\) and \( z\). \( {p}^{(w)}\) and \( {z}^{(w)}\) are said to be orthogonal if \( \Pi{({p}^{(w)}-{z}^{(w)})} = 0\) (see Figure 48.2).

Four weighted points have a unique common orthogonal weighted point called the power sphere. A sphere \( {z}^{(w)}\) is said to be regular if \( \forall {p}^{(w)}\in{S}^{(w)}, \Pi{({p}^{(w)}-{z}^{(w)})}\geq 0\).

A triangulation of \( {S}^{(w)}\) is regular if the power spheres of all simplices are regular.

Template Parameters

  Traits | is the geometric traits class, and must be a model of `RegularTriangulationTraits_3`
  TDS | is the triangulation data structure and must be a model of `TriangulationDataStructure_3`. `Default` may be used with default value `Triangulation_data_structure_3<Regular_triangulation_vertex_base_3<Traits>, Regular_triangulation_cell_base_3<Traits> >`. Any custom type can be used instead of `Regular_triangulation_vertex_base_3` and `Regular_triangulation_cell_base_3`, provided that they are models of the concepts `RegularTriangulationVertexBase_3` and `RegularTriangulationCellBase_3`, respectively.
  SLDS | is an optional parameter to specify the type of the spatial lock data structure. It must be a model of the `SurjectiveLockDataStructure` concept, with `object` being a `Point`. It is only used if the triangulation data structure used is concurrency-safe (i.e. when `TDS::Concurrency_tag` is `Parallel_tag`). The default value is `Spatial_lock_grid_3<Tag_priority_blocking>` if the triangulation data structure is concurrency-safe, and `void` otherwise. In order to use concurrent operations, the user must provide a reference to a `SLDS` instance via the constructor or `Triangulation_3::set_lock_data_structure`.

If `TDS::Concurrency_tag` is `Parallel_tag`, some operations, such as insertion/removal of a range of points, are performed in parallel. See the documentation of the operations for more details.

See also
  `CGAL::Triangulation_3`
  `CGAL::Delaunay_triangulation_3`

Examples
  Triangulation_3/parallel_insertion_and_removal_in_regular_3.cpp, Triangulation_3/regular_3.cpp, and Triangulation_3/regular_with_info_3.cpp.

## Types
typedef Traits::Point_3 | Bare_point
| The type for points `p` of weighted points \( {p}^{(w)}=(p,w_p)\).
typedef Traits::Weighted_point_3 | Weighted_point
| The type for weighted points.
typedef SLDS | Lock_data_structure

## Creation
| Regular_triangulation_3 (const Traits &traits=Traits(), Lock_data_structure *lock_ds=nullptr)
| Creates an empty regular triangulation, possibly specifying a traits class `traits`.
| Regular_triangulation_3 (const Regular_triangulation_3 &rt1)
| Copy constructor.
template<class InputIterator >
| Regular_triangulation_3 (InputIterator first, InputIterator last, const Traits &traits=Traits(), Lock_data_structure *lock_ds=nullptr)
| Equivalent to constructing an empty triangulation with the optional traits class argument and calling `insert(first,last)`.
template<class InputIterator >
| Regular_triangulation_3 (InputIterator first, InputIterator last, Lock_data_structure *lock_ds, const Traits &traits=Traits())
| Same as before, with last two parameters in reverse order.

## Insertion
The following methods, which already exist in `Triangulation_3`, are overloaded to ensure the property that all power spheres are regular. The following method allows one to insert several points.
Vertex_handle | insert (const Weighted_point &p, Cell_handle start=Cell_handle(), bool *could_lock_zone=nullptr)
| Inserts the weighted point `p` in the triangulation.
Vertex_handle | insert (const Weighted_point &p, Vertex_handle hint, bool *could_lock_zone=nullptr)
| Same as above but uses `hint` as a starting place for the search.
Vertex_handle | insert (const Weighted_point &p, Locate_type lt, Cell_handle loc, int li, int lj, bool *could_lock_zone=nullptr)
| Inserts the weighted point `p` in the triangulation and returns the corresponding vertex.
template<class InputIterator >
std::ptrdiff_t | insert (InputIterator first, InputIterator last)
| Inserts the weighted points in the range `[first,last)`.
template<class WeightedPointWithInfoInputIterator >
std::ptrdiff_t | insert (WeightedPointWithInfoInputIterator first, WeightedPointWithInfoInputIterator last)
| Inserts the weighted points in the iterator range `[first,last)`.
The following methods, which already exist in `Triangulation_3`, are overloaded to ensure that hidden points are well created and maintained.
template<class CellIt >
Vertex_handle | insert_in_hole (const Weighted_point &p, CellIt cell_begin, CellIt cell_end, Cell_handle begin, int i)
| Creates a new vertex by starring a hole.
template<class CellIt >
Vertex_handle | insert_in_hole (const Weighted_point &p, CellIt cell_begin, CellIt cell_end, Cell_handle begin, int i, Vertex_handle newv)
| Same as above, except that `newv` will be used as the new vertex, which must have been allocated previously with, e.g. `create_vertex`.

## Removal
void | remove (Vertex_handle v)
| Removes the vertex `v` from the triangulation.
bool | remove (Vertex_handle v, bool *could_lock_zone)
| Removes the vertex `v` from the triangulation.
template<typename InputIterator >
int | remove (InputIterator first, InputIterator beyond)
| Removes the vertices specified by the iterator range `[first, beyond)`.

## Queries
Let us remark that \( \Pi({p}^{(w)}-{z}^{(w)}) > 0 \) is equivalent to `p` lies outside the sphere with center `z` and radius \( \sqrt{w_p^2+w_z^2}\). This remark helps provide an intuition about the following predicates. side_of_power_circle
Bounded_side | side_of_power_sphere (Cell_handle c, const Weighted_point &p) const
| Returns the position of the weighted point \( p\) with respect to the power sphere of `c`.
Bounded_side | side_of_power_circle (const Facet &f, const Weighted_point &p) const
| Returns the position of the point `p` with respect to the power circle of `f`.
Bounded_side | side_of_power_circle (Cell_handle c, int i, const Weighted_point &p) const
| Same as the previous method for facet `i` of cell `c`.
Bounded_side | side_of_power_segment (Cell_handle c, const Weighted_point &p) const
| In dimension 1, returns.
Vertex_handle | nearest_power_vertex (const Bare_point &p, Cell_handle c=Cell_handle())
| Returns the vertex of the triangulation which is nearest to \( p\) with respect to the power distance.
Vertex_handle | nearest_power_vertex_in_cell (const Bare_point &p, Cell_handle c)
| Returns the vertex of the cell `c` that is nearest to \( p\) with respect to the power distance.
A weighted point `p` is said to be in conflict with a cell `c` in dimension 3 (resp. with a facet `f` in dimension 2) if it has a negative power distance to the power sphere of `c` (resp. to the power circle of `f`). The set of cells (resp. facets in dimension 2) which are in conflict with `p` is connected.
template<class OutputIteratorBoundaryFacets , class OutputIteratorCells , class OutputIteratorInternalFacets >
Triple< OutputIteratorBoundaryFacets, OutputIteratorCells, OutputIteratorInternalFacets > | find_conflicts (const Weighted_point p, Cell_handle c, OutputIteratorBoundaryFacets bfit, OutputIteratorCells cit, OutputIteratorInternalFacets ifit, bool *could_lock_zone=nullptr, const Facet *this_facet_must_be_in_the_cz=nullptr, bool *the_facet_is_in_its_cz=nullptr)
| Compute the conflicts with `p`.
template<class OutputIterator >
OutputIterator | vertices_in_conflict (const Weighted_point &p, Cell_handle c, OutputIterator res)
template<class OutputIterator >
OutputIterator | vertices_on_conflict_zone_boundary (const Weighted_point &p, Cell_handle c, OutputIterator res)
| Similar to `find_conflicts()`, but reports the vertices which are on the boundary of the conflict zone of `p`, in the output iterator `res`.
template<class OutputIterator >
OutputIterator | vertices_inside_conflict_zone (const Weighted_point &p, Cell_handle c, OutputIterator res)
| Similar to `find_conflicts()`, but reports the vertices which are in the interior of the conflict zone of `p`, in the output iterator `res`.
In the weighted setting, a face (cell, facet, edge or vertex) is said to be a Gabriel face iff the smallest sphere orthogonal to the weighted points associated to its vertices, has a positive power product with the weighted point of any other vertex of the triangulation. Any weighted Gabriel face belongs to the regular triangulation, but the reciprocal is not true. The following member functions test the Gabriel property of the faces of the regular triangulation.
bool | is_Gabriel (Cell_handle c, int i)
bool | is_Gabriel (Cell_handle c, int i, int j)
bool | is_Gabriel (const Facet &f)
bool | is_Gabriel (const Edge &e)
bool | is_Gabriel (Vertex_handle v)

## Power Diagram
CGAL offers several functionalities to display the power diagram of a set of points in 3D. Note that the user should use a kernel with exact constructions in order to guarantee the computation of the Voronoi diagram (as opposed to computing the triangulation only, which requires only exact predicates).
Bare_point | dual (Cell_handle c) const
| Returns the weighted circumcenter of the four vertices of c.
Object | dual (Facet f) const
| Returns the dual of facet `f`, which is.
Object | dual (Cell_handle c, int i) const
| same as the previous method for facet `(c,i)`.
template<class Stream >
Stream & | draw_dual (Stream &os)
| Writes the set of duals to all the facets of the regular triangulation into `os`.

## Checking
bool | is_valid (bool verbose=false) const
| This is a function for debugging purpose.

## Additional Inherited Members
Public Types inherited from CGAL::Triangulation_3< Traits, TDS, SLDS >
enum | Locate_type { VERTEX =0 , EDGE , FACET , CELL , OUTSIDE_CONVEX_HULL , OUTSIDE_AFFINE_HULL }
| The enum `Locate_type` is defined by `Triangulation_3` to specify which case occurs when locating a point in the triangulation. More...
typedef Traits | Geom_traits
typedef TDS | Triangulation_data_structure
typedef SLDS | Lock_data_structure
typedef Triangulation_data_structure::Vertex::Point | Point
typedef Geom_traits::Segment_3 | Segment
typedef Geom_traits::Triangle_3 | Triangle
typedef Geom_traits::Tetrahedron_3 | Tetrahedron
typedef Triangulation_data_structure::Vertex | Vertex
typedef Triangulation_data_structure::Cell | Cell
typedef Triangulation_data_structure::Facet | Facet
typedef Triangulation_data_structure::Edge | Edge
typedef Triangulation_data_structure::Concurrency_tag | Concurrency_tag
| Concurrency tag (from the TDS).
typedef Triangulation_data_structure::Vertex_handle | Vertex_handle
| handle to a vertex
typedef Triangulation_data_structure::Cell_handle | Cell_handle
| handle to a cell
typedef Triangulation_simplex_3< Self > | Simplex
| Reference to a simplex (vertex, edge, facet or cell) of the triangulation.
typedef Triangulation_data_structure::size_type | size_type
| Size type (an unsigned integral type)
typedef Triangulation_data_structure::difference_type | difference_type
| Difference type (a signed integral type)
typedef Triangulation_data_structure::Cell_iterator | All_cells_iterator
| iterator over cells
typedef Triangulation_data_structure::Facet_iterator | All_facets_iterator
| iterator over facets
typedef Triangulation_data_structure::Edge_iterator | All_edges_iterator
| iterator over edges
typedef Triangulation_data_structure::Vertex_iterator | All_vertices_iterator
| iterator over vertices
typedef unspecified_type | Finite_cells_iterator
| iterator over finite cells
typedef unspecified_type | Finite_facets_iterator
| iterator over finite facets
typedef unspecified_type | Finite_edges_iterator
| iterator over finite edges
typedef unspecified_type | Finite_vertices_iterator
| iterator over finite vertices
typedef unspecified_type | Point_iterator
| iterator over the points corresponding to the finite vertices of the triangulation.
typedef Triangulation_data_structure::Cell_circulator | Cell_circulator
| circulator over all cells incident to a given edge
typedef Triangulation_data_structure::Facet_circulator | Facet_circulator
| circulator over all facets incident to a given edge
typedef unspecified_type | Segment_cell_iterator
| iterator over cells intersected by a line segment.
typedef unspecified_type | Segment_simplex_iterator
| iterator over simplices intersected by a line segment.
typedef Iterator_range< unspecified_type > | All_cell_handles
| range type for iterating over all cell handles (including infinite cells), with a nested type `iterator` that has as value type `Cell_handle`.
typedef Iterator_range< All_facets_iterator > | All_facets
| range type for iterating over facets.
typedef Iterator_range< All_edges_iterator > | All_edges
| range type for iterating over edges.
typedef Iterator_range< unspecified_type > | All_vertex_handles
| range type for iterating over all vertex handles, with a nested type `iterator` that has as value type `Vertex_handle`.
typedef Iterator_range< unspecified_type > | Finite_cell_handles
| range type for iterating over finite cell handles, with a nested type `iterator` that has as value type `Cell_handle`.
typedef Iterator_range< Finite_facets_iterator > | Finite_facets
| range type for iterating over finite facets.
typedef Iterator_range< Finite_edges_iterator > | Finite_edges
| range type for iterating over finite edges.
typedef Iterator_range< unspecified_type > | Finite_vertex_handles
| range type for iterating over finite vertex handles, with a nested type `iterator` that has as value type `Vertex_handle`.
typedef Iterator_range< unspecified_type > | Points
| range type for iterating over the points of the finite vertices.
typedef Iterator_range< unspecified_type > | Segment_traverser_cell_handles
| range type for iterating over the cells intersected by a line segment.
typedef Iterator_range< Segment_simplex_iterator > | Segment_traverser_simplices
| range type for iterating over the simplices intersected by a line segment.
Public Member Functions inherited from CGAL::Triangulation_3< Traits, TDS, SLDS >
| Triangulation_3 (const Geom_traits &traits=Geom_traits(), Lock_data_structure *lock_ds=nullptr)
| Introduces a triangulation `t` having only one vertex which is the infinite vertex.
| Triangulation_3 (Lock_data_structure *lock_ds=nullptr, const Geom_traits &traits=Geom_traits())
| Same as the previous one, but with parameters in reverse order.
| Triangulation_3 (const Triangulation_3 &tr)
| Copy constructor.
template<class InputIterator >
| Triangulation_3 (InputIterator first, InputIterator last, const Geom_traits &traits=Geom_traits(), Lock_data_structure *lock_ds=nullptr)
| Equivalent to constructing an empty triangulation with the optional traits class argument and calling `insert(first,last)`.
Triangulation_3 & | operator= (const Triangulation_3 &tr)
| The triangulation `tr` is duplicated, and modifying the copy after the duplication does not modify the original.
void | swap (Triangulation_3 &tr)
| The triangulations `tr` and `t` are swapped.
void | clear ()
| Deletes all finite vertices and all cells of `t`.
template<class GT , class Tds1 , class Tds2 >
bool | operator== (const Triangulation_3< GT, Tds1 > &t1, const Triangulation_3< GT, Tds2 > &t2)
| Equality operator.
template<class GT , class Tds1 , class Tds2 >
bool | operator!= (const Triangulation_3< GT, Tds1 > &t1, const Triangulation_3< GT, Tds2 > &t2)
| The opposite of `operator==`.
const Geom_traits & | geom_traits () const
| Returns a const reference to the geometric traits object.
const Triangulation_data_structure & | tds () const
| Returns a const reference to the triangulation data structure.
Triangulation_data_structure & | tds ()
| Returns a reference to the triangulation data structure.
int | dimension () const
| Returns the dimension of the affine hull.
size_type | number_of_vertices () const
| Returns the number of finite vertices.
size_type | number_of_cells () const
| Returns the number of cells or 0 if `t.dimension() < 3`.
Vertex_handle | infinite_vertex ()
| Returns the infinite vertex.
void | set_infinite_vertex (Vertex_handle v)
| This is an advanced function.
Cell_handle | infinite_cell () const
| Returns a cell incident to the infinite vertex.
size_type | number_of_facets () const
| The number of facets.
size_type | number_of_edges () const
| The number of edges.
size_type | number_of_finite_cells () const
| The number of finite cells.
size_type | number_of_finite_facets () const
| The number of finite facets.
size_type | number_of_finite_edges () const
| The number of finite edges.
Tetrahedron | tetrahedron (Cell_handle c) const
| Returns the tetrahedron formed by the four vertices of `c`.
Triangle | triangle (Cell_handle c, int i) const
| Returns the triangle formed by the three vertices of facet `(c,i)`.
Triangle | triangle (const Facet &f) const
| Same as the previous method for facet `f`.
Segment | segment (const Edge &e) const
| Returns the line segment formed by the vertices of `e`.
Segment | segment (Cell_handle c, int i, int j) const
| Same as the previous method for edge `(c,i,j)`.
const Point & | point (Cell_handle c, int i) const
| Returns the point given by vertex `i` of cell `c`.
const Point & | point (Vertex_handle v) const
| Same as the previous method for vertex `v`.
bool | is_infinite (Vertex_handle v) const
| `true`, iff vertex `v` is the infinite vertex.
bool | is_infinite (Cell_handle c) const
| `true`, iff `c` is incident to the infinite vertex.
bool | is_infinite (Cell_handle c, int i) const
| `true`, iff the facet `i` of cell `c` is incident to the infinite vertex.
bool | is_infinite (const Facet &f) const
| `true` iff facet `f` is incident to the infinite vertex.
bool | is_infinite (Cell_handle c, int i, int j) const
| `true`, iff the edge `(i,j)` of cell `c` is incident to the infinite vertex.
bool | is_infinite (const Edge &e) const
| `true` iff edge `e` is incident to the infinite vertex.
bool | is_vertex (const Point &p, Vertex_handle &v) const
| Tests whether `p` is a vertex of `t` by locating `p` in the triangulation.
bool | is_vertex (Vertex_handle v) const
| Tests whether `v` is a vertex of `t`.
bool | is_edge (Vertex_handle u, Vertex_handle v, Cell_handle &c, int &i, int &j) const
| Tests whether `(u,v)` is an edge of `t`.
bool | is_facet (Vertex_handle u, Vertex_handle v, Vertex_handle w, Cell_handle &c, int &i, int &j, int &k) const
| Tests whether `(u,v,w)` is a facet of `t`.
bool | is_cell (Cell_handle c) const
| Tests whether `c` is a cell of `t`.
bool | is_cell (Vertex_handle u, Vertex_handle v, Vertex_handle w, Vertex_handle x, Cell_handle &c, int &i, int &j, int &k, int &l) const
| Tests whether `(u,v,w,x)` is a cell of `t`.
bool | is_cell (Vertex_handle u, Vertex_handle v, Vertex_handle w, Vertex_handle x, Cell_handle &c) const
| Tests whether `(u,v,w,x)` is a cell of `t` and computes this cell `c`.
bool | has_vertex (const Facet &f, Vertex_handle v, int &j) const
| If `v` is a vertex of `f`, then `j` is the index of `v` in the cell `f.first`, and the method returns `true`.
bool | has_vertex (Cell_handle c, int i, Vertex_handle v, int &j) const
| Same for facet `(c,i)`.
bool | has_vertex (const Facet &f, Vertex_handle v) const
bool | has_vertex (Cell_handle c, int i, Vertex_handle v) const
| Same as the first two methods, but these two methods do not return the index of the vertex.
bool | are_equal (Cell_handle c, int i, Cell_handle n, int j) const
bool | are_equal (const Facet &f, const Facet &g) const
bool | are_equal (const Facet &f, Cell_handle n, int j) const
| For these three methods:
Cell_handle | locate (const Point &query, Cell_handle start=Cell_handle(), bool *could_lock_zone=nullptr) const
| If the point `query` lies inside the convex hull of the points, the cell that contains the query in its interior is returned.
Cell_handle | locate (const Point &query, Vertex_handle hint, bool *could_lock_zone=nullptr) const
| Same as above but uses `hint` as the starting place for the search.
Cell_handle | inexact_locate (const Point &query, Cell_handle start=Cell_handle()) const
| Same as `locate()` but uses inexact predicates.
Cell_handle | locate (const Point &query, Locate_type &lt, int &li, int &lj, Cell_handle start=Cell_handle(), bool *could_lock_zone=nullptr) const
| If `query` lies inside the affine hull of the points, the \( k\)-face (finite or infinite) that contains `query` in its interior is returned, by means of the cell returned together with `lt`, which is set to the locate type of the query (`VERTEX, EDGE, FACET, CELL`, or `OUTSIDE_CONVEX_HULL` if the cell is infinite and `query` lies strictly in it) and two indices `li` and `lj` that specify the \( k\)-face of the cell containing `query`.
Cell_handle | locate (const Point &query, Locate_type &lt, int &li, int &lj, Vertex_handle hint, bool *could_lock_zone=nullptr) const
| Same as above but uses `hint` as the starting place for the search.
Bounded_side | side_of_cell (const Point &p, Cell_handle c, Locate_type &lt, int &li, int &lj) const
| Returns a value indicating on which side of the oriented boundary of `c` the point `p` lies.
Bounded_side | side_of_facet (const Point &p, const Facet &f, Locate_type &lt, int &li, int &lj) const
| Returns a value indicating on which side of the oriented boundary of `f` the point `p` lies:
Bounded_side | side_of_facet (const Point &p, Cell_handle c, Locate_type &lt, int &li, int &lj) const
| Same as the previous method for the facet `(c,3)`.
Bounded_side | side_of_edge (const Point &p, const Edge &e, Locate_type &lt, int &li) const
| Returns a value indicating on which side of the oriented boundary of `e` the point `p` lies:
Bounded_side | side_of_edge (const Point &p, Cell_handle c, Locate_type &lt, int &li) const
| Same as the previous method for edge \( (c,0,1)\).
bool | flip (Edge e)
bool | flip (Cell_handle c, int i, int j)
| Before flipping, these methods check that edge `e=(c,i,j)` is flippable (which is quite expensive).
void | flip_flippable (Edge e)
void | flip_flippable (Cell_handle c, int i, int j)
| Should be preferred to the previous methods when the edge is known to be flippable.
bool | flip (Facet f)
bool | flip (Cell_handle c, int i)
| Before flipping, these methods check that facet `f=(c,i)` is flippable (which is quite expensive).
void | flip_flippable (Facet f)
void | flip_flippable (Cell_handle c, int i)
| Should be preferred to the previous methods when the facet is known to be flippable.
Vertex_handle | insert (const Point &p, Cell_handle start=Cell_handle())
| Inserts the point `p` in the triangulation and returns the corresponding vertex.
Vertex_handle | insert (const Point &p, Vertex_handle hint)
| Same as above but uses `hint` as the starting place for the search.
Vertex_handle | insert (const Point &p, Locate_type lt, Cell_handle loc, int li, int lj)
| Inserts the point `p` in the triangulation and returns the corresponding vertex.
template<class PointInputIterator >
std::ptrdiff_t | insert (PointInputIterator first, PointInputIterator last)
| Inserts the points in the range `[first,last)` in the given order, and returns the number of inserted points.
template<class PointWithInfoInputIterator >
std::ptrdiff_t | insert (PointWithInfoInputIterator first, PointWithInfoInputIterator last)
| Inserts the points in the iterator range `[first,last)` in the given order, and returns the number of inserted points.
Vertex_handle | insert_in_cell (const Point &p, Cell_handle c)
| Inserts the point `p` in the cell `c`.
Vertex_handle | insert_in_facet (const Point &p, const Facet &f)
| Inserts the point `p` in the facet `f`.
Vertex_handle | insert_in_facet (const Point &p, Cell_handle c, int i)
| As above, insertion in the facet `(c,i)`.
Vertex_handle | insert_in_edge (const Point &p, const Edge &e)
| Inserts `p` in the edge `e`.
Vertex_handle | insert_in_edge (const Point &p, Cell_handle c, int i, int j)
| As above, inserts `p` in the edge \( (i, j)\) of `c`.
Vertex_handle | insert_outside_convex_hull (const Point &p, Cell_handle c)
| The cell `c` must be an infinite cell containing `p`.
Vertex_handle | insert_outside_affine_hull (const Point &p)
| `p` is linked to all the points, and the infinite vertex is linked to all the points (including `p`) to triangulate the new infinite face, so that all the points now belong to the boundary of the convex hull.
template<class CellIt >
Vertex_handle | insert_in_hole (const Point &p, CellIt cell_begin, CellIt cell_end, Cell_handle begin, int i)
| Creates a new vertex by starring a hole.
template<class CellIt >
Vertex_handle | insert_in_hole (const Point &p, CellIt cell_begin, CellIt cell_end, Cell_handle begin, int i, Vertex_handle newv)
| Same as above, except that `newv` will be used as the new vertex, which must have been allocated previously with e.g. `create_vertex`.
Finite_vertices_iterator | finite_vertices_begin () const
| Starts at an arbitrary finite vertex.
Finite_vertices_iterator | finite_vertices_end () const
| Past-the-end iterator.
Finite_edges_iterator | finite_edges_begin () const
| Starts at an arbitrary finite edge.
Finite_edges_iterator | finite_edges_end () const
| Past-the-end iterator.
Finite_facets_iterator | finite_facets_begin () const
| Starts at an arbitrary finite facet.
Finite_facets_iterator | finite_facets_end () const
| Past-the-end iterator.
Finite_cells_iterator | finite_cells_begin () const
| Starts at an arbitrary finite cell.
Finite_cells_iterator | finite_cells_end () const
| Past-the-end iterator.
All_vertices_iterator | all_vertices_begin () const
| Starts at an arbitrary vertex.
All_vertices_iterator | all_vertices_end () const
| Past-the-end iterator.
All_edges_iterator | all_edges_begin () const
| Starts at an arbitrary edge.
All_edges_iterator | all_edges_end () const
| Past-the-end iterator.
All_facets_iterator | all_facets_begin () const
| Starts at an arbitrary facet.
All_facets_iterator | all_facets_end () const
| Past-the-end iterator.
All_cells_iterator | all_cells_begin () const
| Starts at an arbitrary cell.
All_cells_iterator | all_cells_end () const
| Past-the-end iterator.
Point_iterator | points_begin () const
| Iterates over the points of the triangulation.
Point_iterator | points_end () const
| Past-the-end iterator.
All_cell_handles | all_cell_handles () const
| returns a range of iterators over all cells (even the infinite cells).
All_facets | all_facets () const
| returns a range of iterators starting at an arbitrary facet.
All_edges | all_edges () const
| returns a range of iterators starting at an arbitrary edge.
All_vertex_handles | all_vertex_handles () const
| returns a range of iterators over all vertices (even the infinite one).
Finite_cell_handles | finite_cell_handles () const
| returns a range of iterators over finite cells.
Finite_facets | finite_facets () const
| returns a range of iterators starting at an arbitrary facet.
Finite_edges | finite_edges () const
| returns a range of iterators starting at an arbitrary edge.
Finite_vertex_handles | finite_vertex_handles () const
| returns a range of iterators over finite vertices.
Points | points () const
| returns a range of iterators over the points of finite vertices.
std::array< Vertex_handle, 2 > | vertices (const Edge &e) const
| returns an array containing the vertices of `e`, in the order of their indices `e.second` and `e.third` in the cell `e.first`.
std::array< Vertex_handle, 3 > | vertices (const Facet &f) const
| returns an array containing the vertices of `f`, in counterclockwise order on the face of `f.first` opposite to vertex `f.first->vertex(f.second)`.
std::array< Vertex_handle, 4 > | vertices (const Cell_handle c) const
| returns an array containing the vertices of `c`, in the same order as the indices in `c`.
Segment_traverser_cell_handles | segment_traverser_cell_handles () const
| returns a range of iterators over the cells intersected by a line segment
Segment_traverser_simplices | segment_traverser_simplices () const
| returns a range of iterators over the simplices intersected by a line segment
Segment_cell_iterator | segment_traverser_cells_begin (Vertex_handle vs, Vertex_handle vt) const
| returns the iterator that allows to visit the cells intersected by the line segment `[vs,vt]`.
Segment_cell_iterator | segment_traverser_cells_begin (const Point &ps, const Point &pt, Cell_handle hint=Cell_handle()) const
| returns the iterator that allows to visit the cells intersected by the line segment `[ps, pt]`.
Segment_cell_iterator | segment_traverser_cells_end () const
| returns the past-the-end iterator over the intersected cells.
Segment_simplex_iterator | segment_traverser_simplices_begin (Vertex_handle vs, Vertex_handle vt) const
| returns the iterator that allows to visit the simplices intersected by the line segment `[vs,vt]`.
Segment_simplex_iterator | segment_traverser_simplices_begin (const Point &ps, const Point &pt, Cell_handle hint=Cell_handle()) const
| returns the iterator that allows to visit the simplices intersected by the line segment `[ps,pt]`.
Segment_simplex_iterator | segment_traverser_simplices_end () const
| returns the past-the-end iterator over the intersected simplices.
Cell_circulator | incident_cells (Edge e) const
| Starts at an arbitrary cell incident to `e`.
Cell_circulator | incident_cells (Cell_handle c, int i, int j) const
| As above for edge `(i,j)` of `c`.
Cell_circulator | incident_cells (Edge e, Cell_handle start) const
| Starts at cell `start`.
Cell_circulator | incident_cells (Cell_handle c, int i, int j, Cell_handle start) const
| As above for edge `(i,j)` of `c`.
Facet_circulator | incident_facets (Edge e) const
| Starts at an arbitrary facet incident to `e`.
Facet_circulator | incident_facets (Cell_handle c, int i, int j) const
| As above for edge `(i,j)` of `c`.
Facet_circulator | incident_facets (Edge e, Facet start) const
| Starts at facet `start`.
Facet_circulator | incident_facets (Edge e, Cell_handle start, int f) const
| Starts at facet of index `f` in `start`.
Facet_circulator | incident_facets (Cell_handle c, int i, int j, Facet start) const
| As above for edge `(i,j)` of `c`.
Facet_circulator | incident_facets (Cell_handle c, int i, int j, Cell_handle start, int f) const
| As above for edge `(i,j)` of `c` and facet `(start,f)`.
template<class OutputIterator >
OutputIterator | incident_cells (Vertex_handle v, OutputIterator cells) const
| Copies the `Cell_handle`s of all cells incident to `v` to the output iterator `cells`.
bool | try_lock_and_get_incident_cells (Vertex_handle v, std::vector< Cell_handle > &cells) const
| Try to lock and copy the `Cell_handle`s of all cells incident to `v` into `cells`.
template<class OutputIterator >
OutputIterator | finite_incident_cells (Vertex_handle v, OutputIterator cells) const
| Copies the `Cell_handle`s of all finite cells incident to `v` to the output iterator `cells`.
template<class OutputIterator >
OutputIterator | incident_facets (Vertex_handle v, OutputIterator facets) const
| Copies all `Facet`s incident to `v` to the output iterator `facets`.
template<class OutputIterator >
OutputIterator | finite_incident_facets (Vertex_handle v, OutputIterator facets) const
| Copies all finite `Facet`s incident to `v` to the output iterator `facets`.
template<class OutputIterator >
OutputIterator | incident_edges (Vertex_handle v, OutputIterator edges) const
| Copies all `Edge`s incident to `v` to the output iterator `edges`.
template<class OutputIterator >
OutputIterator | finite_incident_edges (Vertex_handle v, OutputIterator edges) const
| Copies all finite `Edge`s incident to `v` to the output iterator `edges`.
template<class OutputIterator >
OutputIterator | adjacent_vertices (Vertex_handle v, OutputIterator vertices) const
| Copies the `Vertex_handle`s of all vertices adjacent to `v` to the output iterator `vertices`.
template<class OutputIterator >
OutputIterator | finite_adjacent_vertices (Vertex_handle v, OutputIterator vertices) const
| Copies the `Vertex_handle`s of all finite vertices adjacent to `v` to the output iterator `vertices`.
size_type | degree (Vertex_handle v) const
| Returns the degree of `v`, that is, the number of incident vertices.
int | mirror_index (Cell_handle c, int i) const
| Returns the index of `c` in its \( i^{th}\) neighbor.
Vertex_handle | mirror_vertex (Cell_handle c, int i) const
| Returns the vertex of the \( i^{th}\) neighbor of `c` that is opposite to `c`.
Facet | mirror_facet (Facet f) const
| Returns the same facet seen from the other adjacent cell.
bool | is_valid (bool verbose=false) const
| This is a function for debugging purpose.
bool | is_valid (Cell_handle c, bool verbose=false) const
| This is a function for debugging purpose.
istream & | operator>> (istream &is, Triangulation_3 &t)
| Reads the underlying combinatorial triangulation from `is` by calling the corresponding input operator of the triangulation data structure class (note that the infinite vertex is numbered 0), and the non-combinatorial information by calling the corresponding input operators of the vertex and the cell classes (such as point coordinates), which are provided by overloading the stream operators of the vertex and cell types.
ostream & | operator<< (ostream &os, const Triangulation_3 &t)
| Writes the triangulation `t` into `os`.
template<typename Tr_src , typename ConvertVertex , typename ConvertCell >
std::istream & | file_input (std::istream &is, ConvertVertex convert_vertex=ConvertVertex(), ConvertCell convert_cell=ConvertCell())
| The triangulation streamed in `is`, of original type `Tr_src`, is written into the triangulation.
void | set_lock_data_structure (Lock_data_structure *lock_ds) const
| Set the pointer to the lock data structure.
Static Public Member Functions inherited from CGAL::Triangulation_utils_3
static unsigned int | next_around_edge (unsigned int i, unsigned int j)
static int | vertex_triple_index (const int i, const int j)
static unsigned int | ccw (unsigned int i)
static unsigned int | cw (unsigned int i)

## Constructor & Destructor Documentation

## ◆ Regular_triangulation_3() [1/3]

template<typename Traits , typename TDS , typename SLDS >

CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::Regular_triangulation_3 | ( | const Traits & | traits = `Traits()`,
|  | Lock_data_structure * | lock_ds = `nullptr`
| ) |  |

Creates an empty regular triangulation, possibly specifying a traits class `traits`.

`lock_ds` is an optional pointer to the lock data structure for parallel operations. It must be provided if concurrency is enabled.

## ◆ Regular_triangulation_3() [2/3]

template<typename Traits , typename TDS , typename SLDS >

CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::Regular_triangulation_3 | ( | const Regular_triangulation_3< Traits, TDS, SLDS > & | rt1 | ) |

Copy constructor.

The pointer to the lock data structure is not copied. Thus, the copy won't be concurrency-safe as long as the user has not called `Triangulation_3::set_lock_data_structure`.

## ◆ Regular_triangulation_3() [3/3]

template<typename Traits , typename TDS , typename SLDS >
template<class InputIterator >

CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::Regular_triangulation_3 | ( | InputIterator | first,
|  | InputIterator | last,
|  | const Traits & | traits = `Traits()`,
|  | Lock_data_structure * | lock_ds = `nullptr`
| ) |  |

Equivalent to constructing an empty triangulation with the optional traits class argument and calling `insert(first,last)`.

If parallelism is enabled, the points will be inserted in parallel.

Template Parameters

  InputIterator | must be an input iterator with value type `Weighted_point` .

## Member Function Documentation

## ◆ dual() [1/2]

template<typename Traits , typename TDS , typename SLDS >

Bare_point CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::dual | ( | Cell_handle | c | ) | const

Returns the weighted circumcenter of the four vertices of c.

Precondition
  `dimension()` \( =3\) and `c` is not infinite.

## ◆ dual() [2/2]

template<typename Traits , typename TDS , typename SLDS >

Object CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::dual | ( | Facet | f | ) | const

Returns the dual of facet `f`, which is.

in dimension 3: either a segment, if the two cells incident to `f` are finite, or a ray, if one of them is infinite;

in dimension 2: a point.

Precondition
  `dimension()` \( \geq2\) and `f` is not infinite.

## ◆ find_conflicts()

template<typename Traits , typename TDS , typename SLDS >
template<class OutputIteratorBoundaryFacets , class OutputIteratorCells , class OutputIteratorInternalFacets >

Triple< OutputIteratorBoundaryFacets, OutputIteratorCells, OutputIteratorInternalFacets > CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::find_conflicts | ( | const Weighted_point | p,
|  | Cell_handle | c,
|  | OutputIteratorBoundaryFacets | bfit,
|  | OutputIteratorCells | cit,
|  | OutputIteratorInternalFacets | ifit,
|  | bool * | could_lock_zone = `nullptr`,
|  | const Facet * | this_facet_must_be_in_the_cz = `nullptr`,
|  | bool * | the_facet_is_in_its_cz = `nullptr`
| ) |  |

Compute the conflicts with `p`.

Parameters

  p | The query point.
  c | The starting cell.
  cit | The cells (resp. facets) in conflict with `p`.
  bfit | The facets (resp. edges) on the boundary of the conflict zone, that is, the facets (resp. edges) `(t, i)` where the cell (resp.. facet) `t` is in conflict, but `t->neighbor(i)` is not.
  ifit | The facets (resp. edges) inside the conflict zone, that facets incident to two cells (resp. facets) in conflict.
  could_lock_zone | The optional argument `could_lock_zone` is used by the concurrency-safe version of the triangulation. If the pointer is not null, the algorithm will try to lock all the cells of the conflict zone, i.e. all the vertices that are inside or on the boundary of the conflict zone (as a result, the boundary cells become partially locked). If it succeeds, `*could_lock_zone` is true, otherwise it is false (and the returned conflict zone is only partial). In any case, the locked cells are not unlocked by the function, leaving this choice to the user.
  this_facet_must_be_in_the_cz | If the optional argument `this_facet_must_be_in_the_cz` is not null, the algorithm will check if this facet is in the conflict zone (it may be internal as well as boundary).
  the_facet_is_in_its_cz | This argument must be not null if the previous `this_facet_must_be_in_the_cz` argument is not null. The boolean value pointed by this pointer is set to true if *`this_facet_must_be_in_the_cz` is among the internal or boundary facets of the conflict zone, and false otherwise.

Precondition
  The starting cell (resp. facet) `c` must be in conflict with `p`.
  `dimension()` \( \geq2\), and `c` is in conflict with `p`.

Returns
  the `Triple` composed of the resulting output iterators.

## ◆ insert() [1/4]

template<typename Traits , typename TDS , typename SLDS >

Vertex_handle CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::insert | ( | const Weighted_point & | p,
|  | Cell_handle | start = `Cell_handle()`,
|  | bool * | could_lock_zone = `nullptr`
| ) |  |

Inserts the weighted point `p` in the triangulation.

The optional argument `start` is used as a starting place for the search.

If this insertion creates a vertex, this vertex is returned.

If `p` coincides with an existing vertex and has a greater weight, then the existing weighted point becomes hidden (see `RegularTriangulationCellBase_3`) and `p` replaces it as vertex of the triangulation.

If `p` coincides with an already existing vertex (both point and weights being equal), then this vertex is returned and the triangulation remains unchanged.

Otherwise if `p` does not appear as a vertex of the triangulation, then it is stored as a hidden point and this method returns the default constructed handle.

The optional argument `could_lock_zone` is used by the concurrency-safe version of the triangulation. If the pointer is not null, the insertion will try to lock all the cells of the conflict zone, i.e. all the vertices that are inside or on the boundary of the conflict zone. If it succeeds, `*could_lock_zone` is true, otherwise it is false (and the point is not inserted). In any case, the locked cells are not unlocked by the function, leaving this choice to the user.

## ◆ insert() [2/4]

template<typename Traits , typename TDS , typename SLDS >

Vertex_handle CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::insert | ( | const Weighted_point & | p,
|  | Locate_type | lt,
|  | Cell_handle | loc,
|  | int | li,
|  | int | lj,
|  | bool * | could_lock_zone = `nullptr`
| ) |  |

Inserts the weighted point `p` in the triangulation and returns the corresponding vertex.

Similar to the above `insert()` function, but takes as additional parameter the return values of a previous location query. See description of `Triangulation_3::locate()`.

## ◆ insert() [3/4]

template<typename Traits , typename TDS , typename SLDS >
template<class InputIterator >

std::ptrdiff_t CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::insert | ( | InputIterator | first,
|  | InputIterator | last
| ) |  |

Inserts the weighted points in the range `[first,last)`.

It returns the difference of the number of vertices between after and before the insertions (it may be negative due to hidden points). Note that this function is not guaranteed to insert the points following the order of `InputIterator`, as `spatial_sort()` is used to improve efficiency. If parallelism is enabled, the points will be inserted in parallel.

Template Parameters

  InputIterator | must be an input iterator with value type `Weighted_point` .

## ◆ insert() [4/4]

template<typename Traits , typename TDS , typename SLDS >
template<class WeightedPointWithInfoInputIterator >

std::ptrdiff_t CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::insert | ( | WeightedPointWithInfoInputIterator | first,
|  | WeightedPointWithInfoInputIterator | last
| ) |  |

Inserts the weighted points in the iterator range `[first,last)`.

It returns the difference of the number of vertices between after and before the insertions (it may be negative due to hidden points). Note that this function is not guaranteed to insert the weighted points following the order of `WeightedPointWithInfoInputIterator`, as `spatial_sort()` is used to improve efficiency. If parallelism is enabled, the points will be inserted in parallel. Given a pair `(p,i)`, the vertex `v` storing `p` also stores `i`, that is `v.point() == p` and `v.info() == i`. If several pairs have the same point, only one vertex is created, one of the objects of type `Vertex::Info` will be stored in the vertex.

Precondition
  `Vertex` must be model of the concept `TriangulationVertexBaseWithInfo_3`.

Template Parameters

  WeightedPointWithInfoInputIterator | must be an input iterator with value type `std::pair<Weighted_point,Vertex::Info>`.

## ◆ insert_in_hole()

template<typename Traits , typename TDS , typename SLDS >
template<class CellIt >

Vertex_handle CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::insert_in_hole | ( | const Weighted_point & | p,
|  | CellIt | cell_begin,
|  | CellIt | cell_end,
|  | Cell_handle | begin,
|  | int | i
| ) |  |

Creates a new vertex by starring a hole.

It takes an iterator range `[cell_begin,cell_end)` of `Cell_handle`s which specifies a hole: a set of connected cells (resp. facets in dimension 2) which is star-shaped wrt `p`. (`begin`, `i`) is a facet (resp. an edge) on the boundary of the hole, that is, `begin` belongs to the set of cells (resp. facets) previously described, and `begin->neighbor(i)` does not. Then this function deletes all the cells (resp. facets) describing the hole, creates a new vertex `v`, and for each facet (resp. edge) on the boundary of the hole, creates a new cell (resp. facet) with `v` as vertex. Then `v->set_point(p)` is called and `v` is returned.

If the hole contains interior vertices, each of them is hidden by the insertion of `p` and is stored in the new cell which contains it.

Precondition
  `dimension()` \( \geq2\), the set of cells (resp. facets in dimension 2) is connected, not empty, its boundary is connected, and `p` lies inside the hole, which is star-shaped wrt `p`.

## ◆ is_valid()

template<typename Traits , typename TDS , typename SLDS >

bool CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::is_valid | ( | bool | verbose = `false` | ) | const

This is a function for debugging purpose.

Debugging Support

Checks the combinatorial validity of the triangulation and the validity of its geometric embedding (see Section Representation). Also checks that all the power spheres (resp. power circles in dimension 2, power segments in dimension 1) of cells (resp. facets in dimension 2, edges in dimension 1) are regular. When `verbose` is set to true, messages describing the first invalidity encountered are printed. This method is mainly a debugging help for the users of advanced features.

## ◆ nearest_power_vertex()

template<typename Traits , typename TDS , typename SLDS >

Vertex_handle CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::nearest_power_vertex | ( | const Bare_point & | p,
|  | Cell_handle | c = `Cell_handle()`
| ) |  |

Returns the vertex of the triangulation which is nearest to \( p\) with respect to the power distance.

This means that the power of the query point `p` with respect to the weighted point in the returned vertex is smaller than the power of `p` with respect to the weighted point for any other vertex. Ties are broken arbitrarily. The default constructed handle is returned if the triangulation is empty. The optional argument `c` is a hint specifying where to start the search.

Precondition
  `c` is a cell of the regular triangulation.

## ◆ remove() [1/2]

template<typename Traits , typename TDS , typename SLDS >
template<typename InputIterator >

int CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::remove | ( | InputIterator | first,
|  | InputIterator | beyond
| ) |  |

Removes the vertices specified by the iterator range `[first, beyond)`.

The number of vertices removed is returned. If parallelism is enabled, the points will be removed in parallel. Note that if at some step, the triangulation dimension becomes lower than 3, the removal of the remaining points will go on sequentially.

Precondition
  (i) all vertices of the range are finite vertices of the triangulation; and (ii) no vertices are repeated in the range.

Template Parameters

  InputIterator | must be an input iterator with value type `Vertex_handle`.

## ◆ remove() [2/2]

template<typename Traits , typename TDS , typename SLDS >

bool CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::remove | ( | Vertex_handle | v,
|  | bool * | could_lock_zone
| ) |  |

Removes the vertex `v` from the triangulation.

This function is concurrency-safe if the triangulation is concurrency-safe. It will first try to lock all the cells adjacent to `v`. If it succeeds, `*could_lock_zone` is true, otherwise it is false (and the point is not removed). In any case, the locked cells are not unlocked by the function, leaving this choice to the user.

This function will try to remove `v` only if the removal does not decrease the dimension. The return value is only meaningful if `*could_lock_zone` is true:

- returns `true` if the vertex was removed
- returns `false` if the vertex wasn't removed since it would decrease the dimension.

Precondition
  `v` is a finite vertex of the triangulation.
  `dt`.`dimension()` \( =3\).

## ◆ side_of_power_circle()

template<typename Traits , typename TDS , typename SLDS >

Bounded_side CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::side_of_power_circle | ( | const Facet & | f,
|  | const Weighted_point & | p
| ) |  | const

Returns the position of the point `p` with respect to the power circle of `f`.

More precisely, it returns:

- in dimension 3:
- For a finite facet,

`ON_BOUNDARY` if `p` is orthogonal to the power circle in the plane of the facet,

`ON_UNBOUNDED_SIDE` when their angle is less than \( \pi/2\),

`ON_BOUNDED_SIDE` when it is greater than \( \pi/2\) (see Figure Triangulation3figsidedim2).

- For an infinite facet, it considers the plane defined by the finite facet of the cell `f.first`, and does the same as in dimension 2 in this plane.
- in dimension 2:
- For a finite facet,

`ON_BOUNDARY` if `p` is orthogonal to the circle,

`ON_UNBOUNDED_SIDE` when the angle between `p` and the power circle of `f` is less than \( \pi/2\), `ON_BOUNDED_SIDE` when it is greater than \( \pi/2\).

- For an infinite facet,

`ON_BOUNDED_SIDE` for a point in the open half plane defined by `f` and not containing any other point of the triangulation,

`ON_UNBOUNDED_SIDE` in the other open half plane.

If the point `p` is collinear with the finite edge `e` of `f`, it returns:

`ON_BOUNDED_SIDE` if \( \Pi({p}^{(w)}-{z(e)}^{(w)})<0\), where \( {z(e)}^{(w)}\) is the power segment of `e` in the line supporting `e`,

`ON_BOUNDARY` if \( \Pi({p}^{(w)}-{z(e)}^{(w)})=0\),

`ON_UNBOUNDED_SIDE` if \( \Pi({p}^{(w)}-{z(e)}^{(w)})>0\) .

Precondition
  `dimension()` \( \geq2\).

## ◆ side_of_power_segment()

template<typename Traits , typename TDS , typename SLDS >

Bounded_side CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::side_of_power_segment | ( | Cell_handle | c,
|  | const Weighted_point & | p
| ) |  | const

In dimension 1, returns.

`ON_BOUNDED_SIDE` if \( \Pi({p}^{(w)}-{z(c)}^{(w)})<0\), where \( {z(c)}^{(w)}\) is the power segment of the edge represented by `c`,

`ON_BOUNDARY` if \( \Pi({p}^{(w)}-{z(c)}^{(w)})=0\),

`ON_UNBOUNDED_SIDE` if \( \Pi({p}^{(w)}-{z(c)}^{(w)})>0\) .

Precondition
  `dimension()` \( = 1\).

## ◆ side_of_power_sphere()

template<typename Traits , typename TDS , typename SLDS >

Bounded_side CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::side_of_power_sphere | ( | Cell_handle | c,
|  | const Weighted_point & | p
| ) |  | const

Returns the position of the weighted point \( p\) with respect to the power sphere of `c`.

More precisely, it returns:

- `ON_BOUNDED_SIDE` if \( \Pi({p}^{(w)}-{z(c)}^{(w)})<0\) where \( {z(c)}^{(w)}\) is the power sphere of `c`. For an infinite cell this means either that `p` lies strictly in the half space limited by its finite facet and not containing any other point of the triangulation, or that the angle between `p` and the power circle of the finite facet of `c` is greater than \( \pi/2\).
- `ON_BOUNDARY` if p is orthogonal to the power sphere of `c` i.e. \( \Pi({p}^{(w)}-{z(c)}^{(w)})=0\). For an infinite cell this means that `p` is orthogonal to the power circle of its finite facet.
- `ON_UNBOUNDED_SIDE` if \( \Pi({p}^{(w)}-{z(c)}^{(w)})>0\) i.e. the angle between the weighted point `p` and the power sphere of `c` is less than \( \pi/2\) or if these two spheres do not intersect. For an infinite cell this means that `p` does not satisfy either of the two previous conditions.
  Precondition
    `dimension()` \( =3\).

## ◆ vertices_in_conflict()

template<typename Traits , typename TDS , typename SLDS >
template<class OutputIterator >

OutputIterator CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::vertices_in_conflict | ( | const Weighted_point & | p,
|  | Cell_handle | c,
|  | OutputIterator | res
| ) |  |

Deprecated:
  This function is renamed `vertices_on_conflict_zone_boundary` since CGAL-3.8.

## ◆ vertices_inside_conflict_zone()

template<typename Traits , typename TDS , typename SLDS >
template<class OutputIterator >

OutputIterator CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::vertices_inside_conflict_zone | ( | const Weighted_point & | p,
|  | Cell_handle | c,
|  | OutputIterator | res
| ) |  |

Similar to `find_conflicts()`, but reports the vertices which are in the interior of the conflict zone of `p`, in the output iterator `res`.

The vertices that are on the boundary of the conflict zone are not reported. Returns the resulting output iterator.

Precondition
  `dimension()` \( \geq2\), and `c` is a cell containing `p`.

## ◆ vertices_on_conflict_zone_boundary()

template<typename Traits , typename TDS , typename SLDS >
template<class OutputIterator >

OutputIterator CGAL::Regular_triangulation_3< Traits, TDS, SLDS >::vertices_on_conflict_zone_boundary | ( | const Weighted_point & | p,
|  | Cell_handle | c,
|  | OutputIterator | res
| ) |  |

Similar to `find_conflicts()`, but reports the vertices which are on the boundary of the conflict zone of `p`, in the output iterator `res`.

Returns the resulting output iterator.

Precondition
  `dimension()` \( \geq2\), and `c` is a cell containing `p`.