mirror of https://github.com/CGAL/cgal
Erased doc_tex/
This commit is contained in:
Clement Jamin
parent
754dd21c31
commit
07160a1996
|
|
@ -1,13 +0,0 @@
|
|||
\begin{ccPkgDescription}{Triangulations\label{Pkg:Triangulations}}
|
||||
|
||||
\ccPkgSummary{The package \ccc{Triangulation} provides classes for manipulating
|
||||
triangulations (pure simplicial complexes) in Euclidean spaces whose
|
||||
dimension can be specified at compile-time or at run-time. Specifically, it
|
||||
provides a combinatorial Triangulation data structure, which is extended into
|
||||
geometric triangulation and Delaunay triangulation classes. Point location and point
|
||||
insertion are supported. The Delaunay triangulation also supports point removal.}
|
||||
|
||||
\ccPkgIntroducedInCGAL{3.6}
|
||||
\ccPkgLicense{\ccLicenseLGPL}
|
||||
\ccPkgIllustration{Triangulation/fig/detail.png}{Triangulation/fig/illustration.png}
|
||||
\end{ccPkgDescription}
|
||||
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 43 KiB |
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 27 KiB |
|
|
@ -1,6 +0,0 @@
|
|||
\ccUserChapter{Triangulations\label{chap:triangulations}}
|
||||
\ccChapterAuthor{Samuel Hornus \and Olivier Devillers}
|
||||
|
||||
\input{Triangulation/PkgDescription}
|
||||
\minitoc
|
||||
\input{Triangulation/triangulation}
|
||||
|
|
@ -1,584 +0,0 @@
|
|||
|
||||
\newcommand{\note}[1]{\begin{ccTexOnly}%
|
||||
{\color{red}$\langle\!\langle$#1$\rangle\!\rangle$}\end{ccTexOnly}}
|
||||
\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{Delaunay_triangulation} 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}}
|
||||
|
||||
\subsubsection{Some definitions}
|
||||
|
||||
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
|
||||
{\em faces} or {\em simplices} (the
|
||||
singular of which is {\em simplex}).
|
||||
%
|
||||
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 {\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
|
||||
{\em finite simplicial complexes} which have slightly different simplices
|
||||
and additional requirements:
|
||||
\begin{itemize}
|
||||
\item vertices corresponds to points in space.
|
||||
\item a simplex $s\in S$ is the convex hull of its vertices.
|
||||
\item the vertices of a simplex $s\in S$ are affinely independent.
|
||||
\item the intersection of any two simplices of $S$ is a proper face of both
|
||||
simplices (the empty set counts).
|
||||
\end{itemize}
|
||||
See the \ccAnchor{http://en.wikipedia.org/wiki/Simplicial_complex}{wikipedia
|
||||
entry} for more about simplicial complexes.
|
||||
|
||||
\subsubsection{What's in this package?}
|
||||
|
||||
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,
|
||||
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<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<DelaunayTriangulationTraits, TriangulationDataStructure>} adds further
|
||||
constraints to a triangulation, in that all its simplices must have the
|
||||
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, TriangulationDataStructure>} is a generalization of
|
||||
%the Delaunay triangulation.
|
||||
|
||||
%The rest of this user manual gives more details about these classes and the
|
||||
%data they store, but does not tell the whole story. For the latter, the user
|
||||
%should have a look at the reference manual of this package.
|
||||
|
||||
%A last remark:
|
||||
%pure complexes are also called \emph{triangulations}. We feel more confortable
|
||||
%in using the word \emph{complexes} as it forces us to think ``in dimension
|
||||
%higher than 3''.
|
||||
|
||||
\subsubsection{Further definitions}
|
||||
|
||||
An $i$-face denotes an $i$-dimensional simplex, or a simplex with $i+1$
|
||||
vertices. When these vertices are embedded in Euclidean space, they must be
|
||||
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 {\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 {\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{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, TriangulationDSVertex,
|
||||
TriangulationDSFullCell>}.% For simplicity, we use the abbreviation \tds.
|
||||
|
||||
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 {\em maximal dimension} which is a
|
||||
positive integer equal to the maximum dimension a full cell can have.
|
||||
This maximal dimension can be chosen by the user at the creation of a \tds\
|
||||
and can then be queried using the method \ccc{tds.maximal_dimension()}.
|
||||
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 maximal dimension with \ad\ and the current dimension with \cd.
|
||||
The inequalities $-2\leq\cd\leq\ad$ and $0<\ad$ always hold.
|
||||
The special meaning of negative values for $d$ is explained below.
|
||||
|
||||
%\note{I remove some comments about 3D vs dD which are not exact. %
|
||||
%in T3D package in degenerate dimension \ccc{Cell} is actually used with the %
|
||||
%same meaning as here (a $d$-face and not a $D$-face).}
|
||||
%% \paragraph{On the \ccc{Facet} nested type}
|
||||
%% In the \ccc{Triangulation_3} \cgal\ package, the maximal dimension is always
|
||||
%% 3. With respect to this reference dimension (3), a \ccc{Facet} is always a
|
||||
%% 2-face (triangle),
|
||||
%% irrespective of the 3D triangulation's current dimension. In
|
||||
%% particular, full cells in degenerate planar 3D triangulation are
|
||||
%% \ccc{Facet}s, not \ccc{Cell}s.
|
||||
%
|
||||
%% 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
|
||||
%% \ccc{Facet} represents a face of dimension \ccc{current_dimension()-1}
|
||||
%% {\em and not} \ccc{maximal_dimension()-1}.
|
||||
|
||||
\subsubsection{The data structure triangulates $\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 {\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 full cell has
|
||||
always exactly $\cd+1$ neighbors.
|
||||
Two full cells $\sigma$ and $\sigma'$ sharing a facet are called
|
||||
{\em neighbors}.
|
||||
|
||||
\newcommand{\cgalTriangulationCurrentDimension}{%
|
||||
\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 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 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$.}
|
||||
|
||||
Possible values of $\cd$ (the \emph{current dimension} of the triangulation) include
|
||||
%\begin{ccTexOnly}
|
||||
% \begin{list}{}{\leftmargin=20mm\labelsep=3mm\labelwidth=17mm}
|
||||
% \cgalTriangulationCurrentDimension
|
||||
% \end{list}
|
||||
%\end{ccTexOnly}
|
||||
%\begin{ccHtmlOnly}
|
||||
\begin{quotation}
|
||||
\noindent\begin{itemize}
|
||||
\cgalTriangulationCurrentDimension
|
||||
\end{itemize}
|
||||
\end{quotation}
|
||||
%\end{ccHtmlOnly}
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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, TriangulationDSVertex,
|
||||
TriangulationDSFullCell>}
|
||||
implementing the concept \ccc{TriangulationDataStructure}.
|
||||
|
||||
|
||||
\subsubsection{Storage}
|
||||
|
||||
A \tds\ explicitly stores its vertices and full cells.
|
||||
|
||||
Each vertex stores a reference (a \ccc{handle}) to one of its incident
|
||||
full cells.
|
||||
|
||||
|
||||
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$ {\em opposite} to
|
||||
the $i$-th vertex of $\sigma$ (Figure~\ref{triangulation:fig:full-cell}).
|
||||
|
||||
\begin{figure}[htbp]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation/fig/simplex-structure.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<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 full cell $c$ in
|
||||
dimension $\cd=2$.}
|
||||
\label{triangulation:fig:full-cell}
|
||||
\end{figure}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
The index of a full cell $c$ in the $i$-th neighbor of $c$ is called the
|
||||
\emph{$i$-th mirror-index} of $c$ (Figure~\ref{triangulation:fig:full-cell}).
|
||||
Mirror indices are often needed for maintaining the triangulation data
|
||||
structure. Thus, it might be desirable, for performance reasons, to store the
|
||||
mirror indices alongside the references to the vertices and neighbors in a full
|
||||
cell. This improves speed a little, but requires more memory.
|
||||
|
||||
\cgal\ provides the class template
|
||||
\ccc{Triangulation_ds_full_cell<TriangulationDataStructure,
|
||||
TDSFullCellStoragePolicy>} for representing full cells in a triangulation. Its
|
||||
second template parameter is used to specify wether or not the mirror indices
|
||||
should be kept in memory or computed on-the-fly, which is the default case.
|
||||
Please refer to the documentation of that class template for specific details.
|
||||
\end{ccAdvanced}
|
||||
|
||||
\subsubsection{Instantiating the class template}
|
||||
|
||||
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 maximal dimension of the triangulation data structure by specifying the \ccc{Dimensionality} template parameter,
|
||||
\item the type used to represent vertices by specifying the \ccc{TriangulationDSVertex}
|
||||
template parameter and
|
||||
\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
|
||||
the user needs custom types (see the reference manual page for this class
|
||||
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 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 full cells must be passed as an integer argument to an instance
|
||||
constructor (see \ccc{TriangulationDataStructure}).
|
||||
\end{itemize}
|
||||
|
||||
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<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.
|
||||
|
||||
{\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
|
||||
\ccc{TriangulationDSFullCell} must provide a nested template \ccc{Rebind_TDS}
|
||||
which is documented in those two concept's reference manual pages.
|
||||
|
||||
\begin{ccAdvanced}
|
||||
The user that is in need of a custom vertex or full cell class, is
|
||||
encouraged to read the documentation of the \cgal\
|
||||
\ccc{Triangulation_2} or \ccc{Triangulation_3} package.
|
||||
\end{ccAdvanced}
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - TDS EXAMPLES
|
||||
|
||||
\subsection{Examples\label{triangulation:tds:examples}}
|
||||
|
||||
\subsubsection{Incremental Construction}
|
||||
The following examples shows how to construct a triangulation data structure by
|
||||
inserting vertices. Its main interest is that it demonstrates most of the API
|
||||
to insert new vertices into the triangulation. Therefore, the reader will make
|
||||
the best use of this example by reading it slowly, together with the reference
|
||||
manual documentation of the methods that are called (see here:
|
||||
\ccc{TriangulationDataStructure}) and by trying to understand the various
|
||||
\ccc{assert(...)} statements.
|
||||
|
||||
\ccIncludeExampleCode{Triangulation/triangulation_data_structure_static.cpp}
|
||||
|
||||
In previous example, the maximal dimension is fixed at compile time.
|
||||
It is also possible to fix it at run time, as in the next example.
|
||||
|
||||
\ccIncludeExampleCode{Triangulation/triangulation_data_structure_dynamic.cpp}
|
||||
|
||||
\subsubsection{Barycentric subdivision}
|
||||
This example provides a function for computing the barycentric subdivision of a
|
||||
single full cell \ccc{c} in a triangulation data structure. The other
|
||||
full cells adjacent to \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 combination enumerator,
|
||||
which is not documented, but provided in \cgal.
|
||||
|
||||
|
||||
\begin{figure}[htbp]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation/fig/barycentric-subdivision.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<img border=0 src="./fig/barycentric-subdivision.png" align="middle"
|
||||
alt="Barycentric subdivision">
|
||||
</center>
|
||||
\end{ccHtmlOnly}
|
||||
\caption{Barycentric subdivision in dimension $\cd=2$.}
|
||||
\label{triangulation:fig:barycentric}
|
||||
\end{figure}
|
||||
|
||||
\ccIncludeExampleCode{Triangulation/barycentric_subdivision.cpp}
|
||||
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - TRIANGULATIONS
|
||||
|
||||
\section{Triangulations}
|
||||
|
||||
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
|
||||
triangulation, as well as a triangulation of the complement of the convex hull
|
||||
{\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 full cells outside the convex hull are each incident to
|
||||
a finite facet on the convex hull of the triangulation and to a unique
|
||||
{\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 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 full cell's finite facet.
|
||||
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - Triangulation IMPLEMENTATION
|
||||
|
||||
\subsection{Implementation}
|
||||
|
||||
The class \ccc{CGAL::Triangulation<TriangulationTraits,
|
||||
TriangulationDataStructure>} stores a model
|
||||
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{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.
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - Triangulation EXAMPLES
|
||||
|
||||
\subsection{Examples}
|
||||
|
||||
\subsubsection{Incremental Construction}
|
||||
|
||||
The following example shows how to construct a triangulation in which we insert
|
||||
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$ 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
|
||||
%in general, this set of vertices is a superset of the set of extremal vertices
|
||||
%of the convex hull.)
|
||||
%%%% I assume the previous rk relates to degeneracies. Matter of definitions.
|
||||
%%%% removed after review 1 reviewer 1
|
||||
|
||||
\ccIncludeExampleCode{Triangulation/triangulation.cpp}
|
||||
|
||||
\subsubsection{Traversing the facets of the convex hull}
|
||||
|
||||
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 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 full cells of the triangulation and check if they
|
||||
are infinite or not:
|
||||
|
||||
\begin{ccExampleCode}
|
||||
{ int i=0;
|
||||
typedef Triangulation::Full_cell_iterator Full_cell_iterator;
|
||||
typedef Triangulation::Facet Facet;
|
||||
|
||||
for( Full_cell_iterator cit = t.full_cells_begin();
|
||||
cit != t.full_cells_end(); ++cit )
|
||||
{
|
||||
if( ! t.is_infinite(cit) )
|
||||
continue;
|
||||
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;
|
||||
}
|
||||
\end{ccExampleCode}%
|
||||
\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 full cells
|
||||
incident to the infinite vertex: they form precisely the set of infinite
|
||||
full cells:
|
||||
|
||||
\begin{ccExampleCode}
|
||||
{ int i=0;
|
||||
typedef Triangulation::Full_cell_handle Full_cell_handle;
|
||||
typedef Triangulation::Facet Facet;
|
||||
typedef std::vector<Full_cell_handle> Full_cells;
|
||||
|
||||
Full_cells infinite_full_cells;
|
||||
std::back_insert_iterator<Full_cells> out(infinite_full_cells);
|
||||
|
||||
t.incident_full_cells(t.infinite_vertex(), out);
|
||||
|
||||
for( Full_cells::iterator sit = infinite_full_cells.begin();
|
||||
sit != infinite_full_cells.end(); ++sit )
|
||||
{
|
||||
Facet ft(*sit, (*sit)->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;
|
||||
}
|
||||
\end{ccExampleCode}
|
||||
\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.
|
||||
|
||||
One important difference between the two examples above is that the first uses
|
||||
\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<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
|
||||
{\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 {\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 {\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:
|
||||
|
||||
%Informally, a finite full cell has the Delaunay (or empty-ball) property---with
|
||||
%respect to the triangulation---if no vertex of the triangulation lies in the
|
||||
%interior of its circumscribing sphere.
|
||||
|
||||
When a new point \ccc{p} is inserted into a Delaunay triangulation, the
|
||||
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 ``star shaped'' around \ccc{p} and thus is easily re-triangulated using
|
||||
\ccc{p} as a center vertex.
|
||||
|
||||
Delaunay triangulations also support vertex removal.
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - DELAUNAY IMPLEMENTATION
|
||||
|
||||
\subsection{Implementation}
|
||||
|
||||
The class \ccc{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} derives from
|
||||
\ccc{CGAL::Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}. It thus stores a model of
|
||||
the concept \ccc{TriangulationDataStructure} which is instantiated with a vertex
|
||||
type that stores a geometric point and allows its retrieval.% and a full cell type that allows the
|
||||
%retrieval of the points of its vertices.
|
||||
|
||||
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
|
||||
\ccc{TriangulationTraits} by requiring a few other geometric predicates, necessary
|
||||
for the computation of Delaunay triangulations.
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - DELAUNAY EXAMPLES
|
||||
|
||||
\subsection{Examples}
|
||||
|
||||
\subsubsection{Access to the conflict zone and created full cells during point
|
||||
insertion}
|
||||
|
||||
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 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}
|
||||
|
||||
|
||||
\section{Complexity and Performances}
|
||||
|
||||
The current implementation locate points by walking in the
|
||||
triangulation, and sort the points with spatial sort to insert a
|
||||
set of points. Thus the theoretical complexity are
|
||||
$O(n\log n)$ for inserting $n$ random points and $O(n^{\frac{1}{\cd}})$
|
||||
for inserting one point in a triangulation of $n$ random points.
|
||||
|
||||
The actual timing are the following:
|
||||
|
||||
% insert here the table produce by script in directory benchmark
|
||||
% (code to be done) !
|
||||
|
||||
\note{todo}
|
||||
|
||||
This section will be completed, when the code will be fully ready (and
|
||||
preferably with the new Kernel).
|
||||
|
||||
|
||||
\section{Design and Implementation History}
|
||||
|
||||
This package is heavily inspired by the works of
|
||||
Monique Teillaud and Sylvain Pion (\ccc{Triangulation_3})
|
||||
and Mariette Yvinec (\ccc{Triangulation_2}).
|
||||
The first version was written by Samuel Hornus and then
|
||||
pursued by Samuel Hornus and Olivier Devillers.
|
||||
|
|
@ -1,116 +0,0 @@
|
|||
|
||||
\begin{ccRefConcept}{DelaunayTriangulationTraits}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
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<DelaunayTriangulationTraits, TriangulationDataStructure>}. It brings the geometric ingredients to
|
||||
the definition of a Delaunay complex, while the combinatorial
|
||||
ingredients are
|
||||
brought by the second template parameter, \ccc{TriangulationDataStructure}.
|
||||
|
||||
\ccRefines
|
||||
|
||||
\ccc{TriangulationTraits}.
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccTwo{DelaunayTriangulationTraits ::}{}
|
||||
|
||||
%\ccNestedType{Point_d}{This nested type is defined in the ``parent'' concept
|
||||
%\ccc{TriangulationTraits}.}
|
||||
|
||||
\ccNestedType{Side_of_oriented_sphere_d}{A predicate object that must provide
|
||||
the templated operator\\\ccc{template<typename ForwardIterator> Oriented_side
|
||||
operator()(ForwardIterator start, ForwardIterator end, const Point_d &
|
||||
p)}.\\The operator returns \ccc{ON_POSITIVE_SIDE},
|
||||
\ccc{ON_NEGATIVE_SIDE}
|
||||
or \ccc{ON_ORIENTED_BOUNDARY} depending of the side of the query
|
||||
point \ccc{p}
|
||||
with respect to the sphere circumscribing the simplex
|
||||
defined by the points in range \ccc{[start,end)}.
|
||||
If the simplex is positively
|
||||
oriented, then the positive side of sphere corresponds geometrically
|
||||
to its bounded side.
|
||||
%\\ The range's size must of course be one more
|
||||
%than the dimension of the Euclidean space the points live in:
|
||||
\ccPrecond
|
||||
\ccc{std::distance(start,end)=D+1}, where
|
||||
\ccc{Point_dimension_d(*it)} is $D$ for all \ccc{it} in
|
||||
\ccc{[start,end)}. \ccc{Point_dimension_d(p)} is also $D$.
|
||||
The points in range
|
||||
\ccc{[start,end)} must be affinely independent, i.e., the simplex must
|
||||
not be flat.}
|
||||
|
||||
\ccNestedType{In_flat_side_of_oriented_sphere_d}{A predicate object that must
|
||||
provide the templated operator\\
|
||||
\ccc{template<typename ForwardIterator>
|
||||
Oriented_side operator()(Flat_orientation_d orient, ForwardIterator start, ForwardIterator end, const
|
||||
Point_d & p)}.\\
|
||||
The operator returns \ccc{ON_POSITIVE_SIDE},
|
||||
\ccc{ON_NEGATIVE_SIDE}
|
||||
or \ccc{ON_ORIENTED_BOUNDARY} depending of the side of the query
|
||||
point \ccc{p}
|
||||
with respect to the sphere circumscribing the simplex
|
||||
defined by the points in range \ccc{[start,end)}.
|
||||
If the simplex is positively
|
||||
oriented according to \ccc{orient},
|
||||
then the positive side of sphere corresponds geometrically
|
||||
to its bounded side.
|
||||
The points in range \ccc{[start,end)} and \ccc{p} are supposed to belong to the lower dimensional flat
|
||||
whose orientation is given by \ccc{orient}.
|
||||
\ccPrecond
|
||||
\ccc{std::distance(start,end)=k+1} where $k$ is the number of
|
||||
points used to construct \ccc{orient}.
|
||||
\ccc{Point_dimension_d(*it)} is $D$ for all \ccc{it} in
|
||||
\ccc{[start,end)}. \ccc{Point_dimension_d(p)} is also $D$.
|
||||
The points in range
|
||||
\ccc{[start,end)} must be affinely independent, {i.e.,} the simplex must
|
||||
not be flat.
|
||||
}
|
||||
|
||||
|
||||
|
||||
%%%%%%%% currently unused
|
||||
% \ccNestedType{Center_of_sphere_d}{A construction object that must
|
||||
% provide the templated operator\\\ccc{template<typename ForwardIterator> bool
|
||||
% operator()(ForwardIterator start, ForwardIterator end)}.\\The operator
|
||||
% constructs the center of the sphere circumscribing the points in
|
||||
% the range \ccc{R=[start, end)}. \ccPrecond The number of points in the range
|
||||
% must be equal to one more than the dimension of the Euclidean space the points
|
||||
% live in, {i.e.}, \ccc{std::distance(start,end)} is equal to \ccc{start->dimension()+1}.}
|
||||
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{traits}
|
||||
|
||||
\ccConstructor{DelaunayTriangulationTraits();}{The default constructor.}
|
||||
|
||||
\ccOperations
|
||||
\ccThree{In_flat_side_of_oriented_sphere_d}{in_flat_side_of_oriented_sphere_d_object()
|
||||
const;}{}
|
||||
|
||||
|
||||
The following methods permit access to the traits class's predicates:
|
||||
|
||||
\ccMethod{Side_of_oriented_sphere_d side_of_oriented_sphere_d_object() const;}
|
||||
{}
|
||||
\ccGlue
|
||||
\ccMethod{In_flat_side_of_oriented_sphere_d in_flat_side_of_oriented_sphere_d_object()
|
||||
const;}
|
||||
{}
|
||||
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Cartesian_d<FT, Dim, LA>},\\
|
||||
\ccc{CGAL::Simple_cartesian_d<FT, Dim, LA>},\\
|
||||
\ccc{CGAL::New_kernel_d} (recommended when available)
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationTraits}\\
|
||||
\ccc{DelaunayTriangulation}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,165 +0,0 @@
|
|||
\begin{ccRefClass}{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ is used to maintain the full cells and vertices of a
|
||||
Delaunay triangulation in $\real^D$. It permits point insertion and
|
||||
removal. The dimension $D$ should be kept reasonably small,
|
||||
see the performance section in the user manual for what reasonable
|
||||
means.
|
||||
%: higher than 7 or 8,
|
||||
%you are entering a realm where patience is a highly useful virtue.
|
||||
|
||||
\ccInclude{CGAL/Delaunay_triangulation.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
\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{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\ can
|
||||
be defined by specifying only the first parameter, or by using the
|
||||
tag \ccc{CGAL::Default} as
|
||||
the second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to
|
||||
\ccc{Triangulation_data_structure<Maximal_dimension<TriangulationTraits::Point_d>::type,
|
||||
Triangulation_vertex<TriangulationTraits>, Triangulation_full_cell<TriangulationTraits>>}.
|
||||
|
||||
|
||||
\ccInheritsFrom
|
||||
\ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}.
|
||||
|
||||
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
|
||||
\ccCreationVariable{dt}
|
||||
|
||||
|
||||
\ccConstructor{Delaunay_triangulation(const int dim, const Geom_traits gt =
|
||||
Geom_traits());}{Instantiates a Delaunay triangulation with one vertex (the vertex
|
||||
at infinity). See the description of the inherited nested type
|
||||
\ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>::Maximal_dimension} for an explanation of
|
||||
the use of the parameter \ccc{dim}. The complex stores a copy of the geometric
|
||||
traits \ccc{gt}.}
|
||||
|
||||
|
||||
\ccHeading{Point removal} % - - - - - - - - - - - - - - - - - - - - - REMOVAL
|
||||
|
||||
\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 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
|
||||
\ccc{infinite_vertex()}.}
|
||||
|
||||
% \ccMethod{Full_cell_handle remove(const Point & p);}{Locate the point \ccc{p} in
|
||||
% 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 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
|
||||
% as above, but uses \ccc{hint} as a starting point for locating the point
|
||||
% \ccc{p} in the complex.}
|
||||
|
||||
\ccMethod{template< typename ForwardIterator > void remove(ForwardIterator
|
||||
start, ForwardIterator end);}{Remove the points or the vertices (through their
|
||||
\ccc{Vertex_handle}) in the range \ccc{[start, end)}.
|
||||
\ccc{*start} must be of type \ccc{Vertex_handle}.
|
||||
}
|
||||
|
||||
|
||||
\ccHeading{Point insertion} % - - - - - - - - - - - - - - - - - - - INSERTION
|
||||
|
||||
\ccMethod{template< typename ForwardIterator >
|
||||
size_type insert(ForwardIterator s, ForwardIterator e);}%
|
||||
{Inserts the points found in range \ccc{[s,e)} in the Delaunay triangulation
|
||||
and ensures that the empty-ball property is preserved.
|
||||
Returns the number of vertices actually inserted. (If more than one vertex share
|
||||
the same position in space, only one insertion is counted.)}
|
||||
|
||||
\ccMethod{Vertex_handle insert(const Point & p, Full_cell_handle hint
|
||||
= Full_cell_handle());}{Inserts point \ccc{p} in the Delaunay triangulation
|
||||
and ensures that the empty-ball property is preserved. Returns a
|
||||
\ccc{Vertex_handle} to the vertex of the triangulation with position \ccc{p}.
|
||||
Prior to the actual insertion, \ccc{p} is located in the triangulation;
|
||||
\ccc{hint} is used as a starting place for locating \ccc{p}.}
|
||||
|
||||
\ccMethod{Vertex_handle insert(const Point & p, Vertex_handle hint);}%
|
||||
{Same as above but uses a vertex as starting place for the search.}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
\ccMethod{Vertex_handle insert(const Point & p, const Locate_type lt,
|
||||
const Face & f, const Facet & ft, const Full_cell_handle c);}
|
||||
{Inserts the point \ccc{p} in the Delaunay triangulation
|
||||
and ensures that the empty-ball property is preserved.
|
||||
Returns a handle to the
|
||||
(possibly newly created) vertex at that position. The behavior depends on the
|
||||
value of \ccc{lt}:\begin{itemize} \item[\ccc{OUTSIDE_AFFINE_HULL}] Point
|
||||
\ccc{p} is inserted so as to increase the current dimension of the Delaunay
|
||||
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. the full cell \ccc{c} {\em is assumed} to be in conflict
|
||||
with \ccc{p}.
|
||||
(Roughly speaking, the method \ccVar.\ccc{insert_in_conflicting_cell()}
|
||||
is called.)\end{itemize}
|
||||
The parameters \ccc{lt}, \ccc{f}, \ccc{ft}
|
||||
and \ccc{c} must be consistent with the localization of point \ccc{p} in the
|
||||
Delaunay triangulation e.g. by a call to
|
||||
\ccc{c = locate(p, lt, f, ft)}.}
|
||||
|
||||
\ccMethod{Vertex_handle insert_outside_affine_hull(const Point & p);}
|
||||
{Inserts the point \ccc{p} in the Delaunay triangulation. Returns a handle to the
|
||||
(possibly newly created) vertex at that position. \ccPrecond The point \ccc{p}
|
||||
must lie outside the affine hull of the Delaunay triangulation. This implies that
|
||||
\ccVar.\ccc{current_dimension()} must be less that
|
||||
\ccVar.\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccMethod{Vertex_handle insert_in_conflicting_cell(const Point & p, const
|
||||
Full_cell_handle c);}
|
||||
{Inserts the point \ccc{p} in the Delaunay triangulation. Returns a handle to the
|
||||
(possibly newly created) vertex at that position.
|
||||
\ccPrecond The point \ccc{p}
|
||||
must be in conflict with the full cell \ccc{c}.}
|
||||
|
||||
\end{ccAdvanced}
|
||||
|
||||
\ccHeading{Queries} % - - - - - - - - - - - - - - - - - - - - - - - - QUERIES
|
||||
|
||||
\ccMethod{bool is_in_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 full cell \ccc{c} ({i.e.}, the circumscribing ball of
|
||||
$c$ contains $p$ in its interior).
|
||||
}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
\ccMethod{template< typename OutputIterator >
|
||||
Facet compute_conflict_zone(const Point & p, const Full_cell_handle c,
|
||||
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}.
|
||||
A facet \ccc{(cc,i)} on the boundary of the conflict zone with
|
||||
\ccc{cc} in conflict is returned.
|
||||
\ccPrecond \ccc{c} is in conflict
|
||||
with \ccc{p}.\\ \ccVar.\ccc{current_dimension()}$\geq 2$.
|
||||
}
|
||||
|
||||
\end{ccAdvanced}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>},\\
|
||||
|
||||
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
\begin{ccRefClass}{Regular_complex<RCTraits, PCDS>}
|
||||
|
||||
TODO: this documentation is not finished.
|
||||
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
|
||||
\begin{ccRefConcept}{RegularComplexTraits}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ describes the various types and functions that a class
|
||||
has to provide as the first parameter (\ccc{RCTraits}) to the class template
|
||||
\ccc{Regular_complex<DCTraits, PCDS>}. It brings the geometric ingredient to
|
||||
the definition of a Regular complex, while the combinatorial ingredient is
|
||||
brought by the second template parameter, \ccc{PCDS}.
|
||||
|
||||
\ccRefines
|
||||
|
||||
\ccc{PureComplexTraits}.
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{Weighted_point_d}{A type representing a point in Euclidean
|
||||
space with an associated weight (in $\real$).}
|
||||
|
||||
\ccNestedType{Side_of_oriented_orthogonal_sphere_d}{A predicate object that
|
||||
must provide the templated operator\\\ccc{template<typename ForwardIterator>
|
||||
Oriented_side operator()(ForwardIterator start, ForwardIterator end, const
|
||||
Weighted_point_d & p)}.\\The operator returns \ccc{ON_POSITIVE_SIDE} if the
|
||||
query point \ccc{p} lies in the positive side of the sphere \ccc{S} orthogonal
|
||||
to the weighted points in the range \ccc{[start,end)}. It returns
|
||||
\ccc{ON_NEGATIVE_SIDE} if the point \ccc{p} lies on the negative side of the
|
||||
sphere \ccc{S}. It returns \ccc{ON_ORIENTED_BOUNDARY} if the point \ccc{p}
|
||||
lies on the sphere \ccc{S}. If the simplex \ccc{[start,end)} is positively
|
||||
oriented, then the positive side of sphere \ccc{S} corresponds geometrically
|
||||
to the bounded side of \ccc{S} and the negative side corresponds to the
|
||||
unbounded side of \ccc{S}. If the simplex is negatively oriented, the
|
||||
correspondance is inverted. \\ The range's size must of course be one more
|
||||
than the dimension of the Euclidean space the points live in: \ccPrecond
|
||||
\ccc{std::distance(start,end)==start->dimension()+1}. The points in range
|
||||
\ccc{[start,end)} must be affinely independent, {i.e.,} the simplex must
|
||||
not be flat.}
|
||||
|
||||
\ccNestedType{Side_of_oriented_orthogonal_subphere_d}{A predicate object that
|
||||
must provide the templated operator\\\ccc{template<typename ForwardIterator>
|
||||
Oriented_side operator()(ForwardIterator start, ForwardIterator end, const
|
||||
Point_d & p)}.\\ Let Aff be the affine subspace spanned by the points in range
|
||||
\ccc{[start,end)}. The operator behaves in the same way as the above predicate
|
||||
\ccc{Side_of_oriented_orthogonal_sphere_d}, but operates in the affine
|
||||
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
|
||||
{\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
|
||||
\ccc{[start,end)} must be affinely independent in Aff, {i.e.,} the
|
||||
simplex must not be flat in Aff.}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{traits}
|
||||
|
||||
\ccConstructor{RegularComplexTraits();}{The default constructor.}
|
||||
|
||||
\ccOperations
|
||||
|
||||
The following methods permit access to the traits class's predicates:
|
||||
|
||||
\ccMethod{Side_of_oriented_orthogonal_sphere_d
|
||||
side_of_oriented_sphere_d_object() const;}
|
||||
{}
|
||||
\ccGlue
|
||||
\ccMethod{Side_of_oriented_orthogonal_subphere_d
|
||||
side_of_oriented_subphere_d_object() const;}
|
||||
{}
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Cartesian_d<FT, Dim, LA>},\\
|
||||
\ccc{CGAL::Simple_cartesian_d<FT, Dim, LA>},\\
|
||||
\ccc{CGAL::Filtered_kernel_d<K>} (recommended).
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{PureComplexTraits}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
|
||||
\begin{ccRefConcept}[TriangulationDataStructure::]{Cell}
|
||||
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ stores
|
||||
\ccc{Vertex_handle}s to its vertices and \ccc{Full_cell_handle}s
|
||||
to its neighbors. The vertices are indexed $0, 1,\ldots,\cd$ in consistent
|
||||
order. The neighbor indexed $i$ lies opposite to vertex \ccc{i}.
|
||||
|
||||
|
||||
\ccTypes
|
||||
\ccThree{typedef TriangulationDataStructure::Full_cell_handle}{TriangulationDataStructure}{}
|
||||
\ccThreeToTwo
|
||||
The class \ccRefName\ defines the following types.
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure Triangulation_data_structure;}{}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Vertex_handle Vertex_handle;}{}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Full_cell_handle Full_cell_handle;}{}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{c} %% choose variable name
|
||||
\ccThree{Full_cell_handle}{c.has_neighbor( Full_cell_handle n, int & i) const}{}
|
||||
|
||||
In order to obtain new cells or destruct unused cells, the user must call the
|
||||
\ccc{new_full_cell()} and \ccc{delete_full_cell()} methods of the triangulation data
|
||||
structure.
|
||||
|
||||
\ccOperations
|
||||
|
||||
\ccAccessFunctions
|
||||
|
||||
\ccMethod{Vertex_handle vertex(int i) const;}
|
||||
{Returns the vertex \ccc{i} of \ccVar.
|
||||
\ccPrecond{$i \in [0,\ad]$.}}
|
||||
\ccGlue
|
||||
\ccMethod{int index(Vertex_handle v) const;}
|
||||
{Returns the index of vertex \ccc{v} in \ccVar.
|
||||
\ccPrecond{\ccc{v} is a vertex of \ccVar}.}
|
||||
\ccGlue
|
||||
\ccMethod{bool has_vertex(Vertex_handle v) const;}
|
||||
{Returns \ccc{true} if \ccc{v} is a vertex of \ccVar.}
|
||||
\ccGlue
|
||||
\ccMethod{bool has_vertex(Vertex_handle v, int & i) const;}
|
||||
{Returns \ccc{true} if \ccc{v} is a vertex of \ccVar, and
|
||||
computes its index \ccc{i} in \ccVar.}
|
||||
|
||||
\ccMethod{Full_cell_handle neighbor(const int i) const;}
|
||||
{Returns the neighbor \ccc{i} of \ccVar.
|
||||
\ccPrecond{$i \in [0,\ad]$.}}
|
||||
\ccGlue
|
||||
\ccMethod{int index(Full_cell_handle n) const;}
|
||||
{Returns the index corresponding to adjacent cell \ccc{n}.
|
||||
\ccPrecond{\ccc{n} is a neighbor of \ccVar.}}
|
||||
\ccGlue
|
||||
\ccMethod{bool has_neighbor(Full_cell_handle n) const;}
|
||||
{Returns \ccc{true} if \ccc{n} is a neighbor of \ccVar.}
|
||||
\ccGlue
|
||||
\ccMethod{bool has_neighbor(Full_cell_handle n, int & i) const;}
|
||||
{Returns \ccc{true} if \ccc{n} is a neighbor of \ccVar, and
|
||||
computes its index \ccc{i} in \ccVar.}
|
||||
|
||||
\ccHeading{Setting}
|
||||
|
||||
\ccMethod{void set_vertex(int i, Vertex_handle v);}
|
||||
{Sets vertex \ccc{i} to \ccc{v}.
|
||||
\ccPrecond{$i \in [0,\ad]$.}}
|
||||
|
||||
\ccMethod{void set_neighbor(int i, Full_cell_handle n);}
|
||||
{Sets neighbor \ccc{i} to \ccc{n}.
|
||||
\ccPrecond{$i \in [0,\ad]$.}}
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Checking}
|
||||
\ccThree{Full_cell_handle}{c.is_valid(}{}
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose = false) const;}
|
||||
{User defined local validity checking function.}
|
||||
\end{ccDebug}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationDataStructure::Vertex}\\
|
||||
\ccc{TriangulationDataStructure}.
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
|
||||
\begin{ccRefConcept}[TriangulationDataStructure::]{Vertex}
|
||||
|
||||
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
|
||||
%% \ccHtmlIndexC[concept]{} %% add further index entries
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ represents the vertex class of a triangulation
|
||||
data structure. It must define
|
||||
the types and operations listed in this section. Some of these
|
||||
requirements are of geometric nature, they are \textit{optional}
|
||||
when using the triangulation data structure class alone. They become
|
||||
compulsory when the triangulation data structure is used as a layer
|
||||
for the geometric triangulation class.
|
||||
\ccTypes
|
||||
\ccTwo{typedef TriangulationDataStructure}{}
|
||||
\ccNestedType{Point}{\textit{Optional for the triangulation data
|
||||
structure alone.}}
|
||||
|
||||
The class \ccRefName\ defines types that are the same as some of the
|
||||
types defined by the triangulation data structure class
|
||||
\ccc{TriangulationDataStructure}.
|
||||
|
||||
\ccThree{typedef TriangulationDataStructure::Full_cell_handle}{Full_cell_handle}{}
|
||||
\ccThreeToTwo
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure Triangulation_data_structure;}{}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Vertex_handle Vertex_handle;}{}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Full_cell_handle Full_cell_handle;}{}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{v} %% choose variable name
|
||||
|
||||
In order to obtain new vertices or destruct unused vertices, the user must
|
||||
call the \ccc{new_vertex()} or \ccc{delete_vertex()} method of the
|
||||
triangulation data structure.
|
||||
|
||||
\ccOperations
|
||||
\ccThree{Full_cell_handle}{v.set_full_cell(Full_cell_handle cx)}{}
|
||||
|
||||
\ccAccessFunctions
|
||||
|
||||
\ccMethod{Full_cell_handle full_cell() const;}
|
||||
{Returns a full cell of the triangulation having \ccVar\ as vertex.}
|
||||
|
||||
\ccMethod{Point point() const;}
|
||||
{Returns the point stored in the vertex.
|
||||
{\textit{Optional for the triangulation data structure alone.}}}
|
||||
|
||||
\ccHeading{Setting}
|
||||
|
||||
\ccMethod{void set_full_cell(Full_cell_handle c);}
|
||||
{Sets the incident cell to \ccc{c}.}
|
||||
|
||||
\ccMethod{void set_point(const Point & p);}
|
||||
{Sets the point to \ccc{p}. {\textit{Optional for the
|
||||
triangulation data structure alone.}}}
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Checking}
|
||||
|
||||
\ccThree{Full_cell_handle}{v.is_valid()}{}
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose = false) const;}
|
||||
{Checks the validity of the vertex. Must check that its incident cell
|
||||
has this vertex. The validity of the base vertex is also checked.\\
|
||||
When \ccc{verbose} is set to \ccc{true}, messages are printed to give
|
||||
a precise indication on the kind of invalidity encountered.}
|
||||
\end{ccDebug}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationDataStructure::FullCell}\\
|
||||
\ccc{TriangulationDataStructure}.
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,533 +0,0 @@
|
|||
\begin{ccRefClass}{Triangulation<TriangulationTraits, TriangulationDataStructure>}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ is used to store and query the full cells and vertices of
|
||||
a triangulationin dimension $d$. A special vertex, named
|
||||
{em infinite vertex}, is used to triangulate the outside of the convex
|
||||
hull of the points in so called {\em infinite cells}.
|
||||
|
||||
\ccInclude{CGAL/Triangulation.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
\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{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\ can
|
||||
be defined by specifying only the first parameter, or by using the
|
||||
tag \ccc{CGAL::Default} as
|
||||
the second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to
|
||||
\ccc{Triangulation_data_structure<Maximal_dimension<TriangulationTraits::Point_d>::type,
|
||||
Triangulation_vertex<TriangulationTraits>, Triangulation_full_cell<TriangulationTraits>>}.
|
||||
|
||||
\ccTypes
|
||||
\ccThree{typedef TriangulationTraits::Point_d}{Maximal_dimension;}{}
|
||||
%The following types are self-explanatory: % but we are explaining anyway
|
||||
|
||||
\ccTypedef{typedef TriangulationTraits Geom_traits;}%
|
||||
{Type for the model of the \ccc{TriangulationTraits} concept.}
|
||||
|
||||
\ccTypedef{typedef TriangulationTraits::Point_d Point;}{A point in Euclidean space.}
|
||||
|
||||
\ccTypedef{typedef TriangulationTraits::Dimension Maximal_dimension;}%
|
||||
{This indicates whether the dimension of the underlying space is static
|
||||
(\ccc{Maximal_dimension}=\ccGlobalScope\ccc{Dimension_tag<int dim>}) or
|
||||
dynamic (\ccc{Maximal_dimension}=\ccGlobalScope\ccc{Dynamic_dimension_tag}).
|
||||
In the latter case, the \ccc{dim} parameter passed to the class's constructor
|
||||
is used.}
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure Triangulation_ds;}%
|
||||
{The second template parameter.}
|
||||
|
||||
|
||||
\ccThree{typedef TriangulationDataStructure::Full_cell_iterator}{Full_cell_iterator}{}
|
||||
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure::Vertex Vertex;}{A model of the concept
|
||||
\ccc{TriangulationVertex}.}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Full_cell Full_cell;}{A model of the concept
|
||||
\ccc{TriangulationFullCell}.}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Facet Facet;}{The facet
|
||||
class}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef TriangulationDataStructure::Face Face;}%
|
||||
{A model of the concept \ccc{TriangulationDSFace}.}
|
||||
|
||||
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.
|
||||
|
||||
Iterators and circulators are convertible to the corresponding handles, thus
|
||||
the user can pass them directly as arguments to the functions.
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure::Vertex_handle
|
||||
Vertex_handle;}{handle to a a vertex}
|
||||
\ccGlue\ccTypedef{typedef TriangulationDataStructure::Vertex_iterator
|
||||
Vertex_iterator;}{iterator over all vertices}
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure::Full_cell_handle
|
||||
Full_cell_handle;}{handle to a full cell}
|
||||
\ccGlue\ccTypedef{typedef
|
||||
TriangulationDataStructure::Full_cell_iterator
|
||||
Full_cell_iterator;}{iterator over all full cells}
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure::Facet_iterator
|
||||
Facet_iterator;}{iterator over all facets}
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure::size_type size_type;}{Size type (an unsigned integral
|
||||
type).}
|
||||
\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
|
||||
which case occurs when locating a point in the triangulation:
|
||||
|
||||
\ccEnum{
|
||||
enum Locate_type
|
||||
{
|
||||
ON_VERTEX
|
||||
, IN_FACE
|
||||
, IN_FACET
|
||||
, IN_FULL_CELL
|
||||
, OUTSIDE_CONVEX_HULL
|
||||
, OUTSIDE_AFFINE_HULL
|
||||
};}{See \ccc{CGAL::Triangulation::Locate_type}}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{tr}
|
||||
|
||||
\ccConstructor{Triangulation(const int dim, const Geom_traits & gt =
|
||||
Geom_traits())}
|
||||
{Instantiates a triangulation with one vertex (the vertex at infinity). See the
|
||||
description of the nested type \ccc{Maximal_dimension} above for an
|
||||
explanation of the use of the parameter \ccc{dim}. The triangulation stores a copy
|
||||
of the geometric traits \ccc{gt}.}
|
||||
|
||||
\ccConstructor{Triangulation(const Triangulation & t2);}
|
||||
{The copy constructor.}% All vertices and full cells are duplicated.}
|
||||
|
||||
\ccHeading{Access functions}
|
||||
|
||||
\ccThree{Finite_full_cell_iterator}{tr.number_of_vertices() const}{}
|
||||
|
||||
\ccMethod{const Triangulation_ds & tds() const;}%
|
||||
{Returns a const reference to the underlying triangulation data structure.}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
\ccMethod{Triangulation_ds & tds();}%
|
||||
{Returns a non-const
|
||||
reference to the underlying triangulation data structure.}
|
||||
\end{ccAdvanced}
|
||||
|
||||
\ccMethod{const Geom_traits & geom_traits() const;}%
|
||||
{Returns a const reference to the geometric traits instance.}
|
||||
|
||||
\ccMethod{int maximal_dimension() const;}%
|
||||
{Returns the dimension of the embedding Euclidean space.}
|
||||
\ccGlue
|
||||
\ccMethod{int current_dimension() const;}%
|
||||
{Returns the dimension of the triangulation (as an embedded manifold).}
|
||||
|
||||
\ccMethod{bool empty() const;}%
|
||||
{Returns \ccc{true} if the triangulation has no finite vertex. Returns
|
||||
\ccc{false} otherwise.}
|
||||
\ccGlue
|
||||
\ccMethod{size_type number_of_vertices() const;}%
|
||||
{Returns the number of finite vertices in the triangulation.}
|
||||
\ccGlue
|
||||
\ccMethod{size_type number_of_full_cells() const;}%
|
||||
{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 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 full cells of maximal dimension that are not
|
||||
incident to the vertex at infinity.}
|
||||
|
||||
\ccHeading{Tests for finite and infinite elements}
|
||||
|
||||
\ccMethod{bool is_infinite(const Vertex_handle v) const;}
|
||||
{Returns \ccc{true} if and only if the vertex \ccc{v} is the infinite vertex.}
|
||||
|
||||
\ccGlue
|
||||
|
||||
\ccMethod{bool is_infinite(const Full_cell_handle c) const;}
|
||||
{Returns \ccc{true} if and only if \ccc{c} is incident to the infinite vertex.
|
||||
%\ccPrecond $0\leq$\ccVar.\ccc{current_dimension()}.
|
||||
}
|
||||
|
||||
\ccGlue
|
||||
|
||||
\ccMethod{bool is_infinite(const Facet & ft) const;}
|
||||
{Returns \ccc{true} if and only if facet \ccc{ft} is incident to the infinite
|
||||
vertex.
|
||||
}
|
||||
|
||||
\ccGlue
|
||||
|
||||
\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.
|
||||
}
|
||||
|
||||
|
||||
%\ccHeading{Queries}
|
||||
|
||||
% \ccMethod{bool is_vertex(const Point & p, Vertex_handle & v) const;} {Tests
|
||||
% whether \ccc{p} is a vertex of \ccVar\ by locating \ccc{p} in the triangulation. If
|
||||
% \ccc{p} is found, the associated vertex \ccc{v} is given.}
|
||||
|
||||
% \ccGlue\ccMethod{bool is_vertex(const Point & p, Vertex_handle & v,
|
||||
% Full_cell_handle hint) const;} {Same as above. The \ccc{Full_cell_handle hint} is
|
||||
% an optional parameter that is used as a hint for the point location.}
|
||||
|
||||
% \ccGlue\ccMethod{bool is_vertex(Vertex_handle v) const;}
|
||||
% {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 full cell of \ccVar.}
|
||||
|
||||
% \ccMethod{Orientation orientation(Full_cell_handle c) const;}
|
||||
% {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.
|
||||
% }
|
||||
|
||||
% \ccMethod{template< typename OutputIterator > OutputIterator
|
||||
% incident_full_cells(Vertex_const_handle v, OutputIterator out) const;}
|
||||
% {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 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 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 full cells that share at least one vertex with the \ccc{Face
|
||||
% f}. Returns the output iterator.
|
||||
% %\ccPrecond\ccc{is_full_cell(f.full_cell())}.
|
||||
% }
|
||||
|
||||
% \ccMethod{template< typename OutputIterator > OutputIterator
|
||||
% incident_faces(Vertex_handle v, const int d, OutputIterator
|
||||
% out);}{Constructs all the \ccc{Face}s of dimension \ccc{d} incident to
|
||||
% \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}. If
|
||||
% $d\geq$ \ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
|
||||
% constructed.
|
||||
% \ccPrecond$0 < d$.
|
||||
% }
|
||||
|
||||
% \ccMethod{template< typename OutputIterator > OutputIterator
|
||||
% incident_upper_faces(Vertex_const_handle v, int d, OutputIterator
|
||||
% 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 {\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
|
||||
% faces of dimension \ccc{d} of the triangulation.\\ The constructed \ccc{Faces} are
|
||||
% lexicographically ordered using the vertex order as base ordering. In order to
|
||||
% make it easy to find the infinite \ccc{Faces}, the latter ordering makes the
|
||||
% vertex at infinity the smallest vertex; so calling the method on a finite
|
||||
% vertex will construct only finite faces and calling it on the vertex at
|
||||
% infinity will produce all infinite \ccc{d}-faces. (Elle est pas belle, la vie
|
||||
% ?) If $d\geq $\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
|
||||
% constructed.
|
||||
% \ccPrecond$0 < d$.
|
||||
% }
|
||||
|
||||
% \ccGlue\ccMethod{template< typename OutputIterator, typename Comparator >
|
||||
% OutputIterator incident_upper_faces(Vertex_const_handle v, const int d,
|
||||
% OutputIterator out, Comparator cmp);} {Same as above, but uses \ccc{cmp} as
|
||||
% 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 full cell containing the facet \ccc{f}}
|
||||
|
||||
\ccMethod{int index_of_covertex(const Facet & f) const;}
|
||||
{Returns the index of the vertex of the full cell
|
||||
\ccc{c=}\ccVar.\ccc{full_cell(f)} which does {not} belong to \ccc{c}.}
|
||||
|
||||
\ccHeading{Triangulation traversal} % - - - - - - - - - - - - - - - - - - TRAVERSAL
|
||||
|
||||
%\ccMethod{Vertex_const_iterator vertices_begin() const;}{}
|
||||
%\ccGlue
|
||||
\ccMethod{Vertex_iterator vertices_begin();}
|
||||
{The first vertex of \ccVar.}
|
||||
%\ccGlue\ccMethod{Vertex_const_iterator vertices_end() const;}{}
|
||||
\ccGlue\ccMethod{Vertex_iterator vertices_end();}
|
||||
{The beyond vertex of \ccVar.}
|
||||
|
||||
%\ccMethod{Finite_vertex_const_iterator finite_vertices_begin() const;}{}
|
||||
%\ccGlue
|
||||
\ccMethod{Finite_vertex_iterator finite_vertices_begin();}
|
||||
{The first finite vertex of \ccVar.}
|
||||
%\ccGlue\ccMethod{Finite_vertex_const_iterator finite_vertices_end() const;}{}
|
||||
\ccGlue\ccMethod{Finite_vertex_iterator finite_vertices_end();}
|
||||
{The beyond finite vertex of \ccVar.}
|
||||
|
||||
%\ccMethod{Full_cell_const_iterator full_cells_begin()const;}{}\ccGlue
|
||||
\ccMethod{Full_cell_iterator full_cells_begin();}
|
||||
{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 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 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 full cell of \ccVar.}
|
||||
|
||||
\ccMethod{Facet_iterator facets_begin();}
|
||||
{Iterator to the first facet of the triangulation.}
|
||||
\ccGlue
|
||||
\ccMethod{Facet_iterator facets_end();}
|
||||
{Iterator to the beyond facet of the triangulation.}
|
||||
|
||||
\ccMethod{Finite_facet_iterator finite_facets_begin();}
|
||||
{Iterator to the first finite facet of the triangulation.}
|
||||
\ccGlue
|
||||
\ccMethod{Finite_facet_iterator finite_facets_end();}
|
||||
{Iterator to the beyond finite facet of the triangulation.}
|
||||
|
||||
\ccHeading{Point location} % - - - - - - - - - - - - - - - - - POINT LOCATION
|
||||
|
||||
The class \ccRefName\ provides methods to locate a query point with respect to
|
||||
the triangulation:
|
||||
|
||||
\ccMethod{Full_cell_handle locate(const Point & query,
|
||||
Full_cell_handle hint = Full_cell_handle()) const;}
|
||||
{The optional argument \ccc{hint} is used as a starting place for the search.\\
|
||||
If the \ccc{query} point lies outside the affine hull of the points (which can
|
||||
happen when \ccVar.\ccc{current_dimension() < }
|
||||
\ccVar.\ccc{maximal_dimension()}) or if there is no finite vertex yet in the
|
||||
triangulation, then \textit{locate} returns a default constructed
|
||||
\ccc{Full_cell_handle()}.\\
|
||||
If the point \ccc{query} lies in the interior of 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 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)$).}
|
||||
|
||||
\ccMethod{Full_cell_handle locate(const Point & query, Vertex_handle hint)
|
||||
const;}
|
||||
{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;}
|
||||
{The optional argument \ccc{hint} is used as a starting place for the
|
||||
search.\\ If the \ccc{query} point lies outside the affine hull of the points
|
||||
(which can happen when \ccVar.\ccc{current_dimension() < }
|
||||
\ccVar.\ccc{maximal_dimension()}) or if there is no finite vertex yet in the
|
||||
triangulation, then \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} {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 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 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 representation of
|
||||
the finite facet containing the
|
||||
\ccc{query} point. The full cell of \ccc{ft} is returned.
|
||||
\item[$k=$\ccc{c.current_dimension()}] If the \ccc{query} point lies
|
||||
{\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
|
||||
{\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
|
||||
locate(const Point & query, Locate_type & loc_type,
|
||||
Face & f, Vertex_handle hint) const;}
|
||||
{Same as above but \ccc{hint}, the starting place for the search, is a vertex.
|
||||
The parameter \ccc{hint} is ignored if it is a default constructed
|
||||
\ccc{Vertex_handle()}.}
|
||||
|
||||
\ccHeading{Removal} % - - - - - - - - - - - - - - - - - - - - - - - REMOVALS
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
\ccMethod{Vertex_handle collapse_face(const Point & p, const Face & f);}
|
||||
{Contracts the \ccc{Face f} to a single vertex at position \ccc{p}. Returns a
|
||||
handle to that vertex.
|
||||
\ccPrecond The boundary of the union of full cells incident to \ccc{f} must
|
||||
be a triangulation of a sphere of dimension
|
||||
\ccVar.\ccc{current_dimension()}).
|
||||
}
|
||||
|
||||
\end{ccAdvanced}
|
||||
|
||||
% - - - - - - - - - - - - - - - - - - - - - - - - - - - INSERTION
|
||||
|
||||
\ccHeading{Point insertion}
|
||||
|
||||
The class \ccRefName\ provides functions to insert a given point in the
|
||||
triangulation:
|
||||
|
||||
\ccMethod{template< typename ForwardIterator >
|
||||
size_type insert(ForwardIterator s, ForwardIterator e);}%
|
||||
{Inserts the points found in range \ccc{[s,e)} in the triangulation. Returns
|
||||
the number of vertices actually inserted. (If several vertices share the
|
||||
same position in space, only the first insertion is counted.)}
|
||||
|
||||
\ccMethod{Vertex_handle insert(const Point p, Full_cell_handle hint =
|
||||
Full_cell_handle());}{Inserts point \ccc{p} in the triangulation. Returns a
|
||||
\ccc{Vertex_handle} to the vertex of the triangulation with position \ccc{p}.
|
||||
Prior to the actual insertion, \ccc{p} is located in the triangulation;
|
||||
\ccc{hint} is used as a starting place for locating \ccc{p}.}
|
||||
|
||||
\ccMethod{Vertex_handle insert(const Point p, Vertex_handle hint);}%
|
||||
{Same as above but uses a vertex \ccc{hint} as the starting place for the search.}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
\ccMethod{Vertex_handle insert(const Point p, Locate_type
|
||||
loc_type, Face & f, Facet & ft, Full_cell_handle c);} {Inserts
|
||||
point \ccc{p} into the triangulation and returns a handle to the
|
||||
\ccc{Vertex} at that position. The action taken depends on the value of
|
||||
\ccc{loc_type}:\begin{itemize} \item[\ccc{ON_VERTEX}] The point of the
|
||||
\ccc{Vertex} described by \ccc{f} is set to \ccc{p}. \item[\ccc{IN_FACE}]
|
||||
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 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 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 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 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 full cells are not
|
||||
retrieved.}
|
||||
|
||||
\ccMethod{Vertex_handle insert_in_face(const Point & p, const Face & f);}%
|
||||
{Inserts point \ccc{p} in the triangulation.
|
||||
\ccPrecond \ccc{p} must lie in the relative interior of \ccc{f}.}
|
||||
|
||||
\ccMethod{Vertex_handle insert_in_facet(const Point & p, const Facet & ft);}%
|
||||
{Inserts point \ccc{p} in the triangulation.
|
||||
\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
|
||||
c);}%
|
||||
{Inserts point \ccc{p} in the triangulation. \ccPrecond \ccc{p} must lie in the
|
||||
interior of \ccc{c}.}
|
||||
|
||||
\ccMethod{Vertex_handle insert_outside_convex_hull(const Point &,
|
||||
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 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 {affine} hull of \ccVar.}
|
||||
|
||||
\end{ccAdvanced}
|
||||
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check}
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose=false) const;}
|
||||
{Partially checks whether \ccVar\ is a triangulation. This function returns
|
||||
\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: It
|
||||
is checked that the orientation of each finite full cell is positive and that
|
||||
the orientation of each infinite full cell is consistent with their finite
|
||||
adjacent full cells.
|
||||
The \ccc{verbose} parameter is not used.%
|
||||
}
|
||||
|
||||
\ccMethod{bool are_incident_full_cells_valid(Vertex_const_handle v, bool
|
||||
verbose = false) const;} {Returns \ccc{true} if and only if all
|
||||
finite full cells incident to \ccc{v} have positive orientation.
|
||||
The \ccc{verbose} parameter is not used.%
|
||||
}
|
||||
|
||||
\end{ccDebug}
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
|
||||
\ccFunction{istream & operator>> (istream & is, Triangulation & t);}
|
||||
{Reads the underlying combinatorial triangulation from \ccc{is} by
|
||||
calling the corresponding input operator of the triangulation data
|
||||
structure class (note that the infinite vertex is numbered 0), and the
|
||||
non-combinatorial information by calling the corresponding input
|
||||
operators of the vertex and the full cell classes (such as point
|
||||
coordinates), which are provided by overloading the stream operators
|
||||
of the vertex and full cell types. Assigns the resulting triangulation to
|
||||
\ccc{t}.}
|
||||
|
||||
\ccFunction{ostream& operator<< (ostream& os, const Triangulation & t);}
|
||||
{Writes the triangulation \ccc{t} into \ccc{os}.}
|
||||
|
||||
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 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, TriangulationDSVertex, TriangulationDSFullCell>},\\
|
||||
\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>},\\
|
||||
%\ccc{Regular_triangulation<RTTraits, TriangulationDataStructure>}.
|
||||
|
||||
\end{ccRefClass}
|
||||
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationDSFace}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
A \ccRefName\ 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 {\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{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationDSFace} is
|
||||
defined/used.}
|
||||
|
||||
\ccNestedType{Vertex_handle}{Must be the same as the nested type
|
||||
\ccc{TriangulationDataStructure::Vertex_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationDSFace} is
|
||||
defined/used.}
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Triangulation_face<TriangulationDataStructure>}.
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{f}
|
||||
|
||||
There is no default constructor, since the maximal 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
|
||||
full cell to \ccc{c} and the maximal dimension to
|
||||
\ccc{c.maximal_dimension()}.
|
||||
\ccPrecond \ccc{c!=Full_cell_handle()}
|
||||
}
|
||||
|
||||
\ccConstructor{Triangulation_face(const int ad);}{Setup the \ccc{Face} knowing
|
||||
the maximal dimension \ccc{ad}. Sets the \ccc{Face}'s full cell to the
|
||||
default-constructed one.}
|
||||
|
||||
\ccHeading{Access functions}
|
||||
|
||||
\ccMethod{Full_cell_handle full_cell() const;}{Returns a handle to a cell that
|
||||
has the face in its boundary.}
|
||||
|
||||
\ccMethod{int face_dimension() const;}{Returns the dimension of the face
|
||||
(one less than the number of vertices).}
|
||||
|
||||
\ccMethod{int index(int i) const;}{Returns the index of the \ccc{i}-th vertex
|
||||
of the face in the cell \ccVar.\ccc{full_cell()}. \ccPrecond $0\leq i\leq$\ccVar.\ccc{face_dimension()}.}
|
||||
|
||||
\ccMethod{Vertex_handle vertex(int i) const;}{Returns a handle to the
|
||||
\ccc{i}-th \ccc{Vertex} of the face in the cell \ccVar.\ccc{full_cell()}.
|
||||
\ccPrecond $0\leq i\leq$\ccVar.\ccc{face_dimension()}.}
|
||||
|
||||
\ccHeading{Update functions}
|
||||
|
||||
\ccMethod{void clear();}{Sets the facet to the empty set. Maximal
|
||||
dimension remains unchanged.}
|
||||
|
||||
\ccMethod{void set_full_cell(Full_cell_handle c);}{Sets the cell of the face to
|
||||
\ccc{c}.
|
||||
\ccPrecond \ccc{c!=Full_cell_handle()}
|
||||
}
|
||||
|
||||
\ccMethod{void set_index(int i, int j);}{Sets the index of the \ccc{i}-th
|
||||
vertex of the face to be the \ccc{j}-th vertex of the full cell.
|
||||
\ccPrecond $0\leq i\leq$\ccVar.\ccc{full_cell()->face_dimension()}.
|
||||
\ccPrecond $0\leq j\leq$\ccVar.\ccc{full_cell()->maximal_dimension()}.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
||||
\ccc{TriangulationDataStructure::FullCell} \\
|
||||
\ccc{TriangulationDataStructure::Vertex} \\
|
||||
\ccc{TriangulationDataStructure}\\
|
||||
\ccc{Triangulation}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,230 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationDSFullCell}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
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 full cell refers 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.
|
||||
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Triangulation_ds_full_cell<TriangulationDataStructure,DSFullCellStoragePolicy>}\\
|
||||
\ccc{CGAL::Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccThree{Full_cell_handle}{v. set_full_cell(Full_cell_handle c);}{}
|
||||
\ccThreeToTwo
|
||||
|
||||
|
||||
\ccNestedType{Vertex_handle}%{}
|
||||
%\ccGlue\ccNestedType{Vertex_const_handle}
|
||||
{A handle to a vertex. It must be the same as 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 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{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the
|
||||
\ccc{TriangulationDSFullCell} is defined/used.}
|
||||
|
||||
\ccThree{Full_cell_handle}{TriangulationDataStructure::Full_cell_data TDS_data}{}
|
||||
\ccThreeToTwo
|
||||
|
||||
\ccTypedef{typedef TriangulationDataStructure::Full_cell_data
|
||||
TDS_data;}{A data member of this type has to be stored and accessible through
|
||||
access function below.}
|
||||
|
||||
|
||||
\ccThree{Full_cell_handle}{v. set_full_cell(Full_cell_handle c);}{}
|
||||
\ccThreeToTwo
|
||||
|
||||
\ccNestedType{
|
||||
template <typename TDS2>
|
||||
Rebind_TDS}
|
||||
{This nested template class has to define a type \ccc{Other} which is the
|
||||
{\it rebound} vertex, that is, the one whose \ccc{Triangulation_data_structure}
|
||||
will be the actually used one. The \ccc{Other} type will be the real base
|
||||
class of \ccc{Triangulation_data_structure::Full_cell}.}
|
||||
|
||||
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{c}
|
||||
|
||||
\ccConstructor{TriangulationDSFullCell(int dmax);}{Sets the maximum possible
|
||||
dimension of the full cell.}
|
||||
|
||||
\ccConstructor{TriangulationDSFullCell(const TriangulationDSFullCell & fc);}%
|
||||
{Copy constructor.}
|
||||
|
||||
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 full cell into
|
||||
a triangulation.
|
||||
|
||||
\ccHeading{Access functions}
|
||||
|
||||
\ccMethod{int maximal_dimension() const;}{Returns one less than the maximum
|
||||
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;}
|
||||
{Returns an iterator to the first \ccc{Vertex_handle} stored in the
|
||||
full cell.}
|
||||
|
||||
\ccMethod{Vertex_handle_iterator vertices_end() const;}
|
||||
{Returns an iterator pointing beyond the last \ccc{Vertex_handle} stored in
|
||||
the full cell.}
|
||||
|
||||
\ccMethod{Vertex_handle vertex(const int i) const;}{Returns the \ccc{i}-th vertex
|
||||
of the full cell. \ccPrecond $0\leq i\leq$\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccGlue\ccMethod{Full_cell_handle neighbor(const int i) const;}{Returns the
|
||||
full cell opposite to the \ccc{i}-th vertex of the full cell \ccVar. \ccPrecond
|
||||
$0\leq i\leq$\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccMethod{int mirror_index(const int i) const;}{Returns the index \ccc{j} of
|
||||
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 \ccVar has no adjacent full cell of index \ccc{i}.
|
||||
\ccPrecond $0\leq i\leq$\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccMethod{int index(Full_cell_handle n) const;}{Returns the index \ccc{i}
|
||||
such that \ccVar\ccc{.neighbor(i)==n}. \ccPrecond \ccc{n}
|
||||
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 \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 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
|
||||
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 full cell
|
||||
\ccVar. This function works even if the adjacency 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
|
||||
triangulation. \ccPrecond $0\leq
|
||||
i,$\ccc{cur_dim}$\leq$\ccc{maximal_dimension()}.}
|
||||
\end{ccAdvanced}
|
||||
|
||||
|
||||
\ccHeading{Update functions} % - - - - - - - - - - - - - - - - - UPDATES
|
||||
\ccThree{ostream&}{c. set_mirror_index(const int i, const int index)}{}
|
||||
|
||||
\ccMethod{void set_vertex(const int i, Vertex_handle v);}{Sets the $i$-th
|
||||
vertex of the full cell.
|
||||
\ccPrecond $0\leq i\leq$\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccMethod{void set_neighbor(const int i, Full_cell_handle n);} {Sets the
|
||||
\ccc{i}-th neighbor of \ccVar\ to \ccc{n}. Full cell \ccc{n} is
|
||||
opposite to the $i$-th vertex of \ccVar.
|
||||
\ccPrecond $0\leq i\leq$\ccc{maximal_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 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{maximal_dimension()}.}
|
||||
|
||||
\ccMethod{void swap_vertices(int d1, int d2);}{Switches the orientation of the
|
||||
full cell \ccVar\ by swapping its vertices with index \ccc{d1} and \ccc{d2}.
|
||||
\ccPrecond $0\leq d1,d2\leq$\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccHeading{Queries}
|
||||
|
||||
\ccMethod{bool has_vertex(Vertex_handle v) const;}{Returns \ccc{true}
|
||||
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 full cell \ccVar. Returns
|
||||
\ccc{false} otherwise.}
|
||||
|
||||
\ccMethod{bool has_neighbor(Full_cell_handle n) const;}{Returns \ccc{true}
|
||||
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 full cell \ccc{n} is a neighbor of the full cell
|
||||
\ccVar. Returns \ccc{false} otherwise.}
|
||||
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check}
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose=false) const;}{
|
||||
Performs some validity checks on the full cell \ccVar.
|
||||
|
||||
It must \emph{at least} check that for each \emph{existing} neighbor \ccc{n},
|
||||
\ccVar\ is also a neighbor of \ccc{n}.
|
||||
|
||||
Returns \ccc{true} if all the tests pass, \ccc{false} if any test fails. See
|
||||
the documentation for the models of this concept to see the additionnal (if
|
||||
any) validity checks that they implement.%
|
||||
}
|
||||
\end{ccDebug}
|
||||
|
||||
\ccHeading{Memory management}
|
||||
|
||||
% \ccMethod{void* for_compact_container() const;}{}
|
||||
% \ccGlue\ccMethod{void* & for_compact_container();}{}
|
||||
|
||||
% These member functions are required by the classes
|
||||
% \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.
|
||||
|
||||
\ccMethod{void * for_compact_container() const;}{}
|
||||
\ccGlue
|
||||
\ccMethod{void * & for_compact_container();}{}
|
||||
{ These member functions are required by \ccc{Triangulation_data_structure}
|
||||
because it uses \ccc{Compact_container} to store its cells. See the
|
||||
documentation of \ccc{Compact_container} for the exact requirements.}
|
||||
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
These operators can be used directly and are called by the I/O
|
||||
operator of class \ccc{TriangulationDataStructure}.
|
||||
|
||||
\ccFunction{template<class TriangulationDataStructure> istream& operator>>(istream & is,
|
||||
Triangulation_ds_full_cell<TriangulationDataStructure> & c);}
|
||||
{Reads (possibly) non-combinatorial information about a full cell from the stream \ccc{is}
|
||||
into \ccc{c}.}
|
||||
|
||||
\ccFunction{template<class TriangulationDataStructure> ostream& operator<<(ostream & os, const
|
||||
Triangulation_ds_full_cell<TriangulationDataStructure> & c);}
|
||||
{Writes (possibly) non-combinatorial information about full cell \ccc{c} to the stream
|
||||
\ccc{os}.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationDSVertex}\\
|
||||
\ccc{TriangulationDSFace}\\
|
||||
\ccc{TriangulationDataStructure}\\
|
||||
\ccc{Triangulation}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,113 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationDSVertex}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ describes what a vertex is in a model of the concept
|
||||
\ccc{TriangulationDataStructure}. It sets requirements of combinatorial nature
|
||||
only, as geometry is not concerned here. In particular, we only require that
|
||||
the vertex holds a handle to a full cell incident to it in the triangulation.
|
||||
|
||||
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Triangulation_ds_vertex<TriangulationDataStructure>}\\
|
||||
\ccc{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
|
||||
|
||||
\ccTypes
|
||||
\ccThree{Full_cell_handle}{v. set_full_cell(Full_cell_handle c);}{}
|
||||
\ccThreeToTwo
|
||||
|
||||
\ccNestedType{Full_cell_handle}{A handle to a cell. It must be the same as 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 class has to define a type \ccc{Other} which is the
|
||||
{\it rebound} vertex, that is, the one whose \ccc{Triangulation_data_structure}
|
||||
will be the actually used one. The \ccc{Other} type will be the real base
|
||||
class of \ccc{Triangulation_data_structure::Vertex}.}
|
||||
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{v}
|
||||
|
||||
\ccConstructor{TriangulationDSVertex();}{The default constructor (no incident
|
||||
full cell is set).}
|
||||
\ccGlue
|
||||
\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
|
||||
\ccThree{Full_cell_handle}{v. set_full_cell(Full_cell_handle c);}{}
|
||||
|
||||
\ccMethod{void set_full_cell(Full_cell_handle c);}{Set \ccc{c} as the vertex's
|
||||
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
|
||||
full cell incident to the vertex.}
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check}
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose=false) const;}{%
|
||||
Performs some validity checks on the vertex \ccVar.
|
||||
|
||||
It must \emph{at least} check that \ccVar\ has an incident full cell, which in
|
||||
turn must contain \ccVar\ as one of its vertices.
|
||||
|
||||
Returns \ccc{true} if all the tests pass, \ccc{false} if any test fails. See
|
||||
the documentation for the models of this concept to see the additionnal (if
|
||||
any) validity checks that they implement.%
|
||||
}
|
||||
|
||||
\end{ccDebug}
|
||||
|
||||
% \ccHeading{Memory management}
|
||||
|
||||
% \ccMethod{void* for_compact_container() const;}{}
|
||||
% \ccGlue\ccMethod{void* & for_compact_container();}{}
|
||||
|
||||
% These member functions are required by the classes
|
||||
% \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
|
||||
% full cells. See the documentation of \ccc{Compact_container} for the exact
|
||||
% requirements.
|
||||
|
||||
\ccHeading{Memory management}
|
||||
|
||||
\ccMethod{void * for_compact_container() const;}{}
|
||||
\ccGlue
|
||||
\ccMethod{void * & for_compact_container();}{}
|
||||
{ These member functions are required by \ccc{Triangulation_data_structure}
|
||||
because it uses \ccc{Compact_container} to store its cells. See the
|
||||
documentation of \ccc{Compact_container} for the exact requirements.}
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
|
||||
These operators can be used directly and are called by the I/O
|
||||
operator of class \ccc{TriangulationDataStructure}.
|
||||
|
||||
\ccFunction{template<class TriangulationDataStructure> istream& operator>>(istream & is,
|
||||
Triangulation_ds_vertex<TriangulationDataStructure> & v);}
|
||||
{Reads (possibly) non-combinatorial information about a vertex from the stream \ccc{is}
|
||||
into \ccc{v}.}
|
||||
|
||||
\ccFunction{template<class TriangulationDataStructure> ostream& operator<<(ostream & os, const
|
||||
Triangulation_ds_vertex<TriangulationDataStructure> & v);}
|
||||
{Writes (possibly) non-combinatorial information about vertex \ccc{v} to the stream
|
||||
\ccc{os}.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationDSFullCell}\\
|
||||
\ccc{TriangulationDSFace}\\
|
||||
\ccc{TriangulationDataStructure}\\
|
||||
\ccc{Triangulation}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,616 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationDataStructure}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The \ccRefName\ concept describes objects responsible for storing and
|
||||
maintaining the combinatorial part of a
|
||||
$\cd$-dimensional pure simplicial complex (all simplices that are not
|
||||
sub-faces of another have the same dimension $\cd$).
|
||||
Its topology is the topology
|
||||
of the sphere $\sphere^\cd$ with $d\in[-2,\ad]$.
|
||||
%possibly of another $\cd$-dimensional manifold without boundary
|
||||
%(that can be embedded in a higher dimension).
|
||||
In a pure (or homogeneous) simplicial $\cd$-complex, all
|
||||
faces are sub-faces of some $\cd$-simplex. (A
|
||||
simplex is also a face of itself.) In particular, it does not
|
||||
contain any $\cd+1$-face, and any $\cd-1$-face belongs to exactly
|
||||
two $\cd$-dimensional {full cells}.
|
||||
|
||||
Values of $\cd$ (the \emph{current dimension} of the complex) include \begin{itemize}
|
||||
|
||||
\item[-2] This corresponds to the non-existence of any object in
|
||||
the triangulation.
|
||||
|
||||
\item[-1] This corresponds to a single vertex and a single full cell,
|
||||
which is also the unique vertex and the unique full cell in the
|
||||
\ccc{TriangulationDataStructure}.
|
||||
In a
|
||||
geometric realization of the \ccRefName\ (\emph{e.g.}, in a
|
||||
\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 full cells being neighbor of each other. This is the unique
|
||||
triangulation of the $0$-sphere.
|
||||
|
||||
\item[$\cd>0$] This corresponds to a standard triangulation of the sphere
|
||||
$\sphere^\cd$.
|
||||
\end{itemize}
|
||||
|
||||
An $i$-simplex is a simplex with $i+1$ vertices. An $i$-simplex $\sigma$ is
|
||||
{incident} to a $j$-simplex $\sigma'$, $j<i$, if and only if $\sigma'$
|
||||
is a proper face of $\sigma$.
|
||||
|
||||
We call a $0$-simplex a {\em vertex}, a $(d-1)$-simplex a {\em facet} and a
|
||||
$d$-simplex a {\em full cell}. A {\em face} can have any dimension.
|
||||
Two full cells are {\em adjacent} if they share a facet. Two faces are
|
||||
{\em incident} if one is included un the other.
|
||||
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
|
||||
|
||||
%\ccTypes
|
||||
%\ccThree{typedef std::pair<Full_cell_handle, int>}{Facet;}{}
|
||||
%\ccThreeToTwo
|
||||
|
||||
\ccNestedType{Vertex}
|
||||
{
|
||||
Vertex type.
|
||||
}
|
||||
\ccGlue
|
||||
\ccNestedType{Full_cell}
|
||||
{
|
||||
Full cell type.
|
||||
}
|
||||
|
||||
The concept \ccRefName\ also defines a type for describing facets of the
|
||||
triangulation with codimension~1:
|
||||
|
||||
|
||||
%\ccThree{typedef std::pair<Full_cell_handle, int>}{Facet;}{}
|
||||
%\ccTypedef{typedef std::pair<Full_cell_handle, int> Facet;}
|
||||
\ccNestedType{Facet}
|
||||
{
|
||||
The constructor \ccc{Facet(c,i)} constructs a \ccc{Facet} representing the facet of
|
||||
full cell \ccc{c} opposite to its \ccc{i}-th vertex. Its dimension is
|
||||
\ccc{current_dimension()-1}.
|
||||
}
|
||||
\ccThreeToTwo
|
||||
|
||||
\ccNestedType{Face}
|
||||
{A model of the concept \ccc{TriangulationDSFace}.}
|
||||
|
||||
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{Full_cell_handle}
|
||||
{
|
||||
Handle to a \ccc{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}
|
||||
{This nested template class allows to get the type of a triangulation
|
||||
data structure that only changes the vertex type. It has to define a type
|
||||
\ccc{Other} which is a {\it rebound} triangulation data structure, that is, the
|
||||
one whose \ccc{TriangulationDSVertexBase} will be \ccc{Vb2}.}
|
||||
\ccGlue
|
||||
\ccNestedType{template <typename Fcb2> struct Rebind_full_cell}
|
||||
{This nested template class allows to get the type of a triangulation
|
||||
data structure that only changes the full cell type. It has to define a type
|
||||
\ccc{Other} which is a {\it rebound} triangulation data structure, that is, the
|
||||
one whose \ccc{TriangulationDSFullCellBase} will be \ccc{Fcb2}.}
|
||||
\end{ccAdvanced}
|
||||
|
||||
|
||||
Vertices, facets and full cells can be iterated over using \emph{iterators}.
|
||||
Iterators support the usual two dereference operators \ccc{operator*} and
|
||||
\ccc{operator->}.
|
||||
|
||||
\ccNestedType{Vertex_iterator}
|
||||
{
|
||||
Iterator over the list of vertices.
|
||||
}
|
||||
\ccGlue
|
||||
\ccNestedType{Full_cell_iterator}
|
||||
{
|
||||
Iterator over the list of full cells.
|
||||
}
|
||||
\ccGlue
|
||||
\ccNestedType{Facet_iterator}
|
||||
{
|
||||
Iterator over the facets of the complex.
|
||||
}
|
||||
|
||||
\ccNestedType{size_type}{Size type (an unsigned integral type)}
|
||||
\ccGlue
|
||||
\ccNestedType{difference_type}{Difference type (a signed integral type)}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{tds}
|
||||
|
||||
\ccConstructor{TriangulationDataStructure(int dim = 0);}{Creates an instance \ccVar\ of
|
||||
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}.
|
||||
The parameter \ccc{dim} can be ignored by the constructor if it is already
|
||||
known at compile-time. Otherwise, the following precondition holds:
|
||||
\ccPrecond \ccc{dim>0}.}
|
||||
|
||||
%\ccOperations
|
||||
|
||||
\ccHeading{Queries} % --------------------------------------------- QUERIES
|
||||
\ccThree{OutputIterator}{tds.number_of_full_cells() const}{}
|
||||
|
||||
\ccMethod{int maximal_dimension() const;} { Returns the maximal dimension of
|
||||
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
|
||||
full dimensional cells stored in the triangulation. It holds that
|
||||
\ccVar.\ccc{current_dimension()=-2} if and only if \ccVar.\ccc{empty()} is
|
||||
\ccc{true}. \ccPostcond the returned value \ccc{d} satisfies
|
||||
$-2\leq d \leq$\ccVar.\ccc{maximal_dimension()}. }
|
||||
|
||||
\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 full cells in the triangulation.}
|
||||
|
||||
\ccMethod{bool is_vertex(const Vertex_handle & v) const;}
|
||||
{Tests whether \ccc{v} is a vertex of the triangulation. }
|
||||
|
||||
\ccMethod{bool is_full_cell(const Full_cell_handle & c) const;}
|
||||
{Tests whether \ccc{c} is a full cell of the triangulation.}
|
||||
|
||||
\ccMethod{template< typename TraversalPredicate, typename OutputIterator >
|
||||
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 criterion. 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 adjacent
|
||||
full cells are also good.\\
|
||||
The argument \ccc{tp} is a predicate that takes as argument a \ccc{Facet}
|
||||
whose defining \ccc{Full_cell} is good. The predicate must return \ccc{true}
|
||||
if the traversal of that \ccc{Facet} leads to a good full cell.\\
|
||||
All the good full cells are output into the last argument \ccc{out}.
|
||||
\ccPrecond \ccc{c!=Full_cell_handle()} and \ccc{tp(c)==true}.
|
||||
}
|
||||
|
||||
\ccMethod{template< typename OutputIterator > OutputIterator
|
||||
incident_full_cells(Vertex_handle v, OutputIterator out) const;}
|
||||
{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 output iterator.
|
||||
\ccPrecond \ccc{v!=Vertex_handle()}.
|
||||
}
|
||||
|
||||
\ccMethod{template< typename OutputIterator > OutputIterator
|
||||
incident_full_cells(const Face & f, OutputIterator out) const;}
|
||||
{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 output iterator.
|
||||
\ccPrecond\ccc{f.full_cell()!=Full_cell_handle()}.
|
||||
}
|
||||
|
||||
\ccMethod{template< typename OutputIterator > OutputIterator
|
||||
star(const Face & f, OutputIterator out) const;}
|
||||
{Insert in \ccc{out} all the full cells that share at least one vertex with the \ccc{Face
|
||||
f}. Returns the output iterator.
|
||||
%\ccPrecond\ccc{f.full_cell()!=Full_cell_handle()}.
|
||||
}
|
||||
|
||||
\ccMethod{template< typename OutputIterator > OutputIterator
|
||||
incident_faces(Vertex_handle v, const int d, OutputIterator
|
||||
out);}{Constructs all the \ccc{Face}s of dimension \ccc{d} incident to
|
||||
\ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}. If \ccc{d
|
||||
>=} \ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
|
||||
constructed.
|
||||
\ccPrecond\ccc{0 < d} and \ccc{v!=Vertex_handle()}.
|
||||
}
|
||||
|
||||
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% Since unused from the moment and usage is not clear, I remove it
|
||||
% for the moment.
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
% \ccMethod{template< typename OutputIterator > OutputIterator
|
||||
% incident_upper_faces(Vertex_handle v, const int d, OutputIterator
|
||||
% 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 {\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
|
||||
% faces of dimension \ccc{d} of the complex.\\ The constructed \ccc{Faces} are
|
||||
% lexicographically ordered (using the vertex order as base
|
||||
% ordering). If
|
||||
% $d\geq$\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
|
||||
% constructed.
|
||||
% \ccPrecond\ccc{0 < d} and \ccc{v!=Vertex_handle()}.
|
||||
% }
|
||||
|
||||
% \ccGlue\ccMethod{template< typename OutputIterator, typename Comparator >
|
||||
% OutputIterator incident_upper_faces(Vertex_handle v, const int d,
|
||||
% OutputIterator out, Comparator cmp);} {Same as above, but uses \ccc{cmp} as
|
||||
% the vertex ordering to define the upper faces.}
|
||||
|
||||
\ccHeading{Accessing the vertices} % --------------------- ACCESS TO VERTICES
|
||||
\ccThree{Vertex_iterator}{tds.number_of_full_cells() const}{}
|
||||
|
||||
\ccMethod{Vertex_handle vertex(Full_cell_handle c, const int i) const;}%{}
|
||||
{ Returns a handle to the \ccc{i}-th \ccc{Vertex} of the \ccc{Full_cell} \ccc{c}.
|
||||
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension()} and \ccc{c!=Full_cell_handle()}.}
|
||||
|
||||
\ccMethod{int mirror_index(Full_cell_handle c, 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{c} as a neighbor of its \ccc{i}-th neighbor.
|
||||
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension}()\\
|
||||
and \ccc{c!=Full_cell_handle()}. }
|
||||
|
||||
\ccMethod{Vertex_handle mirror_vertex(Full_cell_handle c, int i) const;}%{}
|
||||
{Returns the vertex mirror of the \ccc{i}-th vertex of \ccc{c}.
|
||||
Equivalently, returns the vertex of the \ccc{i}-th neighbor of \ccc{c}
|
||||
that is not vertex of \ccc{c}.
|
||||
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension}()\\
|
||||
and \ccc{c!=Full_cell_handle()}. }
|
||||
|
||||
|
||||
\ccMethod{Vertex_iterator vertices_begin();}
|
||||
{
|
||||
The first vertex of \ccVar. User has no control on the order.
|
||||
}
|
||||
\ccGlue
|
||||
\ccMethod{Vertex_iterator vertices_end();}
|
||||
{
|
||||
The beyond vertex of \ccVar.
|
||||
}
|
||||
|
||||
\ccHeading{Accessing the full cells} % ------------------- ACCESS TO CELLS
|
||||
\ccThree{Full_cell_iterator}{tds.number_of_full_cells() const}{}
|
||||
|
||||
\ccMethod{Full_cell_handle full_cell(Vertex_handle v) const;}%{}
|
||||
{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;}%{}
|
||||
{ Returns a \ccc{Full_cell_handle} pointing to the \ccc{Full_cell}
|
||||
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{Full_cell_iterator full_cells_begin();}
|
||||
{
|
||||
The first full cell of \ccVar. User has no control on the order.
|
||||
}
|
||||
\ccGlue
|
||||
\ccMethod{Full_cell_iterator full_cells_end();}
|
||||
{
|
||||
The beyond full cell of \ccVar.
|
||||
}
|
||||
|
||||
\ccHeading{Faces and Facets} % - - - - - - - - - - - - - - - - - - - - FACETS
|
||||
|
||||
\ccMethod{Facet_iterator facets_begin();}
|
||||
{Iterator to the first facet of the triangulation.}
|
||||
\ccGlue
|
||||
\ccMethod{Facet_iterator facets_end();}
|
||||
{Iterator to the beyond facet of the triangulation.}
|
||||
|
||||
\ccMethod{Full_cell_handle full_cell(const Facet & f) const;}
|
||||
{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 full cell \ccc{c=}\ccVar.\ccc{full_cell(f)}
|
||||
which does {not} belong to \ccc{c}.}
|
||||
|
||||
%\begin{ccAdvanced}
|
||||
%
|
||||
%\ccMethod{bool is_boundary_facet(const Facet & f) const;}
|
||||
%{When a subset of the full cells has their \ccc{flags} set to \ccc{1}, this
|
||||
%function returns \ccc{true} when the \ccc{Facet f} is part of the boundary of
|
||||
%that subset, and \ccc{false} otherwise.
|
||||
%\note{OD: bof, ces trucs de flags sont publics ? si oui ils faut qu'ils
|
||||
% soient robustes et documente partout}
|
||||
%\note{SH: Oui, a mon avis, il faut virer cette fonction de la doc.}
|
||||
%}
|
||||
%
|
||||
%\end{ccAdvanced}
|
||||
|
||||
|
||||
\ccHeading{Vertex insertion} % - - - - - - - - - - - - - - - - - - INSERTIONS
|
||||
|
||||
\ccMethod{Vertex_handle insert_in_full_cell(Full_cell_handle c);}
|
||||
{Inserts a new
|
||||
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} (see Figure~\ref{triangulation:fig:insert-full-cell}).
|
||||
\ccPrecond Current dimension is positive and \ccc{c} is a full cell of
|
||||
\ccVar.}
|
||||
|
||||
\begin{figure}[ht]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation_ref/fig/insert-in-cell.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<img border=0 src="./fig/insert-in-cell.png" align="middle" alt="The effect of insert_in_full_cell()">
|
||||
</center>
|
||||
\end{ccHtmlOnly}
|
||||
\caption{Insertion in a full cell, $\cd=2$\label{triangulation:fig:insert-full-cell}}
|
||||
\end{figure}
|
||||
|
||||
\ccMethod{Vertex_handle insert_in_face(const Face & f);}
|
||||
{Inserts a vertex in the triangulation data structure by subdividing the
|
||||
\ccc{Face f}. Returns a handle to the newly created \ccc{Vertex} (see
|
||||
Figure below~\ref{triangulation:fig:insert-face}).}
|
||||
|
||||
\begin{figure}[ht]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation_ref/fig/insert-in-face.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<img border=0 src="./fig/insert-in-face.png" align="middle" alt="The effect of insert_in_face()">
|
||||
</center>
|
||||
\end{ccHtmlOnly}
|
||||
\caption{Insertion in face, $\cd=3$\label{triangulation:fig:insert-face}}
|
||||
\end{figure}
|
||||
|
||||
\ccMethod{Vertex_handle insert_in_facet(const Facet & ft);}
|
||||
{Inserts a vertex in the triangulation data structure by subdividing the
|
||||
\ccc{Facet ft}. Returns a handle to the newly created \ccc{Vertex}.}
|
||||
|
||||
|
||||
|
||||
\ccMethod{template< class ForwardIterator > Vertex_handle
|
||||
insert_in_hole(ForwardIterator start, ForwardIterator end, Facet f);}{The
|
||||
full cells in the range $C=$\ccc{[start, end)} are removed, thus
|
||||
forming a hole $H$.
|
||||
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
|
||||
(see Figure~\ref{triangulation:fig:insert-hole}).
|
||||
\ccPrecond
|
||||
\ccc{c} belongs to $C$ and \ccc{c->neighbor(i)}
|
||||
does not, with \ccc{f=(c,i)}.
|
||||
$H$ the union of full cells in $C$ is simply connected and its
|
||||
boundary $\partial H$ is a
|
||||
combinatorial triangulation of the sphere $\sphere^{d-1}$.
|
||||
All vertices of the triangulation are on $\partial H$.
|
||||
}
|
||||
\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 full cells are
|
||||
appended to the \ccc{out} output iterator.}
|
||||
|
||||
\begin{figure}[ht]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation_ref/fig/insert-in-hole.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<img border=0 src="./fig/insert-in-hole.png" align="middle" alt="The effect of insert_in_hole()">
|
||||
</center>
|
||||
\end{ccHtmlOnly}
|
||||
\caption{Insertion in a hole, $\cd=2$\label{triangulation:fig:insert-hole}}
|
||||
\end{figure}
|
||||
|
||||
\ccMethod{Vertex_handle insert_increase_dimension(Vertex_handle star);}
|
||||
{Transforms a triangulation of the sphere $\sphere^d$ into the
|
||||
triangulation of the sphere $\sphere^{d+1}$ by adding a new vertex
|
||||
\ccc{v}.
|
||||
\ccc{v} is used to triangulate one of the two half-spheres of
|
||||
$\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 full cells that do not already have 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 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
|
||||
(see Figure~\ref{triangulation:fig:insert-increase-dim}).
|
||||
\ccPrecond\ccVar.
|
||||
If the current dimension is -2 (empty triangulation), then \ccc{star}
|
||||
has to be omitted, otherwise
|
||||
the current dimension must be strictly less than the maximal dimension
|
||||
and \ccc{star} must be a vertex of \ccVar.}
|
||||
|
||||
\begin{figure}[ht]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation_ref/fig/insert-increase-dim.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<img border=0 src="./fig/insert-increase-dim.png" align="middle" alt="The effect of insert_increase_dimension()">
|
||||
</center>
|
||||
\end{ccHtmlOnly}
|
||||
\caption{Insertion, increasing the dimension from $\cd=1$ to $\cd=2$\label{triangulation:fig:insert-increase-dim}}
|
||||
\end{figure}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
|
||||
\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 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 full cell of \ccc{v}.}
|
||||
|
||||
\ccMethod{void set_neighbors(Full_cell_handle ci, int i, Full_cell_handle cj, int
|
||||
j);}
|
||||
{Sets the neighbor opposite to vertex \ccc{i} of \ccc{Full_cell} \ccc{ci} to
|
||||
\ccc{cj}. Sets the neighbor opposite to vertex \ccc{j} of \ccc{Full_cell}
|
||||
\ccc{cj} to \ccc{ci}.}
|
||||
|
||||
\ccMethod{void set_current_dimension(int d);} { Forces the current dimension
|
||||
of the complex to \ccc{d}.
|
||||
\ccPrecond $-1\leq d\leq$\ccc{maximal_dimension()}.}
|
||||
|
||||
\end{ccAdvanced}
|
||||
|
||||
\ccHeading{Vertex removal} % - - - - - - - - - - - - - - - - - - - - REMOVALS
|
||||
|
||||
\ccMethod{void clear();}
|
||||
{Reinitializes \ccVar\ to the empty complex.}
|
||||
|
||||
\ccMethod{Vertex_handle collapse_face(const Face & f);} {Contracts the
|
||||
\ccc{Face f} to a single vertex. Returns a handle to that vertex
|
||||
(see Figure~\ref{triangulation:fig:collapse-face}).
|
||||
\ccPrecond
|
||||
The boundary of the full cells incident to \ccc{f}
|
||||
is a topological sphere of dimension
|
||||
\ccVar.\ccc{current_dimension()}-1).
|
||||
}
|
||||
|
||||
\begin{figure}[ht]
|
||||
\begin{ccTexOnly}
|
||||
\begin{center}
|
||||
\includegraphics{Triangulation_ref/fig/collapse-face.pdf}
|
||||
\end{center}
|
||||
\end{ccTexOnly}
|
||||
\begin{ccHtmlOnly}
|
||||
<center>
|
||||
<img border=0 src="./fig/collapse-face.png" align="middle" alt="The effect of collapse_face()">
|
||||
</center>
|
||||
\end{ccHtmlOnly}
|
||||
\caption{Collapsing an edge in dimension $\cd=3$, \ccc{v} is returned\label{triangulation:fig:collapse-face}}
|
||||
\end{figure}
|
||||
|
||||
\ccMethod{void remove_decrease_dimension(Vertex_handle v, Vertex_handle
|
||||
star);} {This method does exactly the opposite of
|
||||
\ccc{insert_increase_dimension()}:
|
||||
\ccc{v} is removed,
|
||||
full cells not containing \ccc{star} are removed
|
||||
full cells containing \ccc{star} but not \ccc{v} loose vertex \ccc{star}
|
||||
full cells containing \ccc{star} and \ccc{v} loose vertex \ccc{v}
|
||||
(see Figure~\ref{triangulation:fig:insert-increase-dim}).
|
||||
\ccPrecond
|
||||
All cells contains either \ccc{star} or \ccc{v}.
|
||||
Edge \ccc{star-v} exists in the triangulation
|
||||
and \ccc{current_dimension()!=2}.
|
||||
}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
\ccMethod{void delete_vertex(Vertex_handle v);}
|
||||
{Remove the vertex \ccc{v} from the triangulation.
|
||||
%This does not take care of
|
||||
%erasing the references to \ccc{v} in other parts of the triangulation.
|
||||
}
|
||||
|
||||
\ccMethod{void delete_full_cell(Full_cell_handle c);}
|
||||
{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 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}
|
||||
|
||||
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check} % - - - - - - - - - - - - - - - - - - - - VALIDITY
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose=false) const;}{%
|
||||
Partially checks whether \ccVar\ is indeed a triangulation.
|
||||
|
||||
It must \emph{at least}\begin{itemize}
|
||||
\item check the validity of the vertices and full cells of \ccVar\ by calling
|
||||
their respective \ccc{is_valid} method.
|
||||
\item check that each full cell has no duplicate vertices and has as many
|
||||
neighbors as its number of facets (\ccc{current_dimension()+1}).
|
||||
\item check that each full cell share exactly \ccVar.\ccc{current_dimension()}
|
||||
vertices with each of its neighbor.
|
||||
\end{itemize}
|
||||
|
||||
Returns \ccc{true} if all the tests pass, \ccc{false} if any test fails. See
|
||||
the documentation for the models of this concept to see the additionnal (if
|
||||
any) validity checks that they implement.%
|
||||
}
|
||||
|
||||
\end{ccDebug}
|
||||
|
||||
|
||||
\ccHeading{Input/Output} % ---------------------------- I/O
|
||||
|
||||
\ccFunction{istream & operator>>(istream & is, TriangulationDataStructure &
|
||||
tds);}
|
||||
{Reads a combinatorial triangulation from \ccc{is} and assigns it to
|
||||
\ccc{tds}. \ccPrecond The dimension of the input complex must be less than or
|
||||
equal to \ccVar.\ccc{maximal_dimension()}.}
|
||||
|
||||
\ccFunction{ostream & operator<<(ostream & os, const TriangulationDataStructure
|
||||
& tds);}
|
||||
{Writes \ccc{tds} into the output stream \ccc{os}}
|
||||
|
||||
The information stored in the \ccc{iostream} is:
|
||||
\\- the current dimension (which must be \ccc{<=}\ccVar.\ccc{maximal_dimension()}),
|
||||
\\- the number of vertices,
|
||||
\\- for each vertex the information of that vertex,
|
||||
\\- the number of full cells,
|
||||
\\- for each full cell the indices of its vertices and extra information for that full cell,
|
||||
\\- for each full cell the indices of its neighbors.
|
||||
|
||||
The indices of vertices and full cells correspond to the order in the
|
||||
file, the user cannot control it.
|
||||
The classes \ccc{Vertex} and
|
||||
\ccc{Full_cell} have to provide the relevant I/O operators
|
||||
(possibly empty).
|
||||
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationDSVertex}\\
|
||||
\ccc{TriangulationDSFullCell}\\
|
||||
\ccc{TriangulationDSFace}\\
|
||||
\ccc{Triangulation}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationFullCell}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ describes the requirements on the type used by the
|
||||
class \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}, and its derived classes, to
|
||||
represent a full cell.
|
||||
|
||||
\ccRefines
|
||||
|
||||
\ccc{TriangulationDSFullCell}
|
||||
|
||||
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 full cell's vertices.
|
||||
% as well as a method for constructing the center of the full cell's circumsphere.
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}
|
||||
|
||||
%\ccTypes
|
||||
|
||||
%\ccNestedType{Point}%
|
||||
%{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<TriangulationTraits, TriangulationDataStructure>}
|
||||
%class.}
|
||||
|
||||
%\ccNestedType{Point_const_iterator}{An iterator over the points of the
|
||||
%full cell.}
|
||||
|
||||
\ccCreationVariable{c}
|
||||
|
||||
%\ccOperations
|
||||
%These operators can be used directly and are called by the I/O
|
||||
%operator of class \ccc{Triangulation}.
|
||||
|
||||
%\ccMethod{Point_const_iterator points_begin() const;}
|
||||
%{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 full cell.}
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
|
||||
These operators can be used directly and are called by the I/O
|
||||
operator of class \ccc{Triangulation}.
|
||||
|
||||
\ccFunction{istream & operator>>(istream & is, TriangulationFullCell & c);}%
|
||||
{Inputs additional information stored in the full cell.}
|
||||
|
||||
\ccFunction{ostream & operator<<(ostream & os, const TriangulationFullCell & c);}%
|
||||
{Outputs additional information stored in the full cell.}
|
||||
|
||||
|
||||
%\ccMethod{Point circumcenter() const;}{Returns the center of the sphere
|
||||
%circumscribing the full cell.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}\\
|
||||
\ccc{TriangulationVertex}\\
|
||||
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,180 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationTraits}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ describes the various types and functions that a class
|
||||
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{TriangulationDataStructure}.
|
||||
|
||||
Inserting a range of points in a triangulation is optimized using
|
||||
spatial sorting, thus besides the requirements below,
|
||||
a class provided as \ccc{TriangulationTraits} should also satisfy the concept
|
||||
\ccc{SpatialSortingTraits_d}.
|
||||
|
||||
\ccRefines
|
||||
\ccc{SpatialSortingTraits_d}
|
||||
|
||||
{If a range of points is inserted, the
|
||||
traits must refine \ccc{SpatialSortingTraits_d}, This is not needed
|
||||
if the points are inserted one by one.}
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccTwo{TriangulationTraits ::Compare_lexicographically_d}{}
|
||||
|
||||
\ccNestedType{Dimension}%
|
||||
{A type representing the dimension of the underlying space. it can be static
|
||||
(\ccc{Maximal_dimension}=\ccGlobalScope\ccc{Dimension_tag<int dim>}) or
|
||||
dynamic (\ccc{Maximal_dimension}=\ccGlobalScope\ccc{Dynamic_dimension_tag}).
|
||||
This dimension must match the dimension of the predicate
|
||||
\ccc{Orientation_d} but not necessarily the one of \ccc{Point_d}.
|
||||
}
|
||||
|
||||
\ccNestedType{Point_d}%
|
||||
{A type representing a point in Euclidean space.}
|
||||
|
||||
|
||||
\ccNestedType{Point_dimension_d}%
|
||||
{Functor returning the dimension of a \ccc{Point_d}.
|
||||
Must provide
|
||||
\ccc{int operator()(Point_d p)} returning the dimension of $p$.
|
||||
}
|
||||
|
||||
\ccNestedType{Orientation_d}{A predicate object that must provide the
|
||||
templated operator\\\ccc{template<typename ForwardIterator> Orientation
|
||||
operator()(ForwardIterator start, ForwardIterator end)}.\\The operator returns
|
||||
\ccc{CGAL::POSITIVE}, \ccc{CGAL::NEGATIVE} or \ccc{CGAL::COPLANAR} depending on
|
||||
the orientation of the simplex defined by the points in the range \ccc{[start,
|
||||
end)}.
|
||||
\ccPrecond \ccc{std::distance(start,end)=D+1}, where
|
||||
\ccc{Point_dimension_d(*it)} is $D$ for all \ccc{it} in \ccc{[start,end)}.
|
||||
}
|
||||
|
||||
\ccNestedType{Contained_in_affine_hull_d}{A predicate object that must provide
|
||||
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 {\em affine hull} of the points
|
||||
in the range.
|
||||
\ccPrecond The $k$ points in the range
|
||||
must be affinely independent.
|
||||
\ccc{Point_dimension_d(*it)} is $D$ for all \ccc{it} in
|
||||
\ccc{[start,end)}, for some $D$.
|
||||
$2\leq k\leq D$.
|
||||
}
|
||||
|
||||
|
||||
In the $D$-dimensional oriented space, a $k-1$ dimensional subspace (flat)
|
||||
define by $k$ points can be oriented in two different ways.
|
||||
Choosing the orientation of any simplex defined by $k$ points fix the
|
||||
orientation of all other simplices. To be able to orient lower
|
||||
dimensional flats, we use the following classes:
|
||||
|
||||
|
||||
\ccNestedType{Flat_orientation_d}{
|
||||
A type representing an orientation of an affine subspace of
|
||||
dimension $k$ strictly smaller than the maximal dimension.
|
||||
}
|
||||
|
||||
|
||||
\ccNestedType{Construct_flat_orientation_d}{
|
||||
A construction object that must
|
||||
provide the templated operator\\\ccc{template<typename ForwardIterator> Flat_orientation_d
|
||||
operator()(ForwardIterator start, ForwardIterator end)}.\\
|
||||
The flat spanned by the points in
|
||||
the range \ccc{R=[start, end)} can be oriented in two different ways,
|
||||
the operator
|
||||
returns an object that allow to orient that flat so that \ccc{R=[start, end)}
|
||||
defines a positive simplex.
|
||||
\ccPrecond The $k$ points in the range
|
||||
must be affinely independent.
|
||||
\ccc{Point_dimension_d(*it)} is $D$ for all \ccc{it} in \ccc{R} for
|
||||
some $D$.
|
||||
$2\leq k\leq D$.
|
||||
}
|
||||
|
||||
|
||||
\ccNestedType{In_flat_orientation_d}{
|
||||
A predicate object that must provide the
|
||||
templated operator\\\ccc{template<typename ForwardIterator> Orientation
|
||||
operator()(Flat_orientation_d orient,ForwardIterator start,
|
||||
ForwardIterator end)}.\\
|
||||
The operator returns
|
||||
\ccc{CGAL::POSITIVE}, \ccc{CGAL::NEGATIVE} or \ccc{CGAL::COPLANAR} depending on
|
||||
the orientation of the simplex defined by the points in the range \ccc{[start,
|
||||
end)}.
|
||||
The points are supposed to belong to the lower dimensional flat
|
||||
whose orientation is given by \ccc{orient}.
|
||||
\ccPrecond \ccc{std::distance(start,end)=k} where $k$ is the number of
|
||||
points
|
||||
used to construct \ccc{orient}.
|
||||
\ccc{Point_dimension_d(*it)} is $D$ for all \ccc{it} in
|
||||
\ccc{[start,end)} where $D$ is the dimension of the points used to
|
||||
construct \ccc{orient}.
|
||||
$2\leq k\leq D$.
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
\ccNestedType{Compare_lexicographically_d}{A predicate object that must
|
||||
provide the operator\\\ccc{Comparison_result operator()(const Point_d & p,
|
||||
const Point_d & q)}.\\The operator returns \ccc{SMALLER} if \ccc{p} is
|
||||
lexicographically smaller than point \ccc{q}, \ccc{EQUAL} if both points are
|
||||
the same and \ccc{LARGER} otherwise.}
|
||||
|
||||
%%%%%%% currently unused in the code
|
||||
% \ccNestedType{Affinely_independent_d}{A predicate object that must provide the
|
||||
% templated operator\\\ccc{template<typename ForwardIterator> bool
|
||||
% operator()(ForwardIterator start, ForwardIterator end)}.\\The operator returns
|
||||
% \ccc{true} if and only if the dimension of the affine hull of the points in
|
||||
% the range \ccc{R=[start, end)} is one less than the number of points in
|
||||
% \ccc{R}.}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{traits}
|
||||
|
||||
\ccConstructor{TriangulationTraits();}{The default constructor.}
|
||||
|
||||
\ccOperations
|
||||
\ccThree{Construct_flat_orientation_d}{construct_flat_orientation_d_object() const}{}
|
||||
|
||||
The following methods permit access to the traits class's predicates:
|
||||
|
||||
\ccMethod{Orientation_d orientation_d_object() const;}%
|
||||
{}
|
||||
\ccGlue
|
||||
\ccMethod{Contained_in_affine_hull_d contained_in_affine_hull_d_object()
|
||||
const;}%
|
||||
{}
|
||||
\ccGlue
|
||||
\ccMethod{Construct_flat_orientation_d construct_flat_orientation_d_object() const;}%
|
||||
{}
|
||||
\ccGlue
|
||||
\ccMethod{In_flat_orientation_d in_flat_orientation_d_object() const;}%
|
||||
{}
|
||||
\ccGlue
|
||||
\ccMethod{Compare_lexicographically_d compare_lexicographically_d_object()
|
||||
const;}%
|
||||
{}
|
||||
%\ccGlue
|
||||
%\ccMethod{ Affinely_independent_d affinely_independent_d_object() const;}%
|
||||
%{}
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Cartesian_d<FT, Dim, LA>},\\
|
||||
%\ccc{Simple_cartesian_d<FT, Dim, LA>},\\
|
||||
\ccc{CGAL::????<K>} (recommended).
|
||||
\note{The new kernel is currently under developement}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{DelaunayTriangulationTraits}
|
||||
\ccc{Triangulation}
|
||||
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
\begin{ccRefConcept}{TriangulationVertex}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ describes the requirements on the type used by the
|
||||
class \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}, and its derived classes, to
|
||||
represent a vertex.
|
||||
|
||||
\ccRefines
|
||||
|
||||
\ccc{TriangulationDSVertex}
|
||||
|
||||
We only list below the additional specific requirements of \ccRefName.
|
||||
|
||||
Compared to \ccc{TriangulationDSVertex}, the main difference is the addition of
|
||||
an association of the vertex into a geometric point.
|
||||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
|
||||
|
||||
\ccTypes
|
||||
\ccThree{TriangulationVertex}{v(Full_cell_handle c, const Point & p);}{}
|
||||
\ccThreeToTwo
|
||||
|
||||
\ccNestedType{Point}{The type of the point stored in the vertex. It must be
|
||||
the same as the point type \ccc{TriangulationTraits::Point} (or its refined
|
||||
concepts) when the \ccc{TriangulationVertex} is used in the class
|
||||
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} (or its derived classes).}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{v}
|
||||
|
||||
\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 full cell.}%{ (Who would have guessed?)}
|
||||
|
||||
\ccGlue\ccConstructor{TriangulationVertex();}%
|
||||
{Same as above, but with a default-constructed \ccc{Point}.}
|
||||
|
||||
\ccOperations
|
||||
|
||||
\ccMethod{void set_point(const Point & p);}%
|
||||
{The parameter \ccc{p} becomes the new geometrical position of the vertex.}
|
||||
|
||||
\ccMethod{const Point & point() const;}%
|
||||
{Returns the vertex's position.}
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
|
||||
These operators can be used directly and are called by the I/O
|
||||
operator of class \ccc{Triangulation}.
|
||||
|
||||
\ccFunction{istream & operator>>(istream & is, TriangulationVertex & v);}%
|
||||
{Inputs the non-combinatorial information given by the vertex, {i.e.},
|
||||
the point and other possible information.}
|
||||
|
||||
\ccFunction{ostream & operator<<(ostream & os, const TriangulationVertex & v);}%
|
||||
{Outputs the non-combinatorial information given by the vertex, {i.e.},
|
||||
the point and other possible information.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}\\
|
||||
\ccc{TriangulationFullCell}\\
|
||||
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
|
@ -1,98 +0,0 @@
|
|||
\begin{ccRefClass}{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
|
||||
|
||||
\ccDefinition
|
||||
This class is used for storing the combinatorial information of a triangulation
|
||||
of dimension $k\leq d$.
|
||||
|
||||
\ccInclude{CGAL/Triangulation_data_structure.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
\ccc{Dimensionality} can be either \begin{itemize}
|
||||
|
||||
\item \ccPureGlobalScope\ccc{Dimension_tag<d>} for some integer \ccc{d}. This
|
||||
indicates that the triangulation data structure can store simplices (full cells) of dimension at most
|
||||
\ccc{d}. The maximum dimension \ccc{d} is known by the compiler, which
|
||||
triggers some optimizations. Or
|
||||
|
||||
\item \ccPureGlobalScope\ccc{Dynamic_dimension_tag}. In this case, the maximum
|
||||
dimension of the simplices (full cells) is passed as an integer argument to an instance
|
||||
constructor (see \ccc{TriangulationDataStructure}).\end{itemize}
|
||||
|
||||
\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\ can be
|
||||
defined by specifying
|
||||
only the first parameter. It also accepts the tag \ccc{CGAL::Default} as
|
||||
second parameter. In both cases, \ccc{TriangulationDSVertex} defaults to
|
||||
\ccc{CGAL::Triangulation_ds_vertex<>}.
|
||||
|
||||
|
||||
\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{TriangulationDSFullCell} defaults to
|
||||
\ccc{CGAL::Triangulation_ds_full_cell<>}.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
\ccc{TriangulationDataStructure}.
|
||||
|
||||
In addition, the class \ccRefName\ provides the following types and methods:
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{t}
|
||||
|
||||
\ccConstructor{XXXXXXX(const Triangulation_data_structure & t2);}
|
||||
{The copy constructor. Creates a copy of the \ccRefName\ \ccc{t2} passed as
|
||||
argument. All vertices and full cells are duplicated.}
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check} % - - - - - - - - - - - - - - - - - - - - VALIDITY
|
||||
|
||||
The \ccc{is_valid} method is only minimally defined in the
|
||||
\ccc{TriangulationDataStructure} concept, so that we document it more precisely
|
||||
here, for the model \ccRefName:
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose = true) const;}{%
|
||||
Implements the validity checks required by the concept
|
||||
\ccc{TriangulationDataStructure}.%
|
||||
|
||||
Note that passing all these tests does not guaranty that we have a
|
||||
triangulation (abstract pure simplicial complex).%
|
||||
}
|
||||
|
||||
\end{ccDebug}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
|
||||
\ccTypes
|
||||
|
||||
\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.}
|
||||
|
||||
\ccHeading{Vertex insertion} % - - - - - - - - - - - - - - - - - - INSERTIONS
|
||||
|
||||
\ccMethod{template< OutputIterator > Full_cell_handle insert_in_tagged_hole(
|
||||
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 full cells from vertex \ccc{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()}.
|
||||
\ccPrecond same as \ccRefName\ccc{::insert_in_hole()}
|
||||
}
|
||||
|
||||
\end{ccAdvanced}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_ds_vertex}\\
|
||||
\ccc{Triangulation_ds_full_cell}\\
|
||||
\ccc{Triangulation}
|
||||
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
\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, TriangulationDSVertex,
|
||||
TriangulationDSFullCell>}.
|
||||
|
||||
This class does not provide any geometric capabilities but only combinatorial
|
||||
(adjacency) information. Thus, if the \ccc{Triangulation_data_structure} is
|
||||
used as a parameter of an (embedded) \ccc{Triangulation}, then its full cell template
|
||||
parameter has to fulfill additional geometric requirements, i.e. it has to be
|
||||
a model of the refined concept \ccc{TriangulationFullCell}.
|
||||
|
||||
This class can be used directly or can serve as a base to derive other classes
|
||||
with some additional attributes tuned for a specific application.
|
||||
|
||||
\ccInclude{CGAL/Triangulation_ds_full_cell.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
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.
|
||||
|
||||
The second parameter, \ccc{TDSFullCellStoragePolicy}, indicates whether or not
|
||||
the full cell should additionally store the mirror indices (the indices
|
||||
of the mirror vertices). This improves speed a little, but takes
|
||||
more space:
|
||||
|
||||
The class template \ccRefName\ accepts that no second parameter be specified.
|
||||
It also accepts the tag \ccc{CGAL::Default} as second parameter. Both cases are
|
||||
equivalent to setting \ccc{TDSFullCellStoragePolicy} to
|
||||
\ccc{CGAL::TDS_full_cell_default_storage_policy}.
|
||||
|
||||
When the second parameter is specified, its possible ``values''
|
||||
are:\begin{itemize}
|
||||
|
||||
\item \ccc{CGAL::Default}, which is the {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 {not stored}.
|
||||
|
||||
\item \ccc{CGAL::TDS_full_cell_mirror_storage_policy}. In that case, the mirror
|
||||
indices are stored.
|
||||
\end{itemize}
|
||||
See the user manual for how to choose the second option.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
\ccc{TriangulationDSFullCell}
|
||||
|
||||
\ccCreationVariable{c}
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check}
|
||||
|
||||
The \ccc{is_valid} method is only minimally defined in the
|
||||
\ccc{TriangulationDSFullCell} concept, so that we document it more precisely
|
||||
here, for the model \ccRefName:
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose=false) const;}{
|
||||
Implements the validity checks required by the concept
|
||||
\ccc{TriangulationDSFullCell}. In addition, it is checked that there is no
|
||||
\ccc{NULL} handle to vertices in the middle of non-\ccc{NULL} ones, that is,
|
||||
that the internal memory layout is not corrupted.%
|
||||
}
|
||||
\end{ccDebug}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
\ccHeading{Rebind mechanism}
|
||||
In case of derivation from that class, the nested class
|
||||
\ccc{Rebind_TDS} need to be provided in the derived class.
|
||||
\end{ccAdvanced}
|
||||
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_ds_vertex<TriangulationDataStructure>}\\
|
||||
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>>}
|
||||
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
\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, TriangulationDSVertex,
|
||||
TriangulationDSFullCell>}.
|
||||
|
||||
This class does not contain any geometric information but only combinatorial
|
||||
(adjacency) information. Thus, if the \ccc{Triangulation_data_structure} is
|
||||
used as a parameter of a (embedded) \ccc{Triangulation}, then its vertex template parameter
|
||||
has to fulfill additional geometric requirements, {i.e.}, it has to be a
|
||||
model of the refined concept \ccc{TriangulationVertex}.
|
||||
|
||||
This class can be used directly or can serve as a base to derive other classes
|
||||
with some additional attributes tuned for a specific application (a color for
|
||||
example).
|
||||
|
||||
\ccInclude{CGAL/Triangulation_ds_vertex.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
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.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
\ccc{TriangulationDSVertex}
|
||||
|
||||
\ccCreationVariable{v}
|
||||
|
||||
\begin{ccDebug}
|
||||
\ccHeading{Validity check}
|
||||
|
||||
The \ccc{is_valid} method is only minimally defined in the
|
||||
\ccc{TriangulationDSVertex} concept, so that we document it more precisely
|
||||
here, for the model \ccRefName:
|
||||
|
||||
\ccMethod{bool is_valid(bool verbose=false) const;}{%
|
||||
Implements the validity checks required by the concept
|
||||
\ccc{TriangulationDSVertex}. Does not implement additional checks.%
|
||||
}
|
||||
\end{ccDebug}
|
||||
|
||||
\begin{ccAdvanced}
|
||||
\ccHeading{Rebind mechanism}
|
||||
In case of derivation from that class, the nested class
|
||||
\ccc{Rebind_TDS} need to be provided in the derived class.
|
||||
\end{ccAdvanced}
|
||||
|
||||
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_ds_full_cell<TriangulationDataStructure, TDSFullCellStoragePolicy>}\\
|
||||
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>>}
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
\begin{ccRefClass}{Triangulation_face<TriangulationDataStructure>}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
A \ccRefName\ is a model of the concept \ccc{TriangulationDSFace}.
|
||||
|
||||
\ccParameters
|
||||
|
||||
Parameter \ccc{TriangulationDataStructure} must be a model of the concept
|
||||
\ccc{TriangulationDataStructure}.
|
||||
Actually, \ccRefName\ needs only that this concept defines the types
|
||||
\ccc{Full_cell_handle},
|
||||
\ccc{Vertex_handle}, and
|
||||
\ccc{Maximal_dimension}.
|
||||
|
||||
% FUTURE: Do we create a \ccc{ProtoComplex} concept?
|
||||
|
||||
\ccIsModel
|
||||
|
||||
\ccc{TriangulationDSFace}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{TriangulationDSFace}\\
|
||||
\ccc{TriangulationDataStructure}
|
||||
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
\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<TriangulationTraits, TriangulationDataStructure>}.
|
||||
|
||||
A \ccRefName\ stores handles to the vertices of the cell as well as handles
|
||||
to its adjacent cells.
|
||||
|
||||
\ccInclude{CGAL/Triangulation_full_cell.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
\ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. It
|
||||
provides geometric types and predicates for use in the
|
||||
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} class.
|
||||
|
||||
\ccc{Data} is an optional type of data to be stored in the full cell 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{CGAL::No_full_cell_data} can explicitely be specified to access the third parameter.
|
||||
|
||||
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{TriangulationDSFullCell} defaults to \ccc{CGAL::Triangulation_ds_full_cell<>}.
|
||||
|
||||
\ccInheritsFrom
|
||||
|
||||
\ccc{TriangulationDSFullCell} (the third template parameter)
|
||||
|
||||
\ccIsModel
|
||||
|
||||
\ccc{TriangulationFullCell}
|
||||
|
||||
Additionally, the class \ccRefName\ also provides the following type,
|
||||
constructors and methods:
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccTypedef{typedef Data Data;}{The type of the additional data stored in the
|
||||
cell. If you read a \ccRefName\ from a stream (a file) or write a \ccRefName
|
||||
to a stream, then streaming operators \ccc{<<} and \ccc{>>} must be provided for this
|
||||
type.}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{c}
|
||||
|
||||
\ccConstructor{template< typename T> Triangulation_full_cell(int dmax, const T
|
||||
& t);}{Sets the maximum possible dimension of the cell to \ccc{dmax}.
|
||||
The parameter \ccc{t} is passed to the \ccc{Data} constructor.}
|
||||
|
||||
\ccHeading{Data access}
|
||||
|
||||
\ccMethod{const Data & data() const;}{Returns a const reference to the stored data.}
|
||||
\ccGlue\ccMethod{Data & data();}{Returns a non-const reference to the stored data.}
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
|
||||
\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
|
||||
{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
|
||||
{also} written.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}\\
|
||||
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}\\
|
||||
\ccc{Triangulation<TriangulationTraits,TriangulationDataStructure>}\\
|
||||
\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
|
||||
\end{ccRefClass}
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
\ccModifierCrossRefOff
|
||||
\begin{ccRefEnum}[Triangulation::]{Locate_type}
|
||||
|
||||
\ccDefinition
|
||||
|
||||
The enum \ccRefName\ is defined by the class \ccc{Triangulation} to specify
|
||||
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};}
|
||||
{}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{CGAL::Triangulation}
|
||||
|
||||
\end{ccRefEnum}
|
||||
\ccModifierCrossRefOn
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
\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<TriangulationTraits, TriangulationDataStructure>}.
|
||||
|
||||
A \ccRefName\ stores a point and an incident full cell.
|
||||
|
||||
\ccInclude{CGAL/Triangulation_vertex.h}
|
||||
|
||||
\ccParameters
|
||||
|
||||
\ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. It
|
||||
provides geometric types and predicates for use in the
|
||||
\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{CGAL::No_vertex_data} can be explicitely specified to allow to access the
|
||||
third parameter.
|
||||
|
||||
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{TriangulationDSVertex} defaults to \ccc{CGAL::Triangulation_ds_vertex<>}.
|
||||
|
||||
\ccInheritsFrom
|
||||
|
||||
\ccc{TriangulationDSVertex} (the third template parameter)
|
||||
|
||||
\ccIsModel
|
||||
|
||||
\ccc{TriangulationVertex}
|
||||
|
||||
Additionally, the class \ccRefName\ also provides the following type,
|
||||
constructors and methods:
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccTypedef{typedef Data Data;}{The type of the additional data stored in the
|
||||
vertex. If you read a \ccRefName\ from a stream (a file) or write a \ccRefName
|
||||
to a stream, then streaming operators \ccc{<<} and \ccc{>>} must be provided for this
|
||||
type.}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{v}
|
||||
|
||||
\ccConstructor{template< typename T>
|
||||
Triangulation_vertex(Full_cell_handle c,
|
||||
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 full cell.}
|
||||
|
||||
\ccGlue\ccConstructor{Triangulation_vertex();}%
|
||||
{Same as above, but with default-constructed \ccc{Point} and \ccc{Data}.}
|
||||
|
||||
\ccHeading{Data access}
|
||||
|
||||
\ccMethod{const Data & data() const;}{Returns a const reference to the stored data.}
|
||||
\ccGlue\ccMethod{Data & data();}{Returns a non-const reference to the stored data.}
|
||||
|
||||
\ccHeading{Input/Output}
|
||||
|
||||
\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
|
||||
{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
|
||||
{also} written.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}\\
|
||||
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}\\
|
||||
\ccc{Triangulation<TriangulationTraits,TriangulationDataStructure>}\\
|
||||
\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
|
||||
|
||||
\end{ccRefClass}
|
||||
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 34 KiB |
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 28 KiB |
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 64 KiB |
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 30 KiB |
|
|
@ -1,94 +0,0 @@
|
|||
%\RCSdef{\RCSTriangulationRev}{$Id$}
|
||||
%\RCSdefDate{\RCSTriangulationDate}{$Date$}
|
||||
|
||||
\ccRefChapter{Triangulations\label{chap:triangulation_ref}}
|
||||
\ccChapterAuthor{Samuel Hornus \and Olivier Devillers}
|
||||
|
||||
|
||||
A triangulation is a pure simplicial complex, connected and without
|
||||
singularities. Its faces are such that two of them either do not
|
||||
intersect or share a common face.
|
||||
|
||||
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 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
|
||||
full cells by
|
||||
considering that each convex hull facet is incident to an infinite
|
||||
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 full cells that are linked
|
||||
together through incidence and adjacency relations. Each full cell gives
|
||||
access to its incident vertices and to its adjacent
|
||||
full cells. Each vertex gives access to one of its incident full cells.
|
||||
|
||||
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 full cell are also
|
||||
indexed in such a way that the neighbor indexed by $i$
|
||||
is opposite to the vertex with the same index.
|
||||
|
||||
|
||||
|
||||
\section{Reference Pages Sorted by Type}
|
||||
|
||||
\subsection{Concepts}
|
||||
|
||||
\subsubsection*{Triangulation data structure}
|
||||
|
||||
\ccRefConceptPage{TriangulationDataStructure}
|
||||
|
||||
The above concept defines three types,
|
||||
\ccc{Vertex}, \ccc{Full_cell} and \ccc{Face}, that must respectively fulfill the
|
||||
following concepts:
|
||||
|
||||
\ccRefConceptPage{TriangulationDSVertex}\\
|
||||
\ccRefConceptPage{TriangulationDSFullCell}\\
|
||||
\ccRefConceptPage{TriangulationDSFace}
|
||||
|
||||
\subsubsection*{(Geometric) triangulations}
|
||||
|
||||
\ccRefConceptPage{TriangulationTraits}\\
|
||||
\ccRefConceptPage{DelaunayTriangulationTraits}\\
|
||||
%\ccRefConceptPage{RegularTriangulationTraits}
|
||||
|
||||
\ccRefConceptPage{TriangulationVertex}\\
|
||||
\ccRefConceptPage{TriangulationFullCell}
|
||||
|
||||
The latter two concepts are also abbreviated respectively as %\ccc{TriangulationTraits},
|
||||
%\ccc{DelaunayTriangulationTraits},
|
||||
%\ccc{RTTraits},
|
||||
\ccc{TrVertex} and \ccc{TrFullCell}.
|
||||
|
||||
\subsection{Classes}
|
||||
|
||||
\subsubsection*{Triangulation data structure}
|
||||
|
||||
\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<TriangulationDataStructure>}
|
||||
|
||||
\subsubsection*{(Geometric) triangulations}
|
||||
|
||||
\ccRefIdfierPage{CGAL::Triangulation<TriangulationTraits, TriangulationDataStructure>}\\
|
||||
\ccRefIdfierPage{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
|
||||
%\ccRefIdfierPage{CGAL::Regular_triangulation<RCTraits, TriangulationDataStructure>}
|
||||
|
||||
\ccRefIdfierPage{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}\\
|
||||
\ccRefIdfierPage{CGAL::Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
|
||||
|
||||
\subsection{Enums}
|
||||
|
||||
\ccRefIdfierPage{CGAL::Triangulation::Locate_type}
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
|
||||
%\newcommand{\sphere}{\ensuremath{\mathcal S}}
|
||||
|
||||
\input{Triangulation_ref/intro.tex}
|
||||
|
||||
% 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}
|
||||
\input{Triangulation_ref/TriangulationDSFace.tex}
|
||||
|
||||
\input{Triangulation_ref/TriangulationTraits.tex}
|
||||
\input{Triangulation_ref/DelaunayTriangulationTraits.tex}
|
||||
%\input{Triangulation_ref/RegularTriangulationTraits.tex}
|
||||
|
||||
\input{Triangulation_ref/TriangulationVertex.tex}
|
||||
\input{Triangulation_ref/TriangulationFullCell.tex}
|
||||
|
||||
% Classes
|
||||
|
||||
\input{Triangulation_ref/Triangulation_data_structure.tex}
|
||||
|
||||
\input{Triangulation_ref/Triangulation_ds_vertex.tex}
|
||||
\input{Triangulation_ref/Triangulation_ds_full_cell.tex}
|
||||
\input{Triangulation_ref/Triangulation_face.tex}
|
||||
|
||||
\input{Triangulation_ref/Triangulation.tex}
|
||||
\input{Triangulation_ref/Delaunay_triangulation.tex}
|
||||
%\input{Triangulation_ref/Regular_triangulation.tex}
|
||||
|
||||
\input{Triangulation_ref/Triangulation_vertex.tex}
|
||||
\input{Triangulation_ref/Triangulation_full_cell.tex}
|
||||
|
||||
% Enums
|
||||
|
||||
\input{Triangulation_ref/Triangulation_locate_type.tex}
|
||||
|
||||
Loading…
Reference in New Issue