songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

after reviews of user manual

This commit is contained in:
Olivier Devillers 2012-05-23 15:22:18 +00:00
parent 20b9923723
commit 1c976bb71f
24 changed files with 478 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Triangulation/TODO
View File

@ -1,6 +1,6 @@
--------------------------------------------------
En lisant les reviews
Problems to be solved from the reviews
--------------------------------------------------
example delaunay does not execute properly
@ -11,6 +11,13 @@ put a default value for dim in the constructor
check that the perturbation scheme is independant of the order of insertion
Add a template parameter Location_policy
ambient dim vs max dim
check all is_valid function, precise in the doc what they are doing.
(do sth like 2/3 d)

BIN
Triangulation/doc_tex/Triangulation/fig/simplex-structure.pdf
View File

Binary file not shown.

BIN
Triangulation/doc_tex/Triangulation/fig/simplex-structure.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 29 KiB

After

Width:  |  Height:  |  Size: 14 KiB

239
Triangulation/doc_tex/Triangulation/triangulation.tex
View File

@ -4,28 +4,37 @@
\newcommand{\sphere}{\ensuremath{\mathcal S}}
\renewcommand{\real}{\ensuremath{\mathbb R}}
This package proposes data structure and algorithms to compute
triangulations of points in any dimensions.
The \ccc{Triangulation_data_structure} allows to store and manipulate the
combinatorial part of a triangulation while the geometric classes
\ccc{Triangulation} and \ccc{DelaunayTriangulation} allows to
compute a (Delaunay) triangulation of a set of points and to maintain
it under insertions (and deletions in the Delaunay case).
\section{Introduction\label{triangulation:intro}}
A \textbf{finite abstract simplicial complex} is built on a finite set of
A \em{finite abstract simplicial complex} is built on a finite set of
vertices $V$ and consists of a collection $S$ of subsets of $V$ such that
\centerline{if $s$ is a set of vertices in $S$, then all the subsets of $s$ are also
in $S$.}
The sets in $S$ (which are subsets of $V$) are called
\textbf{faces} or \textbf{simplices} (the
singular of which is \textbf{simplex}).
\em{faces} or \em{simplices} (the
singular of which is \em{simplex}).
%
A simplex $s\in S$ is \textbf{maximal} if it is not a proper subset of some other
set in $S$. The simplicial complex is \textbf{pure} %(or \textbf{homogeneous})
A simplex $s\in S$ is \em{maximal} if it is not a proper subset of some other
set in $S$. The simplicial complex is \em{pure} %(or \em{homogeneous})
if all the maximal simplices have the same cardinality, i.e., they have the same
number of vertices.
In the sequel, we will call these maximal simplices \textbf{(full) cells}.
A \textbf{face} of a simplex is a subset of it.
A \textbf{proper face} of a simplex is a strict subset of it.
In the sequel, we will call these maximal simplices \em{full cells}.
A \em{face} of a simplex is a subset of it.
A \em{proper face} of a simplex is a strict subset of it.
If the vertices are embedded into Euclidean space $\real^d$, we deal with
\textbf{finite simplicial complexes} which have slightly different simplices
\em{finite simplicial complexes} which have slightly different simplices
and additional requirements:
\begin{itemize}
\item vertices corresponds to points in space.
@ -37,31 +46,35 @@ simplices (the empty set counts).
See the \ccAnchor{http://en.wikipedia.org/wiki/Simplicial_complex}{wikipedia
entry} for more about simplicial complexes.
This \cgal\ package deals with pure finite simplicial complexes, which
we will simply call in the sequel \textbf{triangulations}. It provides three main classes
This \cgal\ package deals with pure finite simplicial complexes
without boundary, which
we will simply call in the sequel \em{triangulations}. It provides three main classes
for creating and manipulating triangulations.
The class \ccc{CGAL::Triangulation_data_structure<Dimensionality,
TDSVertex, TDSFullCell>} models an abstract triangulation: vertices in this
TriangulationDSVertex, TriangulationDSFullCell>} models an {\em abstract triangulation}: vertices in this
class are not embedded in Euclidean space but are only of combinatorial
nature.
The class \ccc{CGAL::Triangulation<TrTraits, TDS>} embeds an abstract
The class \ccc{CGAL::Triangulation<TriangulationTraits, TriangulationDataStructure>} embeds an abstract
triangulation in Euclidean space, thus forming a geometric
triangulation. Methods are
provided for the insertion %and removal
of points in the triangulation, the
traversal of various elements of the triangulation, as well as the localization of a
query point inside the triangulation.
The convex hull of the points is part of the triangulation, the fact
that there is no boundary is ensured by adding an infinite vertex and
infinite full cells to triangulate the outside of the convex hull.
The class \ccc{CGAL::Delaunay_triangulation<DTTraits, TDS>} adds further
The class \ccc{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} adds further
constraints to a triangulation, in that all its simplices must have the
so-called \textbf{Delaunay} or \textbf{empty-ball} property: the interior of
so-called \em{Delaunay} or \em{empty-ball} property: the interior of
a ball circumscribing any simplex (or full cell) must be free from any
vertex of the triangulation. The \ccc{CGAL::Delaunay_triangulation} class
supports deletion of vertices.
%The class \ccc{CGAL::Regular_triangulation<RegularTraits, TDS>} is a generalization of
%The class \ccc{CGAL::Regular_triangulation<RegularTraits, TriangulationDataStructure>} is a generalization of
%the Delaunay triangulation.
%The rest of this user manual gives more details about these classes and the
@ -81,38 +94,36 @@ affinely independent.
If the maximal dimension of a simplex in the triangulation is
$d$, we call:\begin{itemize}
\item an $i$-face for some $i\in[0,d]$ a \textbf{face};
\item a $0$-face a \textbf{vertex};
\item a $1$-face an \textbf{edge};
\item a $(d-2)$-face a \textbf{ridge};
\item a $(d-1)$-face a \textbf{facet}; and
\item a $d$-face a \textbf{full cell}.
\item an $i$-face for some $i\in[0,d]$ a \em{face};
\item a $0$-face a \em{vertex};
\item a $1$-face an \em{edge};
\item a $(d-2)$-face a \em{ridge};
\item a $(d-1)$-face a \em{facet}; and
\item a $d$-face a \em{full cell}.
\end{itemize}
Two faces $\sigma$ and $\sigma'$ are \textbf{incident} if and only if
Two faces $\sigma$ and $\sigma'$ are \em{incident} if and only if
$\sigma'$ is a proper sub-face of $\sigma$ or \emph{vice versa}.
\section{Triangulation Data Structure\label{triangulation:tds}}
\newcommand{\tds}{\ccc{TDS}}
\newcommand{\tds}{\ccc{TriangulationDataStructure}}
\newcommand{\ad}{\ensuremath{D}}
\newcommand{\cd}{\ensuremath{d}}
In this section, we describe the concept \ccc{TriangulationDataStructure} for
which \cgal\ provides one model class:
\ccc{CGAL::Triangulation_data_structure<Dimensionality, TDSVertex,
TDSFullCell>}. For simplicity, we use the abbreviation \tds.
\ccc{CGAL::Triangulation_data_structure<Dimensionality, TriangulationDSVertex,
TriangulationDSFullCell>}. For simplicity, we use the abbreviation \tds.
A \tds\ cannot represent every abstract pure complex, but rather the
combinatorial nature of a (geometric) triangulation. For example, a facet
may be incident to arbitrarily many simplices in an abstract pure complex, but
to at most two in a \tds\ (and in fact exactly two as we explain below).
A \tds\ can represent an abstract pure complex,
such that any facet is incident to exactly two full cells.
A \tds\ has a property called the \textbf{ambient dimension} which is a
A \tds\ has a property called the \em{ambient dimension} which is a
positive integer equal to the maximum dimension a full cell can have.
This ambient dimension can be chosen by the user at the creation of a \tds\
and can then be queried using the method \ccc{tds.ambient_dimension()}.
A \tds\ also knows the \textbf{current dimension} of its full cells,
A \tds\ also knows the \em{current dimension} of its full cells,
which can be queried with \ccc{tds.current_dimension()}. In the sequel, let
us denote the ambient dimension with \ad\ and the current dimension with \cd.
It always holds that $-2\leq\cd\leq\ad$ and $0<\ad$.
@ -131,52 +142,53 @@ The special meaning of negative values for $d$ will be explain below.
%
%% By contrast, in the present \ccc{Triangulation} \cgal\ package, the reference
%% dimension of a pure complex (or a pure complex data structure) is its current
%% dimension. This means that, whatever the current dimension is, a full
%% cell is always represented by the \ccc{FullCell} nested type, And a
%% dimension. This means that, whatever the current dimension is, a
%% full cell is always represented by the \ccc{FullCell} nested type, And a
%% \ccc{Facet} represents a face of dimension \ccc{current_dimension()-1}
%% \textbf{and not} \ccc{ambient_dimension()-1}.
%% \em{and not} \ccc{ambient_dimension()-1}.
\subsubsection{The data structure triangulates $\sphere^\cd$}
In a first approximation, a \tds\ can be viewed as
a \emph{triangulation} of the topological sphere $\sphere^\cd$,
A \tds\ can be viewed as
a {triangulation} of the topological sphere $\sphere^\cd$,
i.e., its faces can be embedded to form a partition of
$\sphere^\cd$ into $\cd$-simplices. When a
\tds\ is used as the combinatorial part of a geometric triangulation, one
special vertex of the \tds\ plays the role of the \textbf{vertex at
infinity}; we can consider that the triangulation covers the whole
affine hull of its vertices
using \textbf{infinite} or \textbf{unbounded} cells to fill the space outside the convex
hull of the triangulation's finite vertices. (More details are given in the next section.)
$\sphere^\cd$ into $\cd$-simplices.
% When a
% \tds\ is used as the combinatorial part of a geometric triangulation, one
% special vertex of the \tds\ plays the role of the \em{vertex at
% infinity}; we can consider that the triangulation covers the whole
% affine hull of its vertices
% using \em{infinite} or \em{unbounded} full cells to fill the space outside the convex
% hull of the triangulation's finite vertices. (More details are given in the next section.)
One nice consequence of the above important fact is that a cell has
One nice consequence of the above important fact is that a full cell has
always exactly $\cd+1$ neighbors.
Two full cells $\sigma$ and $\sigma'$ sharing a facet are called
\textbf{neighbors}.
\em{neighbors}.
Possible values of $\cd$ (the \emph{current dimension} of the triangulation) include
\begin{itemize}
\item[$\cd=-2$] This corresponds to the non-existence of any object in
the \tds.
\item[$\cd=-1$] This corresponds to a single vertex and a single cell. In a
\item[$\cd=-1$] This corresponds to a single vertex and a single full cell. In a
geometric triangulation, this vertex corresponds to the vertex at infinity.
\item[$\cd=0$] This corresponds to two vertices (geometrically, the finite vertex and
the infinite vertex), each corresponding to a cell;
the two cells being neighbors of each other. This is the unique
the infinite vertex), each corresponding to a full cell;
the two full cells being neighbors of each other. This is the unique
triangulation of the $0$-sphere.
\item[$0<\cd\le\ad$] This corresponds to a standard triangulation of
the sphere $\sphere^\cd$.
\end{itemize}
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - TDS IMPLEMENTATION
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - T D S IMPLEMENTATION
\subsection{The class \ccc{Triangulation_data_structure}\label{triangulation:tds:impl}}
We give here some details about the class
\ccc{Triangulation_data_structure<Dimensionality, TDSVertex,
TDSFullCell>}
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex,
TriangulationDSFullCell>}
implementing the concept \ccc{TriangulationDataStructure}.
@ -192,7 +204,7 @@ Each full cell stores references to its $\cd+1$ vertices and
neighbors. Its vertices and neighbors are indexed from $0$ to \cd. The indices
of its neighbors have the following meaning: the $i$-th neighbor of $\sigma$
is the unique neighbor of $\sigma$ that does not contain the $i$-th vertex of
$\sigma$; in other words, it is the neighbor of $\sigma$ \textbf{opposite} to
$\sigma$; in other words, it is the neighbor of $\sigma$ \em{opposite} to
the $i$-th vertex of $\sigma$.
\begin{figure}[htbp]
@ -203,24 +215,25 @@ the $i$-th vertex of $\sigma$.
\end{ccTexOnly}
\begin{ccHtmlOnly}
<center>
<img border=0 src="./fig/simplex-structure.png" align="middle" alt="Index the vertices and neighbors of a simplex">
<img border=0 src="./fig/simplex-structure.png" align="middle"
alt="Index the vertices and neighbors of a full cell">
</center>
\end{ccHtmlOnly}
\caption{Indexing the vertices and neighbors of a simplex $s$ in
\caption{Indexing the vertices and neighbors of a full cell $c$ in
dimension $\cd=2$.}
\label{triangulation:fig:simplex}
\label{triangulation:fig:full-cell}
\end{figure}
\subsubsection{Instantiating the class template}
The \ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>}
The \ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
class template is designed in such a way that its user can choose
\begin{itemize}
\item the ambient dimension of the triangulation data structure by specifying the \ccc{Dimensionality} template parameter,
\item the type used to represent vertices by specifying the \ccc{TDSVertex}
\item the type used to represent vertices by specifying the \ccc{TriangulationDSVertex}
template parameter and
\item the type used to represent simplices by specifying the
\ccc{TDSFullCell} template parameter.
\item the type used to represent full cells by specifying the
\ccc{TriangulationDSFullCell} template parameter.
\end{itemize}
The last two parameters have default values and are thus not necessary, unless
@ -229,23 +242,23 @@ template). The first template parameter, \ccc{Dimensionality}, must be
one of the following:
\begin{itemize}
\item \ccPureGlobalScope\ccc{Dimension_tag<D>} for some integer \ad. This
indicates that the pure complex can store simplices of dimension at most
indicates that the triangulation can store full cells of dimension at most
\ad. The maximum dimension \ad\ is known by the compiler, which
triggers some optimizations.
\item \ccPureGlobalScope\ccc{Dynamic_dimension_tag}. In this case, the maximum
dimension of the simplices must be passed as an integer argument to an instance
dimension of the full cells must be passed as an integer argument to an instance
constructor (see \ccc{TriangulationDataStructure}).
\end{itemize}
The \ccc{TDSVertex} and \ccc{TDSFullCell} parameters to the class template
The \ccc{TriangulationDSVertex} and \ccc{TriangulationDSFullCell} parameters to the class template
must be models of the concepts \ccc{TriangulationDSVertex} and
\ccc{TriangulationDSFullCell} respectively. \cgal\ provides models for these
concepts: \ccc{Triangulation_ds_vertex<TDS>} and
\ccc{Triangulation_ds_simplex<TDS, TDSFullCellStoragePolicy>}, which, as one
concepts: \ccc{Triangulation_ds_vertex<TriangulationDataStructure>} and
\ccc{Triangulation_ds_full_cell<TriangulationDataStructure, TDSFullCellStoragePolicy>}, which, as one
can see, take the \tds\ as a template parameter in order to get access to
some nested types in \tds.
\textbf{This creates a circular dependency}, which we resolve in the same way
\em{This creates a circular dependency}, which we resolve in the same way
as in the \cgal\ \ccc{Triangulation_2} and \ccc{Triangulation_3} packages (see
Chapters~\ref{chapter-TDS2},~\ref{chapter-Triangulation2},~\ref{chapter-TDS3},~and~\ref{chapter-Triangulation3}).
In particular, models of the concepts \ccc{TriangulationDSVertex} and
@ -280,11 +293,11 @@ It is also possible to fix it at run time as in the next example.
\subsubsection{Barycentric subdivision}
This example provides a function for computing the barycentric subdivision of a
single full cell \ccc{fc} in a triangulation data structure. The other full
cells neighboring \ccc{fc} are automatically subdivided to match the
subdivision of the cell \ccc{fc}. The barycentric subdivision of \ccc{fc} is
obtained by enumerating all the faces of \ccc{fc} in order of decreasing
dimension, from the dimension of~\ccc{fc} to dimension~1, and inserting a new
single full cell \ccc{c} in a triangulation data structure. The other
full cells neighboring \ccc{c} are automatically subdivided to match the
subdivision of the full cell \ccc{c}. The barycentric subdivision of \ccc{c} is
obtained by enumerating all the faces of \ccc{c} in order of decreasing
dimension, from the dimension of~\ccc{c} to dimension~1, and inserting a new
vertex in each face. For the enumeration, we use a combinatorial enumerator,
which is not documented, but provided in \cgal.
@ -302,7 +315,7 @@ alt="Barycentric subdivision">
</center>
\end{ccHtmlOnly}
\caption{Barycentric subdivision in dimension $\cd=2$.}
\label{triangulation:fig:simplex}
\label{triangulation:fig:barycentric}
\end{figure}
\ccIncludeExampleCode{Triangulation/barycentric_subdivision.cpp}
@ -312,41 +325,41 @@ alt="Barycentric subdivision">
\section{Triangulations}
The class \ccc{CGAL::Triangulation<TrTraits, TDS>} embeds an abstract
The class \ccc{CGAL::Triangulation<TriangulationTraits, TriangulationDataStructure>} embeds an abstract
triangulation into Euclidean space. More precisely, it
maintains a triangulation (a partition into pairwise interior-disjoint full
cells) of the convex hull of the points (the embedded vertices) of the
maintains a triangulation (a partition into pairwise interior-disjoint
full cells) of the convex hull of the points (the embedded vertices) of the
triangulation, as well as a triangulation of the complement of the convex hull
\textbf{in the affine subspace} spanned by the triangulation's points
\em{in the affine subspace} spanned by the triangulation's points
using a special vertex at infinity.
Methods are provided for the insertion of points in the triangulation, the
contraction of faces, the traversal of various elements of the triangulation
as well as the localization of a query point inside the triangulation.
Infinite cells outside the convex hull are each incident to
Infinite full cells outside the convex hull are each incident to
a finite facet on the convex hull of the triangulation and to a unique special
\textbf{vertex at infinity}.
%\note{In every infinite cell, the vertex at infinity always has index $0$.}
\em{vertex at infinity}.
%\note{In every infinite full cell, the vertex at infinity always has index $0$.}
%\note{SH: the above note this should go in the documentation of the
%\ccc{TriangulationDataStructure} concept, or that of the class?}
As long as no \emph{advanced} class method is called, it is guaranteed that
all finite cells have positive orientation. The infinite cells are
all finite full cells have positive orientation. The infinite full cells are
oriented so that the finite vertices of the triangulation lies on the negative side of
the oriented hyperplane defined by the cell's finite facet.
the oriented hyperplane defined by the full cell's finite facet.
% - - - - - - - - - - - - - - - - - - - - - - - - - Triangulation IMPLEMENTATION
\subsection{Implementation}
The class \ccc{CGAL::Triangulation<TrTraits, TDS>} stores a model \ccc{TDS}
The class \ccc{CGAL::Triangulation<TriangulationTraits, TriangulationDataStructure>} stores a model \tds
of the concept \ccc{TriangulationDataStructure} which is instantiated with a
vertex type that stores a point, and a full cell type that allows the retrieval
of the point of its vertices.
The template parameter \ccc{TrTraits} must be a model of the concept
The template parameter \ccc{TriangulationTraits} must be a model of the concept
\ccc{TriangulationTraits} which provides the geometric \ccc{Point} type as well
as various geometric predicates used by the \ccc{Triangulation} class.
@ -361,7 +374,7 @@ random points. In \ccc{STEP 1}, we generate one hundred random points in
$\real^5$, which we then insert into a triangulation. In \ccc{STEP 2}, we
%have a little fun and
ask the triangulation to construct the set of edges
($1$-cells) incident to the vertex at infinity. It is easy to see that
($1$ dimensional faces) incident to the vertex at infinity. It is easy to see that
these edges are in bijection with the vertices on the convex hull of the
points. This gives us a handy way to count the convex hull vertices.
%(Note that
@ -377,15 +390,15 @@ points. This gives us a handy way to count the convex hull vertices.
Remember that a triangulation triangulates the convex hull of its
vertices.
In general position, each
facet of the convex hull is incident to one finite cell and one infinite
cell. In fact there is a bijection between the infinite cells and the
facet of the convex hull is incident to one finite full cell and one infinite
full cell. In fact there is a bijection between the infinite full cells and the
facets of the convex hull.
If vertices are not in general position, convex hull faces that are
not simplices are triangulated.
So, in order to traverse the convex hull facets,
there are (at least) two possibilities:
The first is to iterate over the cells of the triangulation and check if they
The first is to iterate over the full cells of the triangulation and check if they
are infinite or not:
\begin{ccExampleCode}
@ -393,11 +406,11 @@ are infinite or not:
typedef Triangulation::Full_cell_iterator Full_cell_iterator;
typedef Triangulation::Facet Facet;
for( Full_cell_iterator fcit = t.full_cells_begin();
fcit != t.full_cells_end(); ++fcit ) {
if( ! t.is_infinite(fcit) )
for( Full_cell_iterator cit = t.full_cells_begin();
cit != t.full_cells_end(); ++cit ) {
if( ! t.is_infinite(cit) )
continue;
Facet ft(fcit, fcit->index(t.infinite_vertex() ) );
Facet ft(cit, cit->index(t.infinite_vertex() ) );
++i;// |ft| is a facet of the convex hull
}
std::cout << "There are " << i << " facets on the convex hull."<< std::endl;}
@ -405,9 +418,9 @@ std::cout << "There are " << i << " facets on the convex hull."<< std::endl;}
\textbf{Remark}: the code example above is not self contained, it can
be cut and paste at STEP 2 of {\tt triangulation.cpp} program above.
A second possibility is to ask the triangulation to gather all the cells
A second possibility is to ask the triangulation to gather all the full cells
incident to the infinite vertex: they form precisely the set of infinite
cells:
full cells:
\begin{ccExampleCode}
{int i=0;
@ -431,28 +444,28 @@ std::cout << "There are " << i << " facets on the convex hull."<< std::endl;}
be cut and paste at STEP 2 of {\tt triangulation.cpp} program above.
One important difference between the two examples above is that the first uses
\emph{little} memory but traverses \emph{all} the cells, while the second
visits \emph{only} the infinite cells but stores handles to them into a
\emph{little} memory but traverses \emph{all} the full cells, while the second
visits \emph{only} the infinite full cells but stores handles to them into a
\emph{potentially big} array.
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - DELAUNAY TRIANGULATIONS
\section{Delaunay Triangulations}%and regular triangulationes}
The class \ccc{CGAL::Delaunay_triangulation<DTTraits, TDS>} derives from
\ccc{CGAL::Triangulation<DTTraits, TDS>} and adds further constraints to a
The class \ccc{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} derives from
\ccc{CGAL::Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} and adds further constraints to a
triangulation, in that all its full cells must have the so-called
\textbf{Delaunay} or \textbf{empty-ball} property: the interior of the ball
\em{Delaunay} or \em{empty-ball} property: the interior of the ball
circumscribing any full cell must be free from any vertex
of the triangulation.
The \textbf{circumscribing ball} of a full cell \ccc{fc} is the ball
The \em{circumscribing ball} of a full cell is the ball
having all vertices of the full cell on its boundary.
In case of degeneracies (co-spherical points) the triangulation is not
uniquely defined,
note however that the \cgal\ implementation computes a unique
triangulation even in these cases.
%The \textbf{circumscribing sphere} of a face \ccc{s} is the smallest sphere
%The \em{circumscribing sphere} of a face \ccc{c} is the smallest sphere
%touching all vertices of the face. A triangulation of the convex
%hull of a finite point set has the Delaunay (or empty-ball) property if all
%its full cells have the Delaunay (or empty-ball) property:
@ -462,11 +475,11 @@ triangulation even in these cases.
%interior of its circumscribing sphere.
When a new point \ccc{p} is inserted into a Delaunay triangulation, the
finite cells whose circumscribing sphere contain \ccc{p} are said to
\textbf{be in conflict} with point \ccc{p}. The set of cells that are in
conflict with \ccc{p} form the \textbf{conflict zone}. That conflict zone is
augmented with the infinite cells whose finite facet does not lie
anymore on the convex hull of the triangulation (with \ccc{p} added). The cells
finite full cells whose circumscribing sphere contain \ccc{p} are said to
\em{be in conflict} with point \ccc{p}. The set of full cells that are in
conflict with \ccc{p} form the \em{conflict zone}. That conflict zone is
augmented with the infinite full cells whose finite facet does not lie
anymore on the convex hull of the triangulation (with \ccc{p} added). The full cells
in the conflict zone are removed, leaving a hole that contains \ccc{p}. That
hole is then re-triangulated in a ``star shape'' centered at \ccc{p}.
@ -476,13 +489,13 @@ Delaunay triangulations also support vertex removal.
\subsection{Implementation}
The class \ccc{CGAL::Delaunay_triangulation<DTTraits, TDS>} derives from
\ccc{CGAL::Triangulation<DTTraits, TDS>}. It thus stores a model \ccc{TDS} of
The class \ccc{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} derives from
\ccc{CGAL::Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}. It thus stores a model \tds of
the concept \ccc{TriangulationDataStructure} which is instantiated with a vertex
type that stores a geometric point, and a full cell type that allows the
retrieval of the points of its vertices.
The template parameter \ccc{DTTraits} must be a model of the concept
The template parameter \ccc{DelaunayTriangulationTraits} must be a model of the concept
\ccc{DelaunayTriangulationTraits} which provides the geometric \ccc{Point} type as
well as various geometric predicates used by the \ccc{Delaunay_triangulation} class.
The concept \ccc{DelaunayTriangulationTraits} refines the concept
@ -493,14 +506,14 @@ for the computation of Delaunay triangulations.
\subsection{Examples}
\subsubsection{Access to the conflict zone and created cells during point
\subsubsection{Access to the conflict zone and created full cells during point
insertion}
When using a cell type containing additional custom information, it may be
useful to get an efficient access to the cells that are going to be erased
When using a full cell type containing additional custom information, it may be
useful to get an efficient access to the full cells that are going to be erased
upon the insertion of a new point in the Delaunay triangulation, and to the newly
created cells. The second part of code example below shows how one can have efficient
access to both the conflict zone and the created cells, while still
created full cells. The second part of code example below shows how one can have efficient
access to both the conflict zone and the created full cells, while still
retaining an efficient update of the Delaunay triangulation.
\ccIncludeExampleCode{Triangulation/delaunay.cpp}

4
Triangulation/doc_tex/Triangulation_ref/DelaunayTriangulationTraits.tex
View File

@ -5,9 +5,9 @@
The concept \ccRefName\ describes the various types and functions that a class
has to provide as the first parameter (\ccc{DCTraits}) to the class template
\ccc{Delaunay_triangulation<DTTraits, TDS>}. It brings the geometric ingredient to
\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}. It brings the geometric ingredient to
the definition of a Delaunay complex, while the combinatorial ingredient is
brought by the second template parameter, \ccc{TDS}.
brought by the second template parameter, \ccc{TriangulationDataStructure}.
\ccRefines

43
Triangulation/doc_tex/Triangulation_ref/Delaunay_triangulation.tex
View File

@ -1,4 +1,4 @@
\begin{ccRefClass}{Delaunay_triangulation<DTTraits, TDS>}
\begin{ccRefClass}{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
\ccDefinition
@ -14,26 +14,26 @@ means.
\ccParameters
\ccc{DTTraits} is the geometric traits class that provides the geometric types
and predicates needed by Delaunay triangulations. \ccc{DTTraits} must be a model of
\ccc{DelaunayTriangulationTraits} is the geometric traits class that provides the geometric types
and predicates needed by Delaunay triangulations. \ccc{DelaunayTriangulationTraits} must be a model of
the concept \ccc{DelaunayTriangulationTraits}.
\ccc{TDS} is the class used to store the underlying triangulation data
structure. \ccc{TDS} must be a model of the concept
\ccc{TriangulationDataStructure} is the class used to store the underlying triangulation data
structure. \ccc{TriangulationDataStructure} must be a model of the concept
\ccc{TriangulationDataStructure}. The class template \ccRefName\ accepts that no
second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as
second parameter. In both cases, \ccc{TDS} defaults to
second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to
\ccc{Triangulation_data_structure<
Ambient_dimension<DTTraits::Point_d>::type,
Triangulation_vertex<DTTraits>,
Triangulation_full_cell<DTTraits> >}.
Ambient_dimension<DelaunayTriangulationTraits::Point_d>::type,
Triangulation_vertex<DelaunayTriangulationTraits>,
Triangulation_full_cell<DelaunayTriangulationTraits> >}.
\ccInheritsFrom
\ccc{Triangulation<DTTraits, TDS>}.
\ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}.
The class \ccc{Delaunay_triangulation<DTTraits, TDS>} inherits all the types
defined in the base class \ccc{Triangulation<DTTraits, TDS>}. Additionally, it
The class \ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} inherits all the types
defined in the base class \ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}. Additionally, it
defines or overloads the following methods:
\ccCreation % - - - - - - - - - - - - - - - - - - - - - - - - - - - CREATION
@ -43,7 +43,7 @@ defines or overloads the following methods:
\ccConstructor{Delaunay_triangulation(const int dim, const Geom_traits k =
Geom_traits());}{Instantiates a Delaunay triangulation with one vertex (the vertex
at infinity). See the description of the inherited nested type
\ccc{Triangulation<DTTraits, TDS>::Ambient_dimension} for an explanation of
\ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>::Ambient_dimension} for an explanation of
the use of the parameter \ccc{dim}. The complex stores a copy of the geometric
traits \ccc{k}.}
@ -52,7 +52,7 @@ traits \ccc{k}.}
\ccMethod{Full_cell_handle remove(Vertex_handle v);}{Remove the vertex \ccc{v}
from the Delaunay triangulation. If the current dimension of the triangulation has not
changed after the removal, then the returned cell \ccc{c} geometrically
changed after the removal, then the returned full cell \ccc{c} geometrically
contains the removed vertex \ccc{v} (\ccc{c} can be finite or infinite).
Otherwise, the default-constructed \ccc{Full_cell_handle} is returned.
\ccPrecond \ccc{v} is a vertex of the triangulation, different from the
@ -62,8 +62,8 @@ Otherwise, the default-constructed \ccc{Full_cell_handle} is returned.
% the Delaunay triangulation. If a vertex is found at position \ccc{p}, it is removed
% from it, otherwise, the default-constructed \ccc{Full_cell_handle} is returned.
% If \ccc{p} is found and if the current dimension of the complex has not
% changed after the removal, then the returned simplex \ccc{s} geometrically
% contains the removed point \ccc{p} (\ccc{s} can be finite or infinite).
% changed after the removal, then the returned full cell \ccc{c} geometrically
% contains the removed point \ccc{p} (\ccc{c} can be finite or infinite).
% Otherwise, the default-constructed \ccc{Full_cell_handle} is returned.}
% \ccMethod{Full_cell_handle remove(const Point & p, Full_cell_handle hint);}{Same
@ -108,7 +108,8 @@ value of \ccc{lt}:\begin{itemize} \item[\ccc{OUTSIDE_AFFINE_HULL}] Point
triangulation. The method \ccVar.\ccc{insert_outside_affine_hull()} is called.
\item[\ccc{ON_VERTEX}] The position of the vertex \ccc{v} described by \ccc{f}
is set to \ccc{p}. \ccc{v} is returned. \item[Anything else] The point \ccc{p}
is inserted in the conflict zone \textbf{which is assumed} to contain cell
is inserted in the conflict zone \em{which is assumed} to contain
full cell
\ccc{c}. (Roughly speaking, the method \ccVar.\ccc{insert_in_conflict_zone()}
is called.)\end{itemize} \ccPrecond The parameters \ccc{lt}, \ccc{f}, \ccc{ft}
and \ccc{c} must be consistent with the localization of point \ccc{p} in the
@ -133,16 +134,16 @@ must be in conflict with the full cell \ccc{c}.}
\ccMethod{bool conflict(const Point & p, Full_cell_const_handle c)
const;}{Returns \ccc{true} if and only if the point \ccc{p} is in (Delaunay)
conflict with cell \ccc{c} ({i.e.}, the circumscribing ball of
conflict with full cell \ccc{c} ({i.e.}, the circumscribing ball of
$c$ contains $p$ in its interior).
}
\begin{ccAdvanced}
\ccMethod{Facet compute_conflict_zone(const Point & p, const Full_cell_handle c,
OutputIterator out) const;}{Outputs handles to the simplices in confict with
point \ccc{p} into the \ccc{OutputIterator out}. The cell \ccc{c} is used
as a starting point for gathering the cells in conflict with \ccc{p}.
OutputIterator out) const;}{Outputs handles to the full cells in confict with
point \ccc{p} into the \ccc{OutputIterator out}. The full cell \ccc{c} is used
as a starting point for gathering the full cells in conflict with \ccc{p}.
\ccPrecond \ccc{c} is in conflict
with \ccc{p}.\\ \ccVar.\ccc{current_dimension()}$\geq 2$.
}

2
Triangulation/doc_tex/Triangulation_ref/RegularTriangulationTraits.tex
View File

@ -46,7 +46,7 @@ subspace Aff. It is guaranteed that the affine subspace Aff is given a
consistent orientation when it is called many times with simplex points (in
range \ccc{[start,end)}) living in a same affine subspace.\\
\textbf{Important.} Information about the affine subspace Aff is computed
\textbf{once} and then stored in the predicate class, so it is wise to keep an
\em{once} and then stored in the predicate class, so it is wise to keep an
instance of the predicate around as long as one is sure that the affine
subspace Aff doesn't change. \ccPrecond \ccc{std::distance(start,end)>=3} and
\ccc{std::distance(start,end)<=start->dimension()+1}. The points in range

198
Triangulation/doc_tex/Triangulation_ref/Triangulation.tex
View File

@ -1,36 +1,36 @@
\begin{ccRefClass}{Triangulation<TrTraits, TDS>}
\begin{ccRefClass}{Triangulation<TriangulationTraits, TriangulationDataStructure>}
\ccDefinition
The class \ccRefName\ is used to store and query the cells and vertices of
The class \ccRefName\ is used to store and query the full cells and vertices of
a triangulation embedded in $\real^d$.
\ccInclude{CGAL/Triangulation.h}
\ccParameters
\ccc{TrTraits} is the geometric traits class that provides the geometric types
and predicates needed by triangulations. \ccc{TrTraits} must be a model of the
\ccc{TriangulationTraits} is the geometric traits class that provides the geometric types
and predicates needed by triangulations. \ccc{TriangulationTraits} must be a model of the
concept \ccc{TriangulationTraits}.
\ccc{TDS} is the class used to store the underlying triangulation data
structure. \ccc{TDS} must be a model of the concept
\ccc{TriangulationDataStructure} is the class used to store the underlying triangulation data
structure. \ccc{TriangulationDataStructure} must be a model of the concept
\ccc{TriangulationDataStructure}. The class template \ccRefName\ accepts that no
second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as
second parameter. In both cases, \ccc{TDS} defaults to
\ccc{Triangulation_data_structure<Ambient_dimension<TrTraits::Point_d>::type,
Triangulation_vertex<TrTraits>, Triangulation_full_cell<TrTraits>>}.
second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to
\ccc{Triangulation_data_structure<Ambient_dimension<TriangulationTraits::Point_d>::type,
Triangulation_vertex<TriangulationTraits>, Triangulation_full_cell<TriangulationTraits>>}.
\ccTypes
%The following types are self-explanatory: % but we are explaining anyway
\ccTypedef{typedef TrTraits Geom_traits;}%
\ccTypedef{typedef TriangulationTraits Geom_traits;}%
{The model for the \ccc{TriangulationTraits} concept.}
\ccTypedef{typedef TrTraits::Point_d Point;}{A point in Euclidean space.}
\ccTypedef{typedef TriangulationTraits::Point_d Point;}{A point in Euclidean space.}
\ccTypedef{typedef Ambient_dimension<TrTraits::Point_d>::type
\ccTypedef{typedef Ambient_dimension<TriangulationTraits::Point_d>::type
Ambient_dimension;}%
{This indicates whether the dimension of the ambient Euclidean space is static
(\ccc{Ambient_dimension}=\ccGlobalScope\ccc{Dimension_tag<int dim>}) or
@ -38,46 +38,40 @@ dynamic (\ccc{Ambient_dimension}=\ccGlobalScope\ccc{Dynamic_dimension_tag}).
In the latter case, the \ccc{dim} parameter passed to the class's constructor
is used.}
\ccTypedef{typedef TDS Triangulation_ds;}%
\ccTypedef{typedef TriangulationDataStructure Triangulation_ds;}%
{The second template parameter.}
\ccTypedef{typedef TDS::Vertex Vertex;}{A model of the concept
\ccTypedef{typedef TriangulationDataStructure::Vertex Vertex;}{A model of the concept
\ccc{TriangulationVertex}.}
\ccGlue
\ccTypedef{typedef TDS::Full_cell Full_cell;}{A model of the concept
\ccTypedef{typedef TriangulationDataStructure::Full_cell Full_cell;}{A model of the concept
\ccc{TriangulationFullCell}.}
\ccGlue
\ccTypedef{typedef TDS::Facet Facet;}{}
\ccTypedef{typedef TriangulationDataStructure::Facet Facet;}{}
\ccGlue
\ccTypedef{typedef TDS::Face Face;}%
\ccTypedef{typedef TriangulationDataStructure::Face Face;}%
{A model of the concept \ccc{TriangulationFace}.}
The vertices and cells of triangulations are accessed through handles,
The vertices and full cells of triangulations are accessed through handles,
iterators and circulators. A handle is a model of the \ccc{Handle} concept,
and supports the two dereference operators \ccc{operator*} and
\ccc{operator->}. A circulator is a model of the concept \ccc{Circulator}.
Iterators and circulators are bidirectional and non-mutable.
%The edges and facets of the triangulation can also be visited through
%iterators and circulators which are bidirectional and non-mutable.
Iterators and circulators are convertible to the corresponding handles, thus
the user can pass them directly as arguments to the functions.
\ccTypedef{typedef TDS::Vertex_handle Vertex_handle;}{}
\ccGlue\ccTypedef{typedef TDS::Vertex_iterator Vertex_iterator;}{}
%\ccGlue\ccTypedef{typedef TDS::Vertex_const_handle Vertex_const_handle;}{}
%\ccGlue\ccTypedef{typedef TDS::Vertex_const_iterator Vertex_const_iterator;}{}
\ccTypedef{typedef TriangulationDataStructure::Vertex_handle Vertex_handle;}{}
\ccGlue\ccTypedef{typedef TriangulationDataStructure::Vertex_iterator Vertex_iterator;}{}
\ccTypedef{typedef TDS::Full_cell_handle Full_cell_handle;}{}
\ccGlue\ccTypedef{typedef TDS::Full_cell_iterator Full_cell_iterator;}{}
%\ccGlue\ccTypedef{typedef TDS::Full_cell_const_handle Full_cell_const_handle;}{}
%\ccGlue\ccTypedef{typedef TDS::Full_cell_const_iterator Full_cell_const_iterator;}{}
\ccTypedef{typedef TriangulationDataStructure::Full_cell_handle Full_cell_handle;}{}
\ccGlue\ccTypedef{typedef TriangulationDataStructure::Full_cell_iterator Full_cell_iterator;}{}
\ccTypedef{typedef TDS::Facet_iterator Facet_iterator;}{}
\ccTypedef{typedef TriangulationDataStructure::Facet_iterator Facet_iterator;}{}
\ccTypedef{typedef TDS::size_type size_type;}{Size type (an unsigned integral
\ccTypedef{typedef TriangulationDataStructure::size_type size_type;}{Size type (an unsigned integral
type).}
\ccGlue\ccTypedef{typedef TDS::difference_type difference_type;}{Difference
\ccGlue\ccTypedef{typedef TriangulationDataStructure::difference_type difference_type;}{Difference
type (a signed integral type).}
The \ccRefName\ class also defines the following enum type to specify
@ -135,19 +129,19 @@ reference to the underlying triangulation data structure.}
{Returns the number of finite vertices in the triangulation.}
\ccGlue
\ccMethod{size_type number_of_full_cells() const;}%
{Returns the number of cells of maximal dimension in the triangulation
(cells incident to the vertex at infinity are counted).}
{Returns the number of full cells of maximal dimension in the triangulation
(full cells incident to the vertex at infinity are counted).}
\ccMethod{Vertex_handle infinite_vertex() const;}%
{Returns a handle to the vertex at infinity.}
\ccMethod{Full_cell_handle infinite_full_cell() const;}%
{Returns a handle to some cell incident to the vertex at infinity.}
{Returns a handle to some full cell incident to the vertex at infinity.}
\ccHeading{Non-constant-time access functions}
\ccMethod{size_type number_of_finite_full_cells() const;}%
{Returns the number of cells of maximal dimension that are not
{Returns the number of full cells of maximal dimension that are not
incident to the vertex at infinity.}
\ccHeading{Tests for finite and infinite elements}
@ -173,32 +167,8 @@ vertex.
\ccMethod{bool is_infinite(const Face & f) const;}{Returns \ccc{true} if and
only if the face \ccc{f} is incident to the infinite vertex.
%\ccPrecond $2\leq$\ccVar.\ccc{current_dimension()}.
}
% \ccMethod{bool is_finite(const Vertex_handle v) const;} {Returns \ccc{true} if
% and only if the vertex \ccc{v} is not the infinite vertex.}
% \ccGlue
% \ccMethod{bool is_finite(const Full_cell_handle s) const;}{Returns \ccc{true} if
% and only if all vertices of \ccc{s} are finite.
% %\ccPrecond\ccc{0 <=}\ccVar.\ccc{current_dimension()}.
% }
% \ccGlue
% \ccMethod{bool is_finite(const Facet & ft) const;}{Returns \ccc{true} if and
% only if all vertices of the facet \ccc{ft} are finite.
% %\ccPrecond\ccc{1 <=}\ccVar.\ccc{current_dimension()}.
% }
% \ccGlue
% \ccMethod{bool is_finite(const Face & f) const;}{Returns \ccc{true} if and
% only if all vertices of the face \ccc{f} are finite.
% %\ccPrecond{\ccc{2 <=}\ccVar.\ccc{current_dimension()}}.
% }
\ccHeading{Queries}
@ -214,37 +184,37 @@ an optional parameter that is used as a hint for the point location.}
{Tests whether \ccc{v} is a vertex of \ccVar.}
\ccMethod{bool is_full_cell(Full_cell_handle c) const;}
{Tests whether \ccc{c} is a cell of \ccVar.}
{Tests whether \ccc{c} is a full cell of \ccVar.}
\ccMethod{Orientation orientation(Full_cell_handle c) const;}
{Returns the orientation of the finite cell \ccc{c}:
{Returns the orientation of the finite full cell \ccc{c}:
\ccGlobalScope\ccc{POSITIVE}, \ccGlobalScope\ccc{NEGATIVE} or
\ccGlobalScope\ccc{COPLANAR}. If \ccVar.\ccc{current_dimension() == 0}, then
\ccGlobalScope\ccc{POSITIVE} is returned. Under normal circumstances, the function
should always return \ccGlobalScope\ccc{POSITIVE}.
\ccPrecond Full cell \ccc{c} must be finite.
\note{should be removed, a valid cell is positive}\note{SH: what if user modifies the triangulation arbitrarily?}
\note{should be removed, a valid full cell is positive}\note{SH: what if user modifies the triangulation arbitrarily?}
}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_full_cells(Vertex_const_handle v, OutputIterator out) const;}
{Insert in \ccc{out} all the cells that are incident to the vertex
\ccc{v}, {i.e.}, the cells that have the \ccc{Vertex v} as a vertex.
{Insert in \ccc{out} all the full cells that are incident to the vertex
\ccc{v}, {i.e.}, the full cells that have the \ccc{Vertex v} as a vertex.
Returns the (modified) output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_full_cells(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the cells that are incident to the face \ccc{f},
{i.e.}, the cells that have the \ccc{Face f} as a subface.
{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f},
{i.e.}, the full cells that have the \ccc{Face f} as a subface.
Returns the (probably modified) output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
star(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the cells that share at least one vertex with the \ccc{Face
{Insert in \ccc{out} all the full cells that share at least one vertex with the \ccc{Face
f}. Returns the (probably modified) output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
}
@ -260,11 +230,11 @@ constructed.
\ccMethod{template< typename OutputIterator > OutputIterator
incident_upper_faces(Vertex_const_handle v, int d, OutputIterator
out);}{Constructs all the \textbf{upper} \ccc{Face}s of dimension \ccc{d}
out);}{Constructs all the \em{upper} \ccc{Face}s of dimension \ccc{d}
incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\
Assuming some total ordering on the vertices of the triangulation (which is
invariant as long as no vertex is inserted in or removed from the triangulation), a
\ccc{Face} incident to \ccc{v} is an \emph{upper} \ccc{Face} if and only if
\ccc{Face} incident to \ccc{v} is an \em{upper} \ccc{Face} if and only if
its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In
particular, taking the disjoint union of the upper \ccc{Face}s of dimension
\ccc{d} incident to every vertex of the triangulation yields exactly the set of
@ -287,11 +257,11 @@ the vertex ordering to define the upper faces.}
\ccHeading{Faces and Facets} % - - - - - - - - - - - - - - - - - - - - FACETS
\ccMethod{Full_cell_handle full_cell(const Facet & f) const;}
{Returns a cell containing the facet \ccc{f}}
{Returns a full cell containing the facet \ccc{f}}
\ccMethod{int index_of_covertex(const Facet & f) const;}
{Returns the index of the vertex of the cell
\ccc{c=}\ccVar.\ccc{full_cell(f)} which does \textbf{not} belong to \ccc{c}.}
{Returns the index of the vertex of the full cell
\ccc{c=}\ccVar.\ccc{full_cell(f)} which does {not} belong to \ccc{c}.}
%\begin{ccAdvanced}
%\ccMethod{Face make_empty_face() const;}{Returns an empty \ccc{Face}.}
@ -318,17 +288,17 @@ the vertex ordering to define the upper faces.}
%\ccMethod{Full_cell_const_iterator full_cells_begin()const;}{}\ccGlue
\ccMethod{Full_cell_iterator full_cells_begin();}
{The first cell of \ccVar.}
{The first full cell of \ccVar.}
%\ccGlue\ccMethod{Full_cell_const_iterator full_cells_end() const;}{}
\ccGlue\ccMethod{Full_cell_iterator full_cells_end();}
{The beyond cell of \ccVar.}
{The beyond full cell of \ccVar.}
%\ccMethod{Finite_full_cell_const_iterator finite_full_cells_begin() const;}{}\ccGlue
\ccMethod{Finite_full_cell_iterator finite_full_cells_begin();}
{The first finite cell of \ccVar.}
{The first finite full cell of \ccVar.}
%\ccGlue\ccMethod{Finite_full_cell_const_iterator finite_full_cells_end() const;}{}
\ccGlue\ccMethod{Finite_full_cell_iterator finite_full_cells_end();}
{The beyond finite cell of \ccVar.}
{The beyond finite full cell of \ccVar.}
\ccMethod{Facet_iterator facets_begin();}
{Iterator to the first facet of the triangulation.}
@ -349,20 +319,20 @@ the triangulation:
\ccMethod{Full_cell_handle locate(const Point & query,
Full_cell_handle hint = Full_cell_handle()) const;}
{If the point \ccc{query} lies inside a bounded (finite) cell of \ccVar,
the latter cell is returned.\\
If \ccc{query} lies on the boundary of some finite cells, one of them
{If the point \ccc{query} lies inside a bounded (finite) full cell of \ccVar,
the latter full cell is returned.\\
If \ccc{query} lies on the boundary of some finite full cells, one of them
is returned.\\
Let $d=$\ccVar.\ccc{current_dimension()}. If the point \ccc{query} lies
outside the convex hull of the points, an infinite cell with vertices $\{
p_1, p_2, \ldots, p_d, \infty\}$ is returned such that the cell $(p_1, p_2,
outside the convex hull of the points, an infinite full cell with vertices $\{
p_1, p_2, \ldots, p_d, \infty\}$ is returned such that the full cell $(p_1, p_2,
\ldots, p_d, query)$ is positively oriented (the rest of the triangulation lies
on the other side of facet $(p_1, p_2, \ldots, p_d)$).\\
The optional argument \ccc{hint} is used as a starting place for the search.}
\ccMethod{Full_cell_handle locate(const Point & query, Vertex_handle hint)
const;}
{Same as above but \ccc{hint} is a vertex and not a cell.}
{Same as above but \ccc{hint} is a vertex and not a full cell.}
\ccMethod{Full_cell_handle locate(const Point & query, Locate_type & loc_type,
Face & f, Facet & ft, Full_cell_handle hint = Full_cell_handle()) const;}
@ -370,27 +340,27 @@ Face & f, Facet & ft, Full_cell_handle hint = Full_cell_handle()) const;}
search.\\ If the \ccc{query} point lies outside the affine hull of the points,
which can happen when \ccVar.\ccc{current_dimension() < }
\ccVar.\ccc{ambient_dimension()}, \ccc{loc_type} is set to
\ccc{OUTSIDE_AFFINE_HULL}, and the returned cell has no meaning. As a
\ccc{OUTSIDE_AFFINE_HULL}, and the returned full cell has no meaning. As a
particular case, if there is no finite vertex yet in the triangulation,
\ccc{loc_type} is set to \ccc{OUTSIDE_AFFINE_HULL} and \textit{locate} returns
\ccc{Full_cell_handle()}.\\ If the \ccc{query} point lies inside the affine hull
of the points, a $k$-face that contains \ccc{query} \textbf{in its relative
of the points, a $k$-face that contains \ccc{query} {in its relative
interior} is returned. (If the $k$-face is finite, it is
unique.)\begin{itemize} \item[$k=0$] \ccc{loc_type} is set to \ccc{ON_VERTEX},
\ccc{f} is set to the vertex \ccc{v} the \ccc{query} lies on and a cell
\ccc{f} is set to the vertex \ccc{v} the \ccc{query} lies on and a full cell
having \ccc{v} as a vertex is returned.
\item[$0<k<$\ccc{c.current_dimension()-1}] \ccc{loc_type} is set to
\ccc{IN_FACE}, \ccc{f} is set to the unique finite face containing the
\ccc{query} point. A cell having \ccc{f} on its boundary is returned.
\ccc{query} point. A full cell having \ccc{f} on its boundary is returned.
\item[$k=$\ccc{c.current_dimension()-1}] \ccc{loc_type} is set to
\ccc{IN_FACET}, \ccc{ft} is set to one of the two finite facets containing the
\ccc{query} point. The cell of \ccc{ft} is returned.
\ccc{query} point. The full cell of \ccc{ft} is returned.
\item[$k=$\ccc{c.current_dimension()}] If the \ccc{query} point lies
\textbf{outside} the convex hull of the points in the triangulation, then
\ccc{loc_type} is set to \ccc{OUTSIDE_CONVEX_HULL} and a cell is returned
\em{outside} the convex hull of the points in the triangulation, then
\ccc{loc_type} is set to \ccc{OUTSIDE_CONVEX_HULL} and a full cell is returned
as in the \ccc{locate} method above. If the \ccc{query} point lies
\textbf{inside} the convex hull of the points in the triangulation, then
\ccc{loc_type} is set to \ccc{IN_FULL_CELL} and the unique cell containing
\em{inside} the convex hull of the points in the triangulation, then
\ccc{loc_type} is set to \ccc{IN_FULL_CELL} and the unique full cell containing
the \ccc{query} point is returned. \end{itemize}}
\ccMethod{Full_cell_handle
@ -443,27 +413,27 @@ point \ccc{p} into the triangulation and returns a handle to the
The point \ccc{p} is inserted in the \ccc{Face f}. \item[\ccc{IN_FACET}]
The point \ccc{p} is inserted in the \ccc{Facet ft}. \item[Anything else]
The point \ccc{p} is inserted in the triangulation according to the value
of \ccc{loc_type}, using the cell \ccc{c}.\end{itemize} This method is used
of \ccc{loc_type}, using the full cell \ccc{c}.\end{itemize} This method is used
internally by the other \ccc{insert()} methods.}
\ccMethod{template < typename ForwardIterator, typename OutputIterator >
Vertex_handle insert_in_hole(const Point & p, ForwardIterator s,
ForwardIterator e, const Facet & ft, OutputIterator out);}{The cells in
ForwardIterator e, const Facet & ft, OutputIterator out);}{The full cells in
the range $C=$\ccc{[s, e)} are removed, thus forming a hole. A \ccc{Vertex} is
inserted at position \ccc{p} and connected to the boundary of the hole in
order to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is
returned. The facet \ccc{ft} must lie on the boundary of $C$ and its
defining cell, \ccVar.\ccc{full_cell(ft)} must lie inside $C$. Handles
to the newly created cells are output in the \ccc{out} output iterator.
defining full cell, \ccVar.\ccc{full_cell(ft)} must lie inside $C$. Handles
to the newly created full cells are output in the \ccc{out} output iterator.
\ccPrecond $C$ must be a (geometric) ball, must contain \ccc{p} in its
interior and not contain any vertex all of whose incident cells are in
interior and not contain any vertex all of whose incident full cells are in
$C$. (This implies that \ccVar.\ccc{current_dimension()}$\geq2$ if
$|C|>1$.) The boundary of $C$ must be a triangulation of the sphere
$\sphere^{k-1}$.}
\ccMethod{template < typename ForwardIterator > Vertex_handle
insert_in_hole(const Point & p, ForwardIterator s, ForwardIterator e, const
Facet & ft);}{Same as above, but the newly created cells are not
Facet & ft);}{Same as above, but the newly created full cells are not
retrieved.}
\ccMethod{Vertex_handle insert_in_face(const Point & p, const Face & f);}%
@ -475,19 +445,19 @@ retrieved.}
\ccPrecond \ccc{p} must lie in the relative interior of \ccc{ft}.}
\ccMethod{Vertex_handle insert_in_full_cell(const Point & p, Full_cell_handle
s);}%
c);}%
{Inserts point \ccc{p} in the triangulation. \ccPrecond \ccc{p} must lie in the
interior of \ccc{s}.}
interior of \ccc{c}.}
\ccMethod{Vertex_handle insert_outside_convex_hull(const Point &,
Full_cell_handle s);}%
Full_cell_handle c);}%
{Inserts point \ccc{p} in the triangulation.
\ccPrecond \ccc{p} must lie outside the convex hull of \ccVar. The half-space
defined by the infinite cell \ccc{s} must contain \ccc{p}.}
defined by the infinite full cell \ccc{c} must contain \ccc{p}.}
\ccMethod{Vertex_handle insert_outside_affine_hull(const Point &);}%
{Inserts point \ccc{p} in the triangulation.
\ccPrecond \ccc{p} must lie outside the \textbf{affine} hull of \ccVar.}
\ccPrecond \ccc{p} must lie outside the {affine} hull of \ccVar.}
\end{ccAdvanced}
@ -498,14 +468,14 @@ defined by the infinite cell \ccc{s} must contain \ccc{p}.}
\ccc{true} if the combinatorial triangulation data structure's \ccc{is_valid()}
test returns \ccc{true} and if some geometric tests are passed with success.
%\note{is it really necessary to have the following :
%For each infinite cell, it is checked that the index of the infinite
%For each infinite full cell, it is checked that the index of the infinite
%vertex is 0. }
For each finite cell, it is checked that its orientation is
For each finite full cell, it is checked that its orientation is
positive.}
\ccMethod{bool are_incident_full_cells_valid(Vertex_const_handle v, bool
verbose = true, int level = 0) const;} {Returns \ccc{true} if and only if all
finite cells incident to \ccc{v} have positive orientation.}
finite full cells incident to \ccc{v} have positive orientation.}
\ccHeading{Input/Output}
@ -514,9 +484,9 @@ finite cells incident to \ccc{v} have positive orientation.}
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
operators of the vertex and the full cell classes (such as point
coordinates), which are provided by overloading the stream operators
of the vertex and cell types. Assigns the resulting triangulation to
of the vertex and full cell types. Assigns the resulting triangulation to
\ccc{t}.}
\ccFunction{ostream& operator<< (ostream& os, const Triangulation & t);}
@ -524,16 +494,16 @@ of the vertex and cell types. Assigns the resulting triangulation to
The information in the \ccc{iostream} is: the current dimension, the number of
finite vertices, the non-combinatorial information about vertices (point,
\emph{etc.}), the number of cells, the indices of the vertices of each
cell, plus the non-combinatorial information about each cell, then the
indices of the neighbors of each cell, where the index corresponds to the
preceding list of cells.
\emph{etc.}), the number of full cells, the indices of the vertices of each
full cell, plus the non-combinatorial information about each full cell, then the
indices of the neighbors of each full cell, where the index corresponds to the
preceding list of full cells.
\ccSeeAlso
\ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>},\\
\ccc{Delaunay_triangulation<DTTraits, TDS>},\\
%\ccc{Regular_triangulation<RTTraits, TDS>}.
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>},\\
\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>},\\
%\ccc{Regular_triangulation<RTTraits, TriangulationDataStructure>}.
\end{ccRefClass}

80
Triangulation/doc_tex/Triangulation_ref/TriangulationDSFullCell.tex
View File

@ -5,9 +5,9 @@
The concept \ccRefName\ describes what a full cell is in a model of the concept
\ccc{TriangulationDataStructure}. It sets requirements of combinatorial nature
only, as geometry is not concerned here.
In the context of triangulation, the term cell refer to a face of
\emph{maximal} dimension. We emphasize this maximality characteristic by using
the term {\em full cell}.
In the context of triangulation, the term full cell refer to a face of
\emph{maximal} dimension. This maximality characteristic is emphasized by using
the adjective {\em full}.
A \ccRefName\ is responsible for storing handles to the vertices of a
full cell as well as handles to its neighbors.
@ -17,50 +17,50 @@ concept.
\ccHasModels
\ccc{Triangulation_ds_full_cell<TDS, TDSFullCellStoragePolicy>}\\
\ccc{Triangulation_full_cell<TrTraits, Data, TDSFullCell>}
\ccc{Triangulation_ds_full_cell<TriangulationDataStructure,DSFullCellStoragePolicy>}\\
\ccc{Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
\ccTypes
\ccNestedType{Vertex_handle}%{}
%\ccGlue\ccNestedType{Vertex_const_handle}
{A handle to a vertex. It must be the same as the
nested type \ccc{TDS::Vertex_handle} of the \ccc{TDS} in which the
nested type \ccc{TriangulationDataStructure::Vertex_handle} of the \ccc{TriangulationDataStructure} in which the
\ccc{TriangulationDSFullCell} is defined/used.}
\ccNestedType{Vertex_handle_iterator}{An iterator over the handles to
the vertices of the cell.}
the vertices of the full cell.}
\ccNestedType{Full_cell_handle}%{}
%\ccGlue\ccNestedType{Full_cell_const_handle}
{A handle to a full cell. It must be the same as the
nested type \ccc{TDS::Full_cell_handle} of the \ccc{TDS} in which the
nested type \ccc{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the
\ccc{TriangulationDSFullCell} is defined/used.}
\ccTypedef{typedef TDS::Full_cell_data TDS_data;}{}
\ccTypedef{typedef TriangulationDataStructure::Full_cell_data TDS_data;}{}
\ccNestedType{template<typename TDS2> Rebind_TDS}{This nested template
class must define a nested type \ccc{Other} which is the rebound cell
class must define a nested type \ccc{Other} which is the rebound full cell
class template, that is: \ccc{Other == TriangulationDSFullCell<TDS2>}.}
\ccCreation
\ccCreationVariable{c}
\ccConstructor{TriangulationDSFullCell(int dmax);}{Sets the maximum possible
dimension of the cell.}
dimension of the full cell.}
\ccConstructor{TriangulationDSFullCell(const TriangulationDSFullCell & fc);}%
{Copy constructor.}
If you want to create a cell as part of a \ccc{TriangulationDataStructure},
If you want to create a full cell as part of a \ccc{TriangulationDataStructure},
you would rather want to call the \ccc{new_full_cell()} from the latter concept,
as it is not possible to incorporate an existing external cell into
as it is not possible to incorporate an existing external full cell into
a triangulation.
\ccHeading{Access functions}
\ccMethod{int ambient_dimension() const;}{Returns one less than the maximum
number of vertices that the full cell can store. This does \textbf{not} return
number of vertices that the full cell can store. This does {not} return
the dimension of the actual full cell stored in \ccVar.}
\ccMethod{Vertex_handle_iterator vertices_begin() const;}
@ -72,29 +72,29 @@ full cell.}
the full cell.}
\ccMethod{Vertex_handle vertex(const int i) const;}{Returns the \ccc{i}-th vertex
of the cell. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}
of the full cell. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}
\ccGlue\ccMethod{Full_cell_handle neighbor(const int i) const;}{Returns the
cell opposite to the \ccc{i}-th vertex of the cell \ccVar. \ccPrecond
full cell opposite to the \ccc{i}-th vertex of the full cell \ccVar. \ccPrecond
$0\leq i\leq$\ccc{ambient_dimension()}.}
\ccMethod{int mirror_index(const int i) const;}{Returns the index \ccc{j} of
the cell \ccc{s} as a neighbor in the cell \ccVar\ccc{.neighbor(i);}. If the
the full cell \ccVar as a neighbor in the full cell \ccVar\ccc{.neighbor(i);}. If the
returned integer is not negative, it holds that \ccVar.%
\ccc{neighbor(i)->neighbor(j) == }\ccVar. Returns
\ccc{-1} if \ccc{s} has no neighboring cell of index \ccc{i}.
\ccc{-1} if \ccVar has no neighboring full cell of index \ccc{i}.
\ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}
\ccMethod{int index(Full_cell_handle n) const;}{Returns the index \ccc{i}
of the neighbor \ccc{n} such that \ccVar\ccc{.neighbor(i)==n}. \ccPrecond \ccc{n}
must be a neighbor of \ccc{s}.}
must be a neighbor of \ccVar.}
\ccGlue
\ccMethod{int index(Vertex_handle v) const;}{Returns the index \ccc{i} of
the vertex \ccc{v} such that \ccVar\ccc{.vertex(i)==v}. \ccPrecond \ccc{v} must be
a vertex of the \ccc{s}.}
a vertex of the \ccVar.}
\ccMethod{const TDS_data & get_tds_data() const;}{Returns the data member of
type \ccc{TDS_data}. It is typically used to mark the cell as \emph{visited}
type \ccc{TDS_data}. It is typically used to mark the full cell as \emph{visited}
during operations on a \ccc{TriangulationDataStructure}.}
\ccMethod{TDS_data & get_tds_data();}{Same as above, but returns a reference to
@ -102,7 +102,7 @@ a non-\ccc{const} object.}
\begin{ccAdvanced}
\ccMethod{Vertex_handle mirror_vertex(const int i, const int cur_dim) const;}
{Returns a handle to the mirror vertex of the \ccc{i}-th vertex of cell
{Returns a handle to the mirror vertex of the \ccc{i}-th vertex of full cell
\ccVar. This function works even if the neighboring information stored in the
neighbor full cell \ccc{*}\ccVar\ccc{.neighbor(i)} is corrupted. This is useful
when temporary corruption is necessary during surgical operation on a
@ -114,49 +114,49 @@ i,$\ccc{cur_dim}$\leq$\ccc{ambient_dimension()}.}
\ccHeading{Update functions} % - - - - - - - - - - - - - - - - - UPDATES
\ccMethod{void set_vertex(const int i, Vertex_handle v);}{Sets the $i$-th
vertex of the cell.
vertex of the full cell.
\ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}
\ccMethod{void set_neighbor(const int i, Full_cell_handle n);} {Sets the
\ccc{i}-th neighboring cell of \ccVar\ to \ccc{n}. Full cell \ccc{n} is
\ccc{i}-th neighboring full cell of \ccVar\ to \ccc{n}. Full cell \ccc{n} is
opposite to the $i$-th vertex of \ccVar.
\ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}
\ccMethod{void set_mirror_index(const int i, const int index);} {Sets the
mirror index of the $i$-th vertex of \ccVar\ to \ccc{index}. This corresponds
to the index, in \ccVar\ccc{->neighbor(i)}, of the cell \ccVar.\\
to the index, in \ccVar\ccc{->neighbor(i)}, of the full cell \ccVar.\\
Note: an implementation of the concept \ccVar\ may choose not to store mirror
indices, in which case this function should do nothing.
\ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}
\ccMethod{void swap_vertices(int d1, int d2);}{Switches the orientation of the
cell \ccVar\ by swapping its vertices with index \ccc{d1} and \ccc{d2}.
full cell \ccVar\ by swapping its vertices with index \ccc{d1} and \ccc{d2}.
\ccPrecond $0\leq d1,d2\leq$\ccc{ambient_dimension()}.}
\ccHeading{Queries}
\ccMethod{bool has_vertex(Vertex_handle v) const;}{Returns \ccc{true}
if the vertex \ccc{v} is a vertex of the cell \ccVar. Returns \ccc{false}
if the vertex \ccc{v} is a vertex of the full cell \ccVar. Returns \ccc{false}
otherwise.}
\ccMethod{bool has_vertex(Vertex_handle v, int & ret) const;}%
{Returns \ccc{true} and sets the value of \ccc{ret} to the index of \ccc{v} in
\ccVar\ if the vertex \ccc{v} is a vertex of the cell \ccVar. Returns
\ccVar\ if the vertex \ccc{v} is a vertex of the full cell \ccVar. Returns
\ccc{false} otherwise.}
\ccMethod{bool has_neighbor(Full_cell_handle n) const;}{Returns \ccc{true}
if the cell \ccc{n} is a neighbor of the cell \ccVar. Returns
if the full cell \ccc{n} is a neighbor of the full cell \ccVar. Returns
\ccc{false} otherwise.}
\ccMethod{bool has_neighbor(Full_cell_handle n, int & ret) const;}%
{Returns \ccc{true} and sets the value of \ccc{ret} to the index of \ccc{n} as
a neighbor of \ccVar\ if the cell \ccc{n} is a neighbor of the cell
a neighbor of \ccVar\ if the full cell \ccc{n} is a neighbor of the full cell
\ccVar. Returns \ccc{false} otherwise.}
\ccHeading{Validity check}
\ccMethod{bool is_valid(bool verbose=false, int level=0) const;}{Performs any
desired test on a cell. \emph{E.g.}, checks that for each existing vertex,
desired test on a full cell. \emph{E.g.}, checks that for each existing vertex,
there is an existing neighbor.}
% \ccHeading{Memory management}
@ -165,21 +165,21 @@ there is an existing neighbor.}
% \ccGlue\ccMethod{void* & for_compact_container();}{}
% These member functions are required by the classes
% \ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>} and
% \ccc{Triangulation<TrTraits, TDS>} (and its derived classes) because they use
% \ccc{Compact_container} to store their vertices and simplices. See the
% \ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>} and
% \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} (and its derived classes) because they use
% \ccc{Compact_container} to store their vertices and full cells. See the
% documentation of \ccc{Compact_container} for the exact requirements.
\ccHeading{Input/Output}
\ccFunction{template<class TDS> istream& operator>>(istream & is,
Triangulation_ds_full_cell<TDS> & c);}
{Reads (possible) non-combinatorial information about a cell from the stream \ccc{is}
\ccFunction{template<class TriangulationDataStructure> istream& operator>>(istream & is,
Triangulation_ds_full_cell<TriangulationDataStructure> & c);}
{Reads (possible) non-combinatorial information about a full cell from the stream \ccc{is}
into \ccc{c}.}
\ccFunction{template<class TDS> ostream& operator<<(ostream & os, const
Triangulation_ds_full_cell<TDS> & c);}
{Writes (possible) non-combinatorial information about cell \ccc{c} to the stream
\ccFunction{template<class TriangulationDataStructure> ostream& operator<<(ostream & os, const
Triangulation_ds_full_cell<TriangulationDataStructure> & c);}
{Writes (possible) non-combinatorial information about full cell \ccc{c} to the stream
\ccc{os}.}
\ccSeeAlso

30
Triangulation/doc_tex/Triangulation_ref/TriangulationDSVertex.tex
View File

@ -12,13 +12,13 @@ concept.
\ccHasModels
\ccc{Triangulation_ds_vertex<TDS>}\\
\ccc{Triangulation_vertex<TrTraits, Data, TDSVertex>}
\ccc{Triangulation_ds_vertex<TriangulationDataStructure>}\\
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccTypes
\ccNestedType{Full_cell_handle}{A handle to a cell. It must be the same as the
nested type \ccc{TDS::Full_cell_handle} of the \ccc{TDS} in which the
nested type \ccc{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the
\ccc{TriangulationDSVertex} is defined/used.}
\ccNestedType{template<typename TDS2> Rebind_TDS}{This nested template
@ -29,16 +29,16 @@ class template, that is: \ccc{Other == TriangulationDSVertex<TDS2>}.}
\ccCreationVariable{v}
\ccConstructor{TriangulationDSVertex();}{The default constructor (no incident
cell is set).}
full cell is set).}
\ccGlue
\ccConstructor{TriangulationDSVertex(Full_cell_handle s);}{Sets the incident
cell to \ccc{s}. \ccPrecond \ccc{s} must not be the default-constructed
\ccConstructor{TriangulationDSVertex(Full_cell_handle c);}{Sets the incident
full cell to \ccc{c}. \ccPrecond \ccc{c} must not be the default-constructed
\ccc{Full_cell_handle}.}
\ccOperations
\ccMethod{void set_full_cell(Full_cell_handle c);}{Set \ccc{c} as the vertex's
incident cell. \ccPrecond \ccc{c} must not be the default-constructed
incident full cell. \ccPrecond \ccc{c} must not be the default-constructed
\ccc{Full_cell_handle}.}
\ccMethod{Full_cell_handle full_cell() const;}{Returns a handle to a
@ -48,7 +48,7 @@ incident cell. \ccPrecond \ccc{c} must not be the default-constructed
\ccMethod{bool is_valid(bool verbose=false, int level=0) const;}{Performs any
desired test on a vertex. Al least, checks that the pointer to an incident
cell is not the default constructed handle ({i.e.}, is not
full cell is not the default constructed handle ({i.e.}, is not
\ccc{NULL}). The parameter \ccc{level} is not used, but can be used in derived
classes.}
@ -58,21 +58,21 @@ classes.}
% \ccGlue\ccMethod{void* & for_compact_container();}{}
% These member functions are required by the classes
% \ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>} and
% \ccc{Triangulation<TrTraits, TDS>} (and its derived classes) because they use
% \ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>} and
% \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} (and its derived classes) because they use
% the \cgal\ container class \ccc{Compact_container} to store their vertices and
% simplices. See the documentation of \ccc{Compact_container} for the exact
% full cells. See the documentation of \ccc{Compact_container} for the exact
% requirements.
\ccHeading{Input/Output}
\ccFunction{template<class TDS> istream& operator>>(istream & is,
Triangulation_ds_vertex<TDS> & v);}
\ccFunction{template<class TriangulationDataStructure> istream& operator>>(istream & is,
Triangulation_ds_vertex<TriangulationDataStructure> & v);}
{Reads (possible) non-combinatorial information about a vertex from the stream \ccc{is}
into \ccc{v}.}
\ccFunction{template<class TDS> ostream& operator<<(ostream & os, const
Triangulation_ds_vertex<TDS> & v);}
\ccFunction{template<class TriangulationDataStructure> ostream& operator<<(ostream & os, const
Triangulation_ds_vertex<TriangulationDataStructure> & v);}
{Writes (possible) non-combinatorial information about vertex \ccc{v} to the stream
\ccc{os}.}

168
Triangulation/doc_tex/Triangulation_ref/TriangulationDataStructure.tex
View File

@ -19,14 +19,14 @@ Values of $d$ (the \emph{current dimension} of the complex) include \begin{itemi
\item[-2] This corresponds to the non-existence of any object in
$\sphere^D.$
\item[-1] This corresponds to a single vertex and a single simplex. In a
\item[-1] This corresponds to a single vertex and a single full cell. In a
geometric realization of the \ccRefName\ (\emph{e.g.}, in a
\ccc{Triangulation<TrTraits, TDS>} or a
\ccc{Delaunay_triangulation<DTTraits, TDS>}), this vertex
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} or a
\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}), this vertex
corresponds to \emph{the vertex at infinity}.
\item[0] This corresponds to two vertices, each incident to one $0$-face;
the two cells being neighbor of each other. This is the unique
the two full cells being neighbor of each other. This is the unique
triangulation of the $0$-sphere.
\item[$d>0$] This corresponds to a standard triangulation of the sphere
@ -34,25 +34,23 @@ $\sphere^d$.
\end{itemize}
An $i$-simplex is a simplex with $i+1$ vertices. An $i$-simplex $\sigma$ is
\textbf{incident} to a $j$-simplex $\sigma'$, $j<i$, if and only if $\sigma'$
{incident} to a $j$-simplex $\sigma'$, $j<i$, if and only if $\sigma'$
is a proper face of $\sigma$.
%Two simplices are \textbf{adjacent} if the
%intersection of their vertex-set is not empty.
\ccHasModels
\ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>}
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
\ccTypes
\ccNestedType{Vertex}
{
A model of the concept \ccc{TriangulationDSVertex}.
Vertex type.
}
\ccGlue
\ccNestedType{Full_cell}
{
A model of the concept \ccc{TriangulationDSFullCell}.
Full cell type.
}
The concept \ccRefName\ also defines a type for describing facets of the
@ -67,28 +65,25 @@ full cell \ccc{c} opposite to its \ccc{i}-th vertex}
\ccNestedType{Face}
{A model of the concept \ccc{TriangulationFace}.}
Vertices and simplices are manipulated via \emph{handles}. Handles support the
Vertices and full cells are manipulated via \emph{handles}. Handles support the
usual two dereference operators \ccc{operator*} and \ccc{operator->}.
\ccNestedType{Vertex_handle}
{
Handle to a \ccc{Vertex}.
}
%\ccGlue
%\ccNestedType{Vertex_const_handle}
%{
%Handle to a \ccc{const Vertex}.
%}
\ccGlue
\ccNestedType{Full_cell_handle}
{
Handle to a \ccc{Full_cell}.
}
%\ccGlue
%\ccNestedType{Full_cell_const_handle}
%{
%Handle to a \ccc{const Full_cell}.
%}
Requirements for \ccc{Vertex} and \ccc{Full_cell} are described in concepts
\ccc{TriangulationDataStructure::Vertex} and
\ccc{TriangulationDataStructure::FullCell} \lcTex{(
\ccRefPage{TriangulationDataStructure::Vertex} and
\ccRefPage{TriangulationDataStructure::FullCell})}.
\begin{ccAdvanced}
\ccNestedType{template <typename Vb2> struct Rebind_vertex}
@ -105,7 +100,7 @@ one whose \ccc{TriangulationDSFullCellBase} will be \ccc{Fcb2}.}
\end{ccAdvanced}
Vertices, facets and cells can be iterated over using \emph{iterators}.
Vertices, facets and full cells can be iterated over using \emph{iterators}.
Iterators support the usual two dereference operators \ccc{operator*} and
\ccc{operator->}.
@ -113,21 +108,11 @@ Iterators support the usual two dereference operators \ccc{operator*} and
{
Iterator over the list of vertices.
}
%\ccGlue
%\ccNestedType{Vertex_const_iterator}
%{
%Iterator over the list of vertices (\ccc{const} casted).
%}
\ccGlue
\ccNestedType{Full_cell_iterator}
{
Iterator over the list of cells.
Iterator over the list of full cells.
}
%\ccGlue
%\ccNestedType{Simplex_const_iterator}
%{
%Iterator over the list of simplices (\ccc{const} casted).
%}
\ccGlue
\ccNestedType{Facet_iterator}
{
@ -142,7 +127,7 @@ Iterator over the facets of the complex.
\ccCreationVariable{tds}
\ccConstructor{XXXXXXXXXX(const int dim);} {Creates an instance \ccVar\ of
type \ccRefName. The maximal dimension of its cells is \ccc{dim} and
type \ccRefName. The maximal dimension of its full cells is \ccc{dim} and
\ccVar\ is initialized to the empty triangulation. Thus,
\ccVar.\ccc{current_dimension()} equals \ccc{-2}.}
@ -151,7 +136,7 @@ type \ccRefName. The maximal dimension of its cells is \ccc{dim} and
\ccHeading{Queries} % --------------------------------------------- QUERIES
\ccMethod{int ambient_dimension() const;} { Returns the maximal dimension of
the cells that can be stored in the triangulation \ccVar. \ccPostcond the
the full dimensional cells that can be stored in the triangulation \ccVar. \ccPostcond the
returned value is positive. }
\ccMethod{int current_dimension() const;} { Returns the dimension of the
@ -160,14 +145,14 @@ full dimensional cells stored in the triangulation. It holds that
\ccc{true}. \ccPostcond the returned value \ccc{d} satisfies
$-2\leq d \leq$\ccVar.\ccc{ambient_dimension()}. }
\ccMethod{bool empty() const;} { Returns \ccc{true} if the regular complex
contains no simplex. Returns \ccc{false} otherwise. }
\ccMethod{bool empty() const;} { Returns \ccc{true} if thetriangulation
contains nothing. Returns \ccc{false} otherwise. }
\ccMethod{size_type number_of_vertices() const;}
{Returns the number of vertices in the triangulation.}
\ccMethod{size_type number_of_full_cells() const;}
{Returns the number of cells in the triangulation.}
{Returns the number of full cells in the triangulation.}
\ccMethod{bool is_vertex(const Vertex_handle & v) const;}
{}
@ -179,23 +164,23 @@ contains no simplex. Returns \ccc{false} otherwise. }
void full_cells(Full_cell_handle c, TraversalPredicate & tp,
OutputIterator & out) const;}
{This function computes (\emph{gathers}) a connected set of full cells
satifying a common criteria. Call them \emph{good} cells. It is assumed
that the argument \ccc{c} is a good cell. The cells are then
recursively explored by examining if, from a given good cell, its neighboring
cells are also good.\\
satifying a common criteria. Call them \emph{good} full cells. It is assumed
that the argument \ccc{c} is a good full cell. The full cells are then
recursively explored by examining if, from a given good full cell, its neighboring
full cells are also good.\\
The argument \ccc{tp} is a predicate that takes as argument a \ccc{Facet}
whose containing \ccc{Full_cell} is good. The predicate must return \ccc{true}
if the traversal of that \ccc{Facet} leads to a good cell.\\
All the good cells are outputted into the last argument \ccc{out}.}
if the traversal of that \ccc{Facet} leads to a good full cell.\\
All the good full cells are outputted into the last argument \ccc{out}.}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_full_cells(Vertex_handle v, OutputIterator out) const;}
{Insert in \ccc{out} all the cells that are incident to the vertex
{Insert in \ccc{out} all the full cells that are incident to the vertex
\ccc{v}, {i.e.}, the full cells that have the \ccc{Vertex v} as a vertex.
Returns the (modified) output iterator.}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_full_cells(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the cells that are incident to the face \ccc{f},
{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f},
{i.e.}, the full cells that have the \ccc{Face f} as a subface.
Returns the (probably modified) output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
@ -219,11 +204,11 @@ f}. Returns the (probably modified) output iterator.
\ccMethod{template< typename OutputIterator > OutputIterator
incident_upper_faces(Vertex_handle v, const int d, OutputIterator
out);}{Constructs all the \textbf{upper} \ccc{Face}s of dimension \ccc{d}
out);}{Constructs all the \em{upper} \ccc{Face}s of dimension \ccc{d}
incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\
Assuming some total ordering on the vertices of the complex (which is
invariant as long as no vertex is inserted in or removed from the complex), a
\ccc{Face} incident to \ccc{v} is an \emph{upper} \ccc{Face} if and only if
\ccc{Face} incident to \ccc{v} is an \em{upper} \ccc{Face} if and only if
its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In
particular, taking the disjoint union of the upper \ccc{Face}s of dimension
\ccc{d} incident to every vertex of the complex yields exactly the set of
@ -249,9 +234,8 @@ $d\geq$\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension()}.}
\ccMethod{int mirror_index(Full_cell_handle c, int i) const;}%{}
%\ccGlue\ccMethod{int mirror_index(Full_cell_const_handle s, int i) const;}
{Returns the index of the vertex mirror of the \ccc{i}-th vertex of \ccc{c}.
Equivalently, returns the index of \ccc{s} in its \ccc{i}-th neighbor.
Equivalently, returns the index of \ccc{c} in its \ccc{i}-th neighbor.
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension}()\\
and $s$ is not the default constructed \ccc{Full_cell_handle}. }
@ -263,10 +247,6 @@ and $s$ is not the default constructed \ccc{Full_cell_handle}. }
{
The first vertex of \ccVar.
}
%\ccGlue
%\ccMethod{Vertex_const_iterator vertices_end() const;}
%{
%}
\ccGlue
\ccMethod{Vertex_iterator vertices_end();}
{
@ -276,32 +256,21 @@ The beyond vertex of \ccVar.
\ccHeading{Accessing the full cells} % ------------------- ACCESS TO CELLS
\ccMethod{Full_cell_handle full_cell(Vertex_handle v) const;}%{}
%\ccGlue
%\ccMethod{Full_cell_const_handle simplex(Vertex_const_handle v) const;}
{Returns a full cell incident to \ccc{Vertex} \ccc{v}. Note that this simplex is
not unique (\ccc{v} is typically incident to more than one simplex).
{Returns a full cell incident to \ccc{Vertex} \ccc{v}. Note that this
full cell is
not unique (\ccc{v} is typically incident to more than one full cell).
\ccPrecond\ccc{v} is not the default constructed \ccc{Vertex_handle}}
\ccMethod{Full_cell_handle neighbor(Full_cell_handle c, int i) const;}%{}
%\ccGlue
%\ccMethod{Full_cell_const_handle neighbor(Full_cell_const_handle s, int i) const;}
{ Returns a \ccc{Full_cell_handle} pointing to the \ccc{Full_cell}
opposite to the \ccc{i}-th vertex of \ccc{s}.
opposite to the \ccc{i}-th vertex of \ccc{c}.
\ccPrecond$0\leq i \leq$\ccVar.\ccc{current_dimension()}\\
and \ccc{c} is not the default constructed \ccc{Full_cell_handle}}
%\ccMethod{Simplex_const_iterator full_cells_begin() const;}
%{
%}
%\ccGlue
\ccMethod{Full_cell_iterator full_cells_begin();}
{
The first full cell of \ccVar.
}
%\ccGlue
%\ccMethod{Simplex_const_iterator full_cells_end() const;}
%{
%}
\ccGlue
\ccMethod{Full_cell_iterator full_cells_end();}
{
@ -320,8 +289,8 @@ The beyond full cell of \ccVar.
{Returns a full cell containing the facet \ccc{f}}
\ccMethod{int index_of_covertex(const Facet & f) const;}
{Returns the index of vertex of the cell \ccc{c=}\ccVar.\ccc{full_cell(f)}
which does \textbf{not} belong to \ccc{c}.}
{Returns the index of vertex of the full cell \ccc{c=}\ccVar.\ccc{full_cell(f)}
which does {not} belong to \ccc{c}.}
\ccMethod{Face make_empty_face() const;}{Returns an empty \ccc{Face}
ready to be setup with any $k$-face of the (combinatorial) triangulation with
@ -344,10 +313,11 @@ $k<$\ccVar.\ccc{current_dimension()}. See \ccc{TriangulationFace}.}
\ccHeading{Vertex insertion} % - - - - - - - - - - - - - - - - - - INSERTIONS
\ccMethod{Vertex_handle insert_in_full_cell(Full_cell_handle c);}{Inserts a new
vertex \ccc{v} in the cell \ccc{c} and returns a handle to it. The cell
\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} cells which
vertex \ccc{v} in the full cell \ccc{c} and returns a handle to
it. The full cell
\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} full cells which
share the vertex \ccc{v}.
\ccPrecond Current dimension is positive and \ccc{c} is a simplex of \ccVar.}
\ccPrecond Current dimension is positive and \ccc{c} is a full cell of \ccVar.}
\begin{ccTexOnly}
\begin{center}
\includegraphics{Triangulation_ref/fig/insert-in-cell.pdf}
@ -355,7 +325,7 @@ share the vertex \ccc{v}.
\end{ccTexOnly}
\begin{ccHtmlOnly}
<center>
<img border=0 src="./fig/insert-in-cell.png" align="middle" alt="The effect of insert_in_simplex()">
<img border=0 src="./fig/insert-in-cell.png" align="middle" alt="The effect of insert_in_full_cell()">
</center>
\end{ccHtmlOnly}
@ -379,18 +349,18 @@ share the vertex \ccc{v}.
\ccMethod{template< class ForwardIterator > Vertex_handle
insert_in_hole(ForwardIterator start, ForwardIterator end, Facet f);}{The
simplices in the range $C=$\ccc{[start, end)} are removed, thus forming a hole.
full cells in the range $C=$\ccc{[start, end)} are removed, thus forming a hole.
A \ccc{Vertex} is inserted and connected to the boundary of the hole in order
to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is returned.
\ccPrecond $C$ must be a (combinatorial) ball and not contain any vertex
all of whose incident simplices are in $C$. (This implies that
all of whose incident full cells are in $C$. (This implies that
\ccVar.\ccc{current_dimension()}$\geq2$ if $|C|>1$.)\\ The boundary of
$C$ must be a (combinatorial) triangulation of the sphere
$\sphere^{d-1}$. $f$ must be on the boundary of $C$.}
\ccGlue
\ccMethod{template< class ForwardIterator, class OutputIterator >
Vertex_handle insert_in_hole(ForwardIterator start, ForwardIterator end, Facet
f, OutputIterator out);}{Same as above, but handles to the new simplices are
f, OutputIterator out);}{Same as above, but handles to the new full cells are
appended to the \ccc{out} output iterator.}
\ccMethod{Vertex_handle insert_increase_dimension(Vertex_handle star);}
@ -401,11 +371,11 @@ triangulation of the sphere $\sphere^{d+1}$ by adding a new vertex
$\sphere^{d+1}$ ($v$ is added as $d+2^{th}$ vertex to all
full cells)
and \ccc{star} is used to triangulate the other half-sphere
(all cells that do not already has star as vertex are duplicated,
and \ccc{star} replaces \ccc{v} in these cells).
(all full cells that do not already has star as vertex are duplicated,
and \ccc{star} replaces \ccc{v} in these full cells).
The indexing of the vertices in the
full cell is such that, if \ccc{f} was a cell of maximal dimension in the
initial complex, then \ccc{(f,v)}, in this order, is the corresponding cell
full cell is such that, if \ccc{f} was a full cell of maximal dimension in the
initial complex, then \ccc{(f,v)}, in this order, is the corresponding full cell
in the updated triangulation. A handle to \ccc{v} is returned.
\ccPrecond\ccVar.
If the current dimension is -2 (empty triangulation), then \ccc{star}
@ -418,17 +388,17 @@ and \ccc{star} must be a vertex of \ccVar.}
The following methods may destroy the integrity %(the ``purity'', one may say)
of the data structure. They are used internally. Use at your own risks.
\ccMethod{Full_cell_handle new_full_cell();} {Adds a new cell to \ccVar\ and
returns a handle to it. The new cell has no vertex and no neighbor yet.}
\ccMethod{Full_cell_handle new_full_cell();} {Adds a new full cell to \ccVar\ and
returns a handle to it. The new full cell has no vertex and no neighbor yet.}
\ccMethod{Vertex_handle new_vertex();}
{Adds a new vertex to \ccVar\ and returns a handle to it. The new vertex has
no associated cell nor index yet.}
no associated full cell nor index yet.}
\ccMethod{void associate_vertex_with_full_cell(Full_cell_handle c, int i,
Vertex_handle v);}
{Sets the \ccc{i}-th vertex of \ccc{c} to \ccc{v} and, if \ccc{v} is non-NULL,
sets \ccc{c} as the incident cell of \ccc{v}.}
sets \ccc{c} as the incident full cell of \ccc{v}.}
\ccMethod{void set_neighbors(Full_cell_handle ci, int i, Full_cell_handle cj, int
j);}
@ -466,13 +436,13 @@ dimension is not -2.}
erasing the references to \ccc{v} in other parts of the triangulation.}
\ccMethod{void delete_full_cell(Full_cell_handle c);}
{Remove the cell \ccc{c} from the triangulation. This does not take care of
{Remove the full cell \ccc{c} from the triangulation. This does not take care of
erasing the references to \ccc{c} in other parts of the triangulation.}
\ccMethod{template< typename ForwardIterator > void
delete_full_cells(ForwardIterator start, ForwardIterator end);}
{Remove the cells in the range \ccc{[start,end)} from the triangulation.
This does not take care of erasing the references to these cells in other parts of
{Remove the full cells in the range \ccc{[start,end)} from the triangulation.
This does not take care of erasing the references to these full cells in other parts of
the triangulation.}
\end{ccAdvanced}
@ -481,17 +451,17 @@ the triangulation.}
\ccMethod{bool is_valid(bool verbose = true, int level = 0) const;}
{Partially checks whether \ccVar\ is a triangulation. This function
returns \ccc{true} if each vertex is a vertex of the cell of which it
claims to be a vertex, if the vertices of every cell are pairwise distinct,
if the neighbor relationship is symmetric, and if neighboring cells share
returns \ccc{true} if each vertex is a vertex of the full cell of which it
claims to be a vertex, if the vertices of every full cell are pairwise distinct,
if the neighbor relationship is symmetric, and if neighboring full cells share
exactly \ccVar.\ccc{current_dimension()} vertices and the induced
orientation of these two cells are compatible.
orientation of these two full cells are compatible.
It prints an error message
if one of these conditions is violated and the \ccc{verbose} parameter is
\ccc{true}. Passing these tests does not garanty that we have a
triangulation (abstract pure
complex). In particular, for example, it is not
checked whether cells that share \ccVar.\ccc{current_dimension()} vertices
checked whether full cells that share \ccVar.\ccc{current_dimension()} vertices
are neighbors in the data structure.}
\ccHeading{Input/Output} % ---------------------------- I/O
@ -508,10 +478,10 @@ equal to \ccVar.\ccc{ambient_dimension()}.}
The information stored in the \ccc{iostream} is: the current dimension (which
must be \ccc{<=} \ccVar.\ccc{ambient_dimension()}), the number of vertices,
the number of cells, the indices of the vertices of each cell and then the
indices of the neighbors of each cell, where the index corresponds to the
preceding list of cells.
If the TDS vertices and full cells contains some extra information
the number of full cells, the indices of the vertices of each full cell and then the
indices of the neighbors of each full cell, where the index corresponds to the
preceding list of full cells.
If the \ccc{TriangulationDataStructure} vertices and full cells contains some extra information
(i.e. geometric information) the classes \ccc{Vertex} and
\ccc{Full_cell} has to provide the relevant I/O operators.
@ -519,6 +489,6 @@ If the TDS vertices and full cells contains some extra information
\ccSeeAlso
\ccc{TriangulationDSVertex}\\
\ccc{TriangulationDSSimplex}
\ccc{TriangulationDSFullCell}
\end{ccRefConcept}

18
Triangulation/doc_tex/Triangulation_ref/TriangulationFace.tex
View File

@ -5,38 +5,38 @@
A \ccRefName\ simply describes a \ccc{k}-face \ccc{f} in a triangulation.
It gives access to a handle to a full cell \ccc{c} containing the face
\ccc{f} in its boundary, as well as the indices of the vertices of \ccc{f} in
\ccc{c}. It must hold that \ccc{f} is a \textbf{proper} face of cell
\ccc{c}. It must hold that \ccc{f} is a \em{proper} face of full cell
\ccc{c}, {i.e.}, the dimension of \ccc{f} is strictly less than
the dimension of \ccc{c}.
\ccTypes
\ccNestedType{Full_cell_handle}{Must be the same as the nested type
\ccc{TDS::Full_cell_handle} of the \ccc{TDS} in which the \ccc{TriangulationFace} is
\ccc{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationFace} is
defined/used.}
\ccNestedType{Vertex_handle}{Must be the same as the nested type
\ccc{TDS::Vertex_handle} of the \ccc{TDS} in which the \ccc{TriangulationFace} is
\ccc{TriangulationDataStructure::Vertex_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationFace} is
defined/used.}
\ccHasModels
\ccc{Triangulation_face<TDS>}.
\ccc{Triangulation_face<TriangulationDataStructure>}.
\ccCreation
\ccCreationVariable{f}
There is no default constructor, since the ambient dimension (the maximal
dimension of the simplices) must be known by the constructors of a \ccRefName.
dimension of the full cells) must be known by the constructors of a \ccRefName.
\ccConstructor{Triangulation_face(Triangulation_face g);}{Copy constructor.}
\ccConstructor{Triangulation_face(Full_cell_handle c);}{Sets the \ccc{Face}'s
cell to \ccc{c}. \ccPrecond \ccc{s} must be a handle to an existing
cell (not the default-constructed \ccc{Full_cell_handle()}).}
full cell to \ccc{c}. \ccPrecond \ccc{c} must be a handle to an existing
full cell (not the default-constructed \ccc{Full_cell_handle()}).}
\ccConstructor{Triangulation_face(const int ad);}{Setup the \ccc{Face} knowing
the ambient dimension \ccc{ad}. Sets the \ccc{Face}'s cell to the
the ambient dimension \ccc{ad}. Sets the \ccc{Face}'s full cell to the
default-constructed one.}
\ccHeading{Access functions}
@ -70,6 +70,6 @@ vertex of the face.
\ccSeeAlso
\ccc{TriangulationDataStructure}, \\
\ccc{Triangulation_face<TDS>}.
\ccc{Triangulation_face<TriangulationDataStructure>}.
\end{ccRefConcept}

26
Triangulation/doc_tex/Triangulation_ref/TriangulationFullCell.tex
View File

@ -3,8 +3,8 @@
\ccDefinition
The concept \ccRefName\ describes the requirements on the type used by the
class \ccc{Triangulation<TrTraits, TDS>}, and its derived classes, to
represent a cell.
class \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}, and its derived classes, to
represent a full cell.
\ccRefines
@ -13,41 +13,41 @@ represent a cell.
We only list below the additional specific requirements of \ccRefName.
Compared to \ccc{TriangulationDSFullCell}, the main difference is the addition of
methods to access and iterate over the position of the cell's vertices as
well as a method for constructing the center of the cell's circumsphere.
methods to access and iterate over the position of the full cell's vertices as
well as a method for constructing the center of the full cell's circumsphere.
\ccHasModels
\ccc{Triangulation_full_cell<TrTraits, TDSFullCell>}
\ccc{Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}
\ccTypes
\ccNestedType{Point}%
{The type of the point stored in the cell's vertices. It must be the same
{The type of the point stored in the full cell's vertices. It must be the same
as the point type \ccc{TriangulationTraits::Point} (or its refined concepts)
defined by the geometric traits of the \ccc{Triangulation<TrTraits, TDS>}
defined by the geometric traits of the \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
class.}
\ccNestedType{Point_const_iterator}{An iterator over the points of the
cell.}
full cell.}
\ccCreationVariable{c}
\ccOperations
\ccMethod{Point_const_iterator points_begin() const;}
{Returns an iterator pointing to the first point of the cell.}
{Returns an iterator pointing to the first point of the full cell.}
\ccGlue
\ccMethod{Point_const_iterator points_end() const;}
{Returns an iterator pointing beyond the last point of the cell.}
{Returns an iterator pointing beyond the last point of the full cell.}
\ccMethod{Point circumcenter() const;}{Returns the center of the sphere
circumscribing the cell.}
circumscribing the full cell.}
\ccSeeAlso
\ccc{Triangulation_full_cell<TrTraits, TDSFullCell>}\\
\ccc{Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}\\
\ccc{TriangulationVertex}\\
\ccc{Triangulation<TrTraits, TDS>}
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
\end{ccRefConcept}

10
Triangulation/doc_tex/Triangulation_ref/TriangulationTraits.tex
View File

@ -3,14 +3,14 @@
\ccDefinition
The concept \ccRefName\ describes the various types and functions that a class
must provide as the first parameter (\ccc{TrTraits}) to the class template
\ccc{Triangulation<TrTraits, TDS>}. It brings the geometric ingredient to the
must provide as the first parameter (\ccc{TriangulationTraits}) to the class template
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}. It brings the geometric ingredient to the
definition of a triangulation, while the combinatorial ingredient is brought by
the second template parameter, \ccc{TDS}.
the second template parameter, \ccc{TriangulationDataStructure}.
Inserting a range of points in a triangulation is optimized using
spatial sorting, thus besides the requirements below,
a class provided as \ccc{TrTraits} should also satisfies the concept
a class provided as \ccc{TriangulationTraits} should also satisfies the concept
\ccc{SpatialSortingTraits_d}.
\ccRefines
@ -47,7 +47,7 @@ the templated operator\\\ccc{template<typename ForwardIterator> bool
operator()(ForwardIterator start, ForwardIterator end, const Point_d &
p)}.\\The operator returns \ccc{true} if and only if point \ccc{p} is
contained in the affine space spanned by the points in the range \ccc{[start,
end)}. That affine space is also called the \textbf{affine hull} of the points
end)}. That affine space is also called the \em{affine hull} of the points
in the range.
\ccPrecond The $k$ points in the range
must be affinely independent.

18
Triangulation/doc_tex/Triangulation_ref/TriangulationVertex.tex
View File

@ -3,7 +3,7 @@
\ccDefinition
The concept \ccRefName\ describes the requirements on the type used by the
class \ccc{Triangulation<TrTraits, TDS>}, and its derived classes, to
class \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}, and its derived classes, to
represent a vertex.
\ccRefines
@ -17,23 +17,23 @@ an embedding of the vertex into a geometric point.
\ccHasModels
\ccc{Triangulation_vertex<TrTraits, Data, TDSVertex>}
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccTypes
\ccNestedType{Point}{The type of the point stored in the vertex. It must be
the same as the point type \ccc{TrTraits::Point} (or its refined
the same as the point type \ccc{TriangulationTraits::Point} (or its refined
concepts) when the \ccc{TriangulationVertex} is used in the class
\ccc{Triangulation<TrTraits, TDS>} (or its derived classes).}
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} (or its derived classes).}
\ccCreation
\ccCreationVariable{v}
\ccConstructor{TriangulationVertex(Full_cell_handle s, const Point & p);}%
{Constructs a vertex with incident cell \ccc{s}. The vertex is embedded at point \ccc{p}.}
\ccConstructor{TriangulationVertex(Full_cell_handle c, const Point & p);}%
{Constructs a vertex with incident full cell \ccc{c}. The vertex is embedded at point \ccc{p}.}
\ccGlue\ccConstructor{TriangulationVertex(const Point & p);}%
{Same as above, but without incident cell.}%{ (Who would have guessed?)}
{Same as above, but without incident full cell.}%{ (Who would have guessed?)}
\ccGlue\ccConstructor{TriangulationVertex();}%
{Same as above, but with a default-constructed \ccc{Point}.}
@ -58,8 +58,8 @@ the point and other possible information.}
\ccSeeAlso
\ccc{Triangulation_vertex<TrTraits, Data, TDSVertex>}\\
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}\\
\ccc{TriangulationFullCell}\\
\ccc{Triangulation<TrTraits, TDS>}
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
\end{ccRefConcept}

23
Triangulation/doc_tex/Triangulation_ref/Triangulation_data_structure.tex
View File

@ -1,4 +1,4 @@
\begin{ccRefClass}{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>}
\begin{ccRefClass}{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
\ccDefinition
This class is used for storing the combinatorial information of a triangulation
@ -19,19 +19,19 @@ triggers some optimizations. Or
dimension of the simplices (full cells) is passed as an integer argument to an instance
constructor (see \ccc{TriangulationDataStructure}).\end{itemize}
\ccc{TDSVertex} is the class to be used as the base \ccc{Vertex} type in the
\ccc{TriangulationDSVertex} is the class to be used as the base \ccc{Vertex} type in the
triangulation data structure. It must be a model of the concept
\ccc{TriangulationDSVertex}. The class template \ccRefName\ accepts that no
second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as
second parameter. In both cases, \ccc{TDSVertex} defaults to
second parameter. In both cases, \ccc{TriangulationDSVertex} defaults to
\ccc{CGAL::Triangulation_ds_vertex<>}.
\ccc{TDSFullCell} is the class to be used as the base \ccc{Full_cell} type in
\ccc{TriangulationDSFullCell} is the class to be used as the base \ccc{Full_cell} type in
the triangulation data structure. It must be a model of the concept
\ccc{TriangulationDSFullCell}. The class template \ccRefName\ accepts that no
third parameter be specified. It also accepts the tag \ccc{CGAL::Default} as
third parameter. In both cases, \ccc{TDSFullCell} defaults to
third parameter. In both cases, \ccc{TriangulationDSFullCell} defaults to
\ccc{CGAL::Triangulation_ds_full_cell<>}.
\ccIsModel
@ -53,17 +53,18 @@ In addition, the class \ccRefName\ provides the following types and methods:
\ccNestedType{Full_cell_data}
{A data member of type \ccc{Full_cell_data} is stored in every full cell (models
of the concept \ccc{TriangulationDSFullCell}). It is used to mark some full
cells, during modifications of the triangulation data structure.}
of the concept \ccc{TriangulationDSFullCell}). It is used to mark
some
full cells, during modifications of the triangulation data structure.}
\ccHeading{Vertex insertion} % - - - - - - - - - - - - - - - - - - INSERTIONS
\ccMethod{template< OutputIterator > Full_cell_handle insert_in_tagged_hole(
Vertex_handle v, Facet f, OutputIterator new_simplices);}
{A set \ccc{C} of simplices satisfying the same condition as in method
Vertex_handle v, Facet f, OutputIterator new_full_cells);}
{A set \ccc{C} of full cells satisfying the same condition as in method
\ccRefName\ccc{::insert_in_hole()} is assumed to be marked. This
method creates new simplices from \ccc{Vertex} v to the boundary of \ccc{C}.
The boundary is recognized by checking the mark of the simplices.
method creates new full cells from \ccc{Vertex} v to the boundary of \ccc{C}.
The boundary is recognized by checking the mark of the full cells.
This method is used by \ccRefName\ccc{::insert_in_hole()}.}
\end{ccAdvanced}

14
Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_full_cell.tex
View File

@ -1,10 +1,10 @@
\begin{ccRefClass}{Triangulation_ds_full_cell<TDS, TDSFullCellStoragePolicy>}
\begin{ccRefClass}{Triangulation_ds_full_cell<TriangulationDataStructure, TDSFullCellStoragePolicy>}
\ccDefinition
The class \ccRefName\ serves as the default full cell template parameter in the
class \ccc{Triangulation_data_structure<Dimensionality, TDSVertex,
TDSFullCell>}.
class \ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex,
TriangulationDSFullCell>}.
This class does not provide any geometric capabilities but only combinatorial
(adjacency) information. Thus, if the \ccc{Triangulation_data_structure} is
@ -19,7 +19,7 @@ with some additional attributes tuned for a specific application.
\ccParameters
The first template parameter, \ccc{TDS}, must be a model of the
The first template parameter, \ccc{TriangulationDataStructure}, must be a model of the
\ccc{TriangulationDataStructure} concept. It defaults to \ccc{void}, which is
used to break some dependency cycles.
@ -36,11 +36,11 @@ equivalent to setting \ccc{TDSFullCellStoragePolicy} to
When the second parameter is specified, its possible ``values''
are:\begin{itemize}
\item \ccc{CGAL::Default}, which is the \textbf{default} value. In that case, the
\item \ccc{CGAL::Default}, which is the \em{default} value. In that case, the
policy \ccc{CGAL::TDS_full_cell_default_storage_policy} is used.
\item \ccc{CGAL::TDS_full_cell_default_storage_policy}. In that case, the mirror
indices are \textbf{not stored}.
indices are {not stored}.
\item \ccc{CGAL::TDS_full_cell_mirror_storage_policy}. In that case, the mirror
indices are stored.
@ -53,6 +53,6 @@ See the user manual \note{TODO} for how to choose the second option.
\ccSeeAlso
\ccc{Triangulation_ds_vertex<TDS>}
\ccc{Triangulation_ds_vertex<TriangulationDataStructure>}
\end{ccRefClass}

10
Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_vertex.tex
View File

@ -1,10 +1,10 @@
\begin{ccRefClass}{Triangulation_ds_vertex<TDS>}
\begin{ccRefClass}{Triangulation_ds_vertex<TriangulationDataStructure>}
\ccDefinition
The class \ccRefName\ serves as the default vertex template parameter in the
class \ccc{Triangulation_data_structure<Dimensionality, TDSVertex,
TDSFullCell>}.
class \ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex,
TriangulationDSFullCell>}.
This class does not contain any geometric information but only combinatorial
(adjacency) information. Thus, if the \ccc{Triangulation_data_structure} is
@ -20,7 +20,7 @@ example).
\ccParameters
The template parameter \ccc{TDS} must be a model of the
The template parameter \ccc{TriangulationDataStructure} must be a model of the
\ccc{TriangulationDataStructure} concept. It defaults to \ccc{void}, which is
used to break some dependency cycles.
@ -30,6 +30,6 @@ used to break some dependency cycles.
\ccSeeAlso
\ccc{Triangulation_ds_full_cell<TDS, TDSFullCellStoragePolicy>}
\ccc{Triangulation_ds_full_cell<TriangulationDataStructure, TDSFullCellStoragePolicy>}
\end{ccRefClass}

4
Triangulation/doc_tex/Triangulation_ref/Triangulation_face.tex
View File

@ -1,4 +1,4 @@
\begin{ccRefClass}{Triangulation_face<TDS>}
\begin{ccRefClass}{Triangulation_face<TriangulationDataStructure>}
\ccDefinition
@ -6,7 +6,7 @@ A \ccRefName\ is a model of the concept \ccc{TriangulationFace}.
\ccParameters
\ccc{TDS} must be a \textbf{very loose} model of the concept
Parameter \ccc{TriangulationDataStructure} must be a \em{very loose} model of the concept
\ccc{TriangulationDataStructure} in that it must only provide the
types\begin{itemize}
\item \ccc{Full_cell_handle},

21
Triangulation/doc_tex/Triangulation_ref/Triangulation_full_cell.tex
View File

@ -1,10 +1,10 @@
\begin{ccRefClass}{Triangulation_full_cell<TrTraits, Data, TDSFullCell>}
\begin{ccRefClass}{Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
\ccDefinition
The class \ccRefName\ is a model of the concept \ccc{TriangulationFullCell}. It
is used by default for representing full cells in the class
\ccc{Triangulation<TrTraits, TDS>}.
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}.
A \ccRefName\ stores handles to the vertices of the cell as well as handles
to its neighboring cells.
@ -13,22 +13,23 @@ to its neighboring cells.
\ccParameters
\ccc{TrTraits} must be a model of the concept \ccc{TriangulationTraits}. It
\ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. It
provides geometric types and predicates for use in the
\ccc{Triangulation<TrTraits, TDS>} class.
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} class.
\ccc{Data} is an optional type of data to be stored in the vertex class. The
class template \ccRefName\ accepts that no second parameter be specified. In
this case, \ccc{Data} defaults to \ccc{CGAL::No_full_cell_data}.
\ccc{TDSFullCell} must be a model of the concept \ccc{TriangulationDSFullCell}.
Parameter \ccc{TriangulationDSFullCell} must be a model of the concept
\ccc{TriangulationDSFullCell}.
The class template \ccRefName\ accepts that no third parameter be specified.
It also accepts the tag \ccc{CGAL::Default} as third parameter. In both
cases, \ccc{TDSFullCell} defaults to \ccc{CGAL::Triangulation_ds_full_cell<>}.
cases, \ccc{TriangulationDSFullCell} defaults to \ccc{CGAL::Triangulation_ds_full_cell<>}.
\ccInheritsFrom
\ccc{TDSFullCell} (the third template parameter)
\ccc{TriangulationDSFullCell} (the third template parameter)
\ccIsModel
@ -61,15 +62,15 @@ The parameter \ccc{t} is passed to the \ccc{Data} constructor.}
\ccFunction{istream & operator>>(istream & is, Triangulation_full_cell & v);}%
{Inputs the non-combinatorial information given by the cell, {i.e.},
the point and other possible information. The data of type \ccc{Data} is
\textbf{also} read.}
{also} read.}
\ccFunction{ostream & operator<<(ostream & os, const Triangulation_full_cell & v);}%
{Outputs the non-combinatorial information given by the cell, {i.e.},
the point and other possible information. The data of type \ccc{Data} is
\textbf{also} written.}
{also} written.}
\ccSeeAlso
\ccc{Triangulation_vertex<TrTraits, Data, TDSVertex>}
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\end{ccRefClass}

2
Triangulation/doc_tex/Triangulation_ref/Triangulation_locate_type.tex
View File

@ -4,7 +4,7 @@
\ccDefinition
The enum \ccRefName\ is defined by the class \ccc{Triangulation} to specify
in what kind of simplex a point has been located in a triangulation.
in what kind of face a point has been located in a triangulation.
\ccEnum{enum Locate_type {ON_VERTEX, IN_FACE, IN_FACET, IN_FULL_CELL,
OUTSIDE_CONVEX_HULL, OUTSIDE_AFFINE_HULL};}

25
Triangulation/doc_tex/Triangulation_ref/Triangulation_vertex.tex
View File

@ -1,10 +1,10 @@
\begin{ccRefClass}{Triangulation_vertex<TrTraits, Data, TDSVertex>}
\begin{ccRefClass}{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccDefinition
The class \ccRefName\ is a model of the concept \ccc{TriangulationVertex}. It is
used by default for representing vertices in the class
\ccc{Triangulation<TrTraits, TDS>}.
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}.
A \ccRefName\ stores a point and an incident full cell.
@ -12,23 +12,24 @@ A \ccRefName\ stores a point and an incident full cell.
\ccParameters
\ccc{TrTraits} must be a model of the concept \ccc{TriangulationTraits}. It
\ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. It
provides geometric types and predicates for use in the
\ccc{Triangulation<TrTraits, TDS>} class. It is of interest here for its
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} class. It is of interest here for its
declaration of the \ccc{Point} type.
\ccc{Data} is an optional type of data to be stored in the vertex class. The
class template \ccRefName\ accepts that no second parameter be specified. In
this case, \ccc{Data} defaults to \ccc{CGAL::No_vertex_data}.
\ccc{TDSVertex} must be a model of the concept \ccc{TriangulationDSVertex}. The
Parameter
\ccc{TriangulationDSVertex} must be a model of the concept \ccc{TriangulationDSVertex}. The
class template \ccRefName\ accepts that no third parameter be specified. It
also accepts the tag \ccc{CGAL::Default} as third parameter. In both cases,
\ccc{TDSVertex} defaults to \ccc{CGAL::Triangulation_ds_vertex<>}.
\ccc{TriangulationDSVertex} defaults to \ccc{CGAL::Triangulation_ds_vertex<>}.
\ccInheritsFrom
\ccc{TDSVertex} (the third template parameter)
\ccc{TriangulationDSVertex} (the third template parameter)
\ccIsModel
@ -49,12 +50,12 @@ type.}
\ccConstructor{template< typename T>
Triangulation_vertex(Full_cell_handle c,
const Point & p, const T & t);}{Constructs a vertex with incident cell
const Point & p, const T & t);}{Constructs a vertex with incident full cell
\ccc{c}. The vertex is embedded at point \ccc{p} and the parameter \ccc{t} is
passed to the \ccc{Data} constructor.}
\ccGlue\ccConstructor{template< typename T> Triangulation_vertex(const Point
& p, const T & t);}{Same as above, but without incident cell.}
& p, const T & t);}{Same as above, but without incident full cell.}
\ccGlue\ccConstructor{Triangulation_vertex();}%
{Same as above, but with default-constructed \ccc{Point} and \ccc{Data}.}
@ -69,15 +70,15 @@ passed to the \ccc{Data} constructor.}
\ccFunction{istream & operator>>(istream & is, Triangulation_vertex & v);}%
{Inputs the non-combinatorial information given by the vertex, {i.e.},
the point and other possible information. The data of type \ccc{Data} is
\textbf{also} read.}
{also} read.}
\ccFunction{ostream & operator<<(ostream & os, const Triangulation_vertex & v);}%
{Outputs the non-combinatorial information given by the vertex, {i.e.},
the point and other possible information. The data of type \ccc{Data} is
\textbf{also} written.}
{also} written.}
\ccSeeAlso
\ccc{Triangulation_full_cell<TrTraits, Data, TDSFullCell>}
\ccc{Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
\end{ccRefClass}

46
Triangulation/doc_tex/Triangulation_ref/intro.tex
View File

@ -13,27 +13,28 @@ The basic triangulation class of \cgal\ is primarily designed to
represent the triangulations of a set of points $A$ in $\R^d$.
It can be
viewed as a partition of the convex hull of $A$ into simplices whose
vertices are the points of $A$. Together with the unbounded cells having
vertices are the points of $A$. Together with the unbounded full cells having
the convex hull boundary as its frontier, the triangulation forms a
partition of $\R^d$.
In order to deal only with full dimensional simplices (full cells),
which is convenient for many
applications, the space outside the convex hull is subdivided into simplices by
applications, the space outside the convex hull is subdivided into
full cells by
considering that each convex hull facet is incident to an infinite
cell having as vertex an auxiliary vertex called the infinite
vertex. In that way, each facet is incident to exactly two cells and
full cell having as vertex an auxiliary vertex called the infinite
vertex. In that way, each facet is incident to exactly two full cells and
special cases at the boundary of the convex hull are simple to deal
with.
A triangulation is a collection of vertices and cells that are linked
together through incidence and adjacency relations. Each cell gives
A triangulation is a collection of vertices and full cells that are linked
together through incidence and adjacency relations. Each full cell gives
access to its its incident vertices and to its its adjacent
cells. Each vertex gives access to one of its incident cells.
full cells. Each vertex gives access to one of its incident full cells.
The vertices of a cell are indexed in positive
The vertices of a full cell are indexed in positive
orientation, the positive orientation being defined by the orientation
of the underlying Euclidean space $\R^d$. The neighbors of a cell are also
of the underlying Euclidean space $\R^d$. The neighbors of a full cell are also
indexed in such a way that the neighbor indexed by $i$
is opposite to the vertex with the same index.
@ -47,7 +48,7 @@ is opposite to the vertex with the same index.
\ccRefConceptPage{TriangulationDataStructure}
The above concept is also abbreviated as \ccc{TDS}. It defines three types,
The above concept is also abbreviated as \ccc{TriangulationDataStructure}. It defines three types,
\ccc{Vertex}, \ccc{Full_cell} and \ccc{Face}, that must respectively fulfill the
following concepts:
@ -55,9 +56,6 @@ following concepts:
\ccRefConceptPage{TriangulationDSFullCell}\\
\ccRefConceptPage{TriangulationFace}
The above first two concepts are also abbreviated respectively as
\ccc{TDSVertex} and \ccc{TDSFullCell}.
\subsubsection*{(Geometric) triangulations}
\ccRefConceptPage{TriangulationTraits}\\
@ -67,8 +65,8 @@ The above first two concepts are also abbreviated respectively as
\ccRefConceptPage{TriangulationVertex}\\
\ccRefConceptPage{TriangulationFullCell}
The above concepts are also abbreviated respectively as \ccc{TrTraits},
\ccc{DTTraits},
The above concepts are also abbreviated respectively as \ccc{TriangulationTraits},
\ccc{DelaunayTriangulationTraits},
%\ccc{RTTraits},
\ccc{TrVertex} and \ccc{TrFullCell}.
@ -76,20 +74,20 @@ The above concepts are also abbreviated respectively as \ccc{TrTraits},
\subsubsection*{Triangulation data structure}
\ccRefIdfierPage{CGAL::Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>}\\
\ccRefIdfierPage{CGAL::Triangulation_ds_vertex<TDS>}\\
\ccRefIdfierPage{CGAL::Triangulation_ds_full_cell<TDS, TDSFullCellStoragePolicy>}
\ccRefIdfierPage{CGAL::Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}\\
\ccRefIdfierPage{CGAL::Triangulation_ds_vertex<TriangulationDataStructure>}\\
\ccRefIdfierPage{CGAL::Triangulation_ds_full_cell<TriangulationDataStructure, TDSFullCellStoragePolicy>}
\ccRefIdfierPage{CGAL::Triangulation_face<TDS>}
\ccRefIdfierPage{CGAL::Triangulation_face<TriangulationDataStructure>}
\subsubsection*{(Geometric) triangulations}
\ccRefIdfierPage{CGAL::Triangulation<TrTraits, TDS>}\\
\ccRefIdfierPage{CGAL::Delaunay_triangulation<DTTraits, TDS>}
%\ccRefIdfierPage{CGAL::Regular_triangulation<RCTraits, TDS>}
\ccRefIdfierPage{CGAL::Triangulation<TriangulationTraits, TriangulationDataStructure>}\\
\ccRefIdfierPage{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
%\ccRefIdfierPage{CGAL::Regular_triangulation<RCTraits, TriangulationDataStructure>}
\ccRefIdfierPage{CGAL::Triangulation_vertex<TrTraits, Data, TDSVertex>}\\
\ccRefIdfierPage{CGAL::Triangulation_full_cell<TrTraits, Data, TDSFullCell>}
\ccRefIdfierPage{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}\\
\ccRefIdfierPage{CGAL::Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
\subsection{Enums}

2
Triangulation/doc_tex/Triangulation_ref/main.tex
View File

@ -6,6 +6,8 @@
% Concepts
\input{Triangulation_ref/TriangulationDataStructure.tex}
\input{Triangulation_ref/Tds_vertex.tex}
\input{Triangulation_ref/Tds_full_cell.tex}
\input{Triangulation_ref/TriangulationDSVertex.tex}
\input{Triangulation_ref/TriangulationDSFullCell.tex}