diff --git a/Triangulation/TODO b/Triangulation/TODO index 1db0e7d146a..692271731c5 100644 --- a/Triangulation/TODO +++ b/Triangulation/TODO @@ -1,6 +1,6 @@ -------------------------------------------------- -En lisant les reviews +Problems to be solved from the reviews -------------------------------------------------- example delaunay does not execute properly @@ -11,6 +11,13 @@ put a default value for dim in the constructor check that the perturbation scheme is independant of the order of insertion +Add a template parameter Location_policy + +ambient dim vs max dim + +check all is_valid function, precise in the doc what they are doing. +(do sth like 2/3 d) + diff --git a/Triangulation/doc_tex/Triangulation/fig/simplex-structure.pdf b/Triangulation/doc_tex/Triangulation/fig/simplex-structure.pdf index 0035b3a30cb..a8ce3e61a4b 100644 Binary files a/Triangulation/doc_tex/Triangulation/fig/simplex-structure.pdf and b/Triangulation/doc_tex/Triangulation/fig/simplex-structure.pdf differ diff --git a/Triangulation/doc_tex/Triangulation/fig/simplex-structure.png b/Triangulation/doc_tex/Triangulation/fig/simplex-structure.png index 04d2e9d60c8..d92d9f86889 100644 Binary files a/Triangulation/doc_tex/Triangulation/fig/simplex-structure.png and b/Triangulation/doc_tex/Triangulation/fig/simplex-structure.png differ diff --git a/Triangulation/doc_tex/Triangulation/triangulation.tex b/Triangulation/doc_tex/Triangulation/triangulation.tex index d3f05c35a41..95bddf6a915 100644 --- a/Triangulation/doc_tex/Triangulation/triangulation.tex +++ b/Triangulation/doc_tex/Triangulation/triangulation.tex @@ -4,28 +4,37 @@ \newcommand{\sphere}{\ensuremath{\mathcal S}} \renewcommand{\real}{\ensuremath{\mathbb R}} +This package proposes data structure and algorithms to compute +triangulations of points in any dimensions. +The \ccc{Triangulation_data_structure} allows to store and manipulate the +combinatorial part of a triangulation while the geometric classes +\ccc{Triangulation} and \ccc{DelaunayTriangulation} allows to +compute a (Delaunay) triangulation of a set of points and to maintain +it under insertions (and deletions in the Delaunay case). + + \section{Introduction\label{triangulation:intro}} -A \textbf{finite abstract simplicial complex} is built on a finite set of +A \em{finite abstract simplicial complex} is built on a finite set of vertices $V$ and consists of a collection $S$ of subsets of $V$ such that \centerline{if $s$ is a set of vertices in $S$, then all the subsets of $s$ are also in $S$.} The sets in $S$ (which are subsets of $V$) are called -\textbf{faces} or \textbf{simplices} (the -singular of which is \textbf{simplex}). +\em{faces} or \em{simplices} (the +singular of which is \em{simplex}). % -A simplex $s\in S$ is \textbf{maximal} if it is not a proper subset of some other -set in $S$. The simplicial complex is \textbf{pure} %(or \textbf{homogeneous}) +A simplex $s\in S$ is \em{maximal} if it is not a proper subset of some other +set in $S$. The simplicial complex is \em{pure} %(or \em{homogeneous}) if all the maximal simplices have the same cardinality, i.e., they have the same number of vertices. -In the sequel, we will call these maximal simplices \textbf{(full) cells}. -A \textbf{face} of a simplex is a subset of it. -A \textbf{proper face} of a simplex is a strict subset of it. +In the sequel, we will call these maximal simplices \em{full cells}. +A \em{face} of a simplex is a subset of it. +A \em{proper face} of a simplex is a strict subset of it. If the vertices are embedded into Euclidean space $\real^d$, we deal with -\textbf{finite simplicial complexes} which have slightly different simplices +\em{finite simplicial complexes} which have slightly different simplices and additional requirements: \begin{itemize} \item vertices corresponds to points in space. @@ -37,31 +46,35 @@ simplices (the empty set counts). See the \ccAnchor{http://en.wikipedia.org/wiki/Simplicial_complex}{wikipedia entry} for more about simplicial complexes. -This \cgal\ package deals with pure finite simplicial complexes, which -we will simply call in the sequel \textbf{triangulations}. It provides three main classes +This \cgal\ package deals with pure finite simplicial complexes +without boundary, which +we will simply call in the sequel \em{triangulations}. It provides three main classes for creating and manipulating triangulations. The class \ccc{CGAL::Triangulation_data_structure} models an abstract triangulation: vertices in this +TriangulationDSVertex, TriangulationDSFullCell>} models an {\em abstract triangulation}: vertices in this class are not embedded in Euclidean space but are only of combinatorial nature. -The class \ccc{CGAL::Triangulation} embeds an abstract +The class \ccc{CGAL::Triangulation} 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} adds further +The class \ccc{CGAL::Delaunay_triangulation} adds further constraints to a triangulation, in that all its simplices must have the -so-called \textbf{Delaunay} or \textbf{empty-ball} property: the interior of +so-called \em{Delaunay} or \em{empty-ball} property: the interior of a ball circumscribing any simplex (or full cell) must be free from any vertex of the triangulation. The \ccc{CGAL::Delaunay_triangulation} class supports deletion of vertices. -%The class \ccc{CGAL::Regular_triangulation} is a generalization of +%The class \ccc{CGAL::Regular_triangulation} is a generalization of %the Delaunay triangulation. %The rest of this user manual gives more details about these classes and the @@ -81,38 +94,36 @@ affinely independent. If the maximal dimension of a simplex in the triangulation is $d$, we call:\begin{itemize} -\item an $i$-face for some $i\in[0,d]$ a \textbf{face}; -\item a $0$-face a \textbf{vertex}; -\item a $1$-face an \textbf{edge}; -\item a $(d-2)$-face a \textbf{ridge}; -\item a $(d-1)$-face a \textbf{facet}; and -\item a $d$-face a \textbf{full cell}. +\item an $i$-face for some $i\in[0,d]$ a \em{face}; +\item a $0$-face a \em{vertex}; +\item a $1$-face an \em{edge}; +\item a $(d-2)$-face a \em{ridge}; +\item a $(d-1)$-face a \em{facet}; and +\item a $d$-face a \em{full cell}. \end{itemize} -Two faces $\sigma$ and $\sigma'$ are \textbf{incident} if and only if +Two faces $\sigma$ and $\sigma'$ are \em{incident} if and only if $\sigma'$ is a proper sub-face of $\sigma$ or \emph{vice versa}. \section{Triangulation Data Structure\label{triangulation:tds}} -\newcommand{\tds}{\ccc{TDS}} +\newcommand{\tds}{\ccc{TriangulationDataStructure}} \newcommand{\ad}{\ensuremath{D}} \newcommand{\cd}{\ensuremath{d}} In this section, we describe the concept \ccc{TriangulationDataStructure} for which \cgal\ provides one model class: -\ccc{CGAL::Triangulation_data_structure}. For simplicity, we use the abbreviation \tds. +\ccc{CGAL::Triangulation_data_structure}. For simplicity, we use the abbreviation \tds. -A \tds\ cannot represent every abstract pure complex, but rather the -combinatorial nature of a (geometric) triangulation. For example, a facet -may be incident to arbitrarily many simplices in an abstract pure complex, but -to at most two in a \tds\ (and in fact exactly two as we explain below). +A \tds\ can represent an abstract pure complex, +such that any facet is incident to exactly two full cells. -A \tds\ has a property called the \textbf{ambient dimension} which is a +A \tds\ has a property called the \em{ambient dimension} which is a positive integer equal to the maximum dimension a full cell can have. This ambient dimension can be chosen by the user at the creation of a \tds\ and can then be queried using the method \ccc{tds.ambient_dimension()}. -A \tds\ also knows the \textbf{current dimension} of its full cells, +A \tds\ also knows the \em{current dimension} of its full cells, which can be queried with \ccc{tds.current_dimension()}. In the sequel, let us denote the ambient dimension with \ad\ and the current dimension with \cd. It always holds that $-2\leq\cd\leq\ad$ and $0<\ad$. @@ -131,52 +142,53 @@ The special meaning of negative values for $d$ will be explain below. % %% By contrast, in the present \ccc{Triangulation} \cgal\ package, the reference %% dimension of a pure complex (or a pure complex data structure) is its current -%% dimension. This means that, whatever the current dimension is, a full -%% cell is always represented by the \ccc{FullCell} nested type, And a +%% dimension. This means that, whatever the current dimension is, a +%% full cell is always represented by the \ccc{FullCell} nested type, And a %% \ccc{Facet} represents a face of dimension \ccc{current_dimension()-1} -%% \textbf{and not} \ccc{ambient_dimension()-1}. +%% \em{and not} \ccc{ambient_dimension()-1}. \subsubsection{The data structure triangulates $\sphere^\cd$} -In a first approximation, a \tds\ can be viewed as -a \emph{triangulation} of the topological sphere $\sphere^\cd$, +A \tds\ can be viewed as +a {triangulation} of the topological sphere $\sphere^\cd$, i.e., its faces can be embedded to form a partition of -$\sphere^\cd$ into $\cd$-simplices. When a -\tds\ is used as the combinatorial part of a geometric triangulation, one -special vertex of the \tds\ plays the role of the \textbf{vertex at -infinity}; we can consider that the triangulation covers the whole -affine hull of its vertices -using \textbf{infinite} or \textbf{unbounded} cells to fill the space outside the convex -hull of the triangulation's finite vertices. (More details are given in the next section.) +$\sphere^\cd$ into $\cd$-simplices. +% When a +% \tds\ is used as the combinatorial part of a geometric triangulation, one +% special vertex of the \tds\ plays the role of the \em{vertex at +% infinity}; we can consider that the triangulation covers the whole +% affine hull of its vertices +% using \em{infinite} or \em{unbounded} full cells to fill the space outside the convex +% hull of the triangulation's finite vertices. (More details are given in the next section.) -One nice consequence of the above important fact is that a cell has +One nice consequence of the above important fact is that a full cell has always exactly $\cd+1$ neighbors. Two full cells $\sigma$ and $\sigma'$ sharing a facet are called -\textbf{neighbors}. +\em{neighbors}. Possible values of $\cd$ (the \emph{current dimension} of the triangulation) include \begin{itemize} \item[$\cd=-2$] This corresponds to the non-existence of any object in the \tds. -\item[$\cd=-1$] This corresponds to a single vertex and a single cell. In a +\item[$\cd=-1$] This corresponds to a single vertex and a single full cell. In a geometric triangulation, this vertex corresponds to the vertex at infinity. \item[$\cd=0$] This corresponds to two vertices (geometrically, the finite vertex and - the infinite vertex), each corresponding to a cell; -the two cells being neighbors of each other. This is the unique + the infinite vertex), each corresponding to a full cell; +the two full cells being neighbors of each other. This is the unique triangulation of the $0$-sphere. \item[$0<\cd\le\ad$] This corresponds to a standard triangulation of the sphere $\sphere^\cd$. \end{itemize} -% - - - - - - - - - - - - - - - - - - - - - - - - - - - - TDS IMPLEMENTATION +% - - - - - - - - - - - - - - - - - - - - - - - - - - - - T D S IMPLEMENTATION \subsection{The class \ccc{Triangulation_data_structure}\label{triangulation:tds:impl}} We give here some details about the class -\ccc{Triangulation_data_structure} +\ccc{Triangulation_data_structure} implementing the concept \ccc{TriangulationDataStructure}. @@ -192,7 +204,7 @@ Each full cell stores references to its $\cd+1$ vertices and neighbors. Its vertices and neighbors are indexed from $0$ to \cd. The indices of its neighbors have the following meaning: the $i$-th neighbor of $\sigma$ is the unique neighbor of $\sigma$ that does not contain the $i$-th vertex of -$\sigma$; in other words, it is the neighbor of $\sigma$ \textbf{opposite} to +$\sigma$; in other words, it is the neighbor of $\sigma$ \em{opposite} to the $i$-th vertex of $\sigma$. \begin{figure}[htbp] @@ -203,24 +215,25 @@ the $i$-th vertex of $\sigma$. \end{ccTexOnly} \begin{ccHtmlOnly}
-Index the vertices and neighbors of a simplex +
\end{ccHtmlOnly} -\caption{Indexing the vertices and neighbors of a simplex $s$ in +\caption{Indexing the vertices and neighbors of a full cell $c$ in dimension $\cd=2$.} -\label{triangulation:fig:simplex} +\label{triangulation:fig:full-cell} \end{figure} \subsubsection{Instantiating the class template} -The \ccc{Triangulation_data_structure} +The \ccc{Triangulation_data_structure} class template is designed in such a way that its user can choose \begin{itemize} \item the ambient dimension of the triangulation data structure by specifying the \ccc{Dimensionality} template parameter, -\item the type used to represent vertices by specifying the \ccc{TDSVertex} +\item the type used to represent vertices by specifying the \ccc{TriangulationDSVertex} template parameter and -\item the type used to represent simplices by specifying the -\ccc{TDSFullCell} template parameter. +\item the type used to represent full cells by specifying the +\ccc{TriangulationDSFullCell} template parameter. \end{itemize} The last two parameters have default values and are thus not necessary, unless @@ -229,23 +242,23 @@ template). The first template parameter, \ccc{Dimensionality}, must be one of the following: \begin{itemize} \item \ccPureGlobalScope\ccc{Dimension_tag} for some integer \ad. This -indicates that the pure complex can store simplices of dimension at most +indicates that the triangulation can store full cells of dimension at most \ad. The maximum dimension \ad\ is known by the compiler, which triggers some optimizations. \item \ccPureGlobalScope\ccc{Dynamic_dimension_tag}. In this case, the maximum -dimension of the simplices must be passed as an integer argument to an instance +dimension of the full cells must be passed as an integer argument to an instance constructor (see \ccc{TriangulationDataStructure}). \end{itemize} -The \ccc{TDSVertex} and \ccc{TDSFullCell} parameters to the class template +The \ccc{TriangulationDSVertex} and \ccc{TriangulationDSFullCell} parameters to the class template must be models of the concepts \ccc{TriangulationDSVertex} and \ccc{TriangulationDSFullCell} respectively. \cgal\ provides models for these -concepts: \ccc{Triangulation_ds_vertex} and -\ccc{Triangulation_ds_simplex}, which, as one +concepts: \ccc{Triangulation_ds_vertex} and +\ccc{Triangulation_ds_full_cell}, which, as one can see, take the \tds\ as a template parameter in order to get access to some nested types in \tds. -\textbf{This creates a circular dependency}, which we resolve in the same way +\em{This creates a circular dependency}, which we resolve in the same way as in the \cgal\ \ccc{Triangulation_2} and \ccc{Triangulation_3} packages (see Chapters~\ref{chapter-TDS2},~\ref{chapter-Triangulation2},~\ref{chapter-TDS3},~and~\ref{chapter-Triangulation3}). In particular, models of the concepts \ccc{TriangulationDSVertex} and @@ -280,11 +293,11 @@ It is also possible to fix it at run time as in the next example. \subsubsection{Barycentric subdivision} This example provides a function for computing the barycentric subdivision of a -single full cell \ccc{fc} in a triangulation data structure. The other full -cells neighboring \ccc{fc} are automatically subdivided to match the -subdivision of the cell \ccc{fc}. The barycentric subdivision of \ccc{fc} is -obtained by enumerating all the faces of \ccc{fc} in order of decreasing -dimension, from the dimension of~\ccc{fc} to dimension~1, and inserting a new +single full cell \ccc{c} in a triangulation data structure. The other +full cells neighboring \ccc{c} are automatically subdivided to match the +subdivision of the full cell \ccc{c}. The barycentric subdivision of \ccc{c} is +obtained by enumerating all the faces of \ccc{c} in order of decreasing +dimension, from the dimension of~\ccc{c} to dimension~1, and inserting a new vertex in each face. For the enumeration, we use a combinatorial enumerator, which is not documented, but provided in \cgal. @@ -302,7 +315,7 @@ alt="Barycentric subdivision"> \end{ccHtmlOnly} \caption{Barycentric subdivision in dimension $\cd=2$.} -\label{triangulation:fig:simplex} +\label{triangulation:fig:barycentric} \end{figure} \ccIncludeExampleCode{Triangulation/barycentric_subdivision.cpp} @@ -312,41 +325,41 @@ alt="Barycentric subdivision"> \section{Triangulations} -The class \ccc{CGAL::Triangulation} embeds an abstract +The class \ccc{CGAL::Triangulation} embeds an abstract triangulation into Euclidean space. More precisely, it -maintains a triangulation (a partition into pairwise interior-disjoint full -cells) of the convex hull of the points (the embedded vertices) of the +maintains a triangulation (a partition into pairwise interior-disjoint +full cells) of the convex hull of the points (the embedded vertices) of the triangulation, as well as a triangulation of the complement of the convex hull -\textbf{in the affine subspace} spanned by the triangulation's points +\em{in the affine subspace} spanned by the triangulation's points using a special vertex at infinity. Methods are provided for the insertion of points in the triangulation, the contraction of faces, the traversal of various elements of the triangulation as well as the localization of a query point inside the triangulation. -Infinite cells outside the convex hull are each incident to +Infinite full cells outside the convex hull are each incident to a finite facet on the convex hull of the triangulation and to a unique special -\textbf{vertex at infinity}. -%\note{In every infinite cell, the vertex at infinity always has index $0$.} +\em{vertex at infinity}. +%\note{In every infinite full cell, the vertex at infinity always has index $0$.} %\note{SH: the above note this should go in the documentation of the %\ccc{TriangulationDataStructure} concept, or that of the class?} As long as no \emph{advanced} class method is called, it is guaranteed that -all finite cells have positive orientation. The infinite cells are +all finite full cells have positive orientation. The infinite full cells are oriented so that the finite vertices of the triangulation lies on the negative side of -the oriented hyperplane defined by the cell's finite facet. +the oriented hyperplane defined by the full cell's finite facet. % - - - - - - - - - - - - - - - - - - - - - - - - - Triangulation IMPLEMENTATION \subsection{Implementation} -The class \ccc{CGAL::Triangulation} stores a model \ccc{TDS} +The class \ccc{CGAL::Triangulation} stores a model \tds of the concept \ccc{TriangulationDataStructure} which is instantiated with a vertex type that stores a point, and a full cell type that allows the retrieval of the point of its vertices. -The template parameter \ccc{TrTraits} must be a model of the concept +The template parameter \ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits} which provides the geometric \ccc{Point} type as well as various geometric predicates used by the \ccc{Triangulation} class. @@ -361,7 +374,7 @@ random points. In \ccc{STEP 1}, we generate one hundred random points in $\real^5$, which we then insert into a triangulation. In \ccc{STEP 2}, we %have a little fun and ask the triangulation to construct the set of edges -($1$-cells) incident to the vertex at infinity. It is easy to see that +($1$ dimensional faces) incident to the vertex at infinity. It is easy to see that these edges are in bijection with the vertices on the convex hull of the points. This gives us a handy way to count the convex hull vertices. %(Note that @@ -377,15 +390,15 @@ points. This gives us a handy way to count the convex hull vertices. Remember that a triangulation triangulates the convex hull of its vertices. In general position, each -facet of the convex hull is incident to one finite cell and one infinite -cell. In fact there is a bijection between the infinite cells and the +facet of the convex hull is incident to one finite full cell and one infinite +full cell. In fact there is a bijection between the infinite full cells and the facets of the convex hull. If vertices are not in general position, convex hull faces that are not simplices are triangulated. So, in order to traverse the convex hull facets, there are (at least) two possibilities: -The first is to iterate over the cells of the triangulation and check if they +The first is to iterate over the full cells of the triangulation and check if they are infinite or not: \begin{ccExampleCode} @@ -393,11 +406,11 @@ are infinite or not: typedef Triangulation::Full_cell_iterator Full_cell_iterator; typedef Triangulation::Facet Facet; -for( Full_cell_iterator fcit = t.full_cells_begin(); - fcit != t.full_cells_end(); ++fcit ) { - if( ! t.is_infinite(fcit) ) +for( Full_cell_iterator cit = t.full_cells_begin(); + cit != t.full_cells_end(); ++cit ) { + if( ! t.is_infinite(cit) ) continue; - Facet ft(fcit, fcit->index(t.infinite_vertex() ) ); + Facet ft(cit, cit->index(t.infinite_vertex() ) ); ++i;// |ft| is a facet of the convex hull } std::cout << "There are " << i << " facets on the convex hull."<< std::endl;} @@ -405,9 +418,9 @@ std::cout << "There are " << i << " facets on the convex hull."<< std::endl;} \textbf{Remark}: the code example above is not self contained, it can be cut and paste at STEP 2 of {\tt triangulation.cpp} program above. -A second possibility is to ask the triangulation to gather all the cells +A second possibility is to ask the triangulation to gather all the full cells incident to the infinite vertex: they form precisely the set of infinite -cells: +full cells: \begin{ccExampleCode} {int i=0; @@ -431,28 +444,28 @@ std::cout << "There are " << i << " facets on the convex hull."<< std::endl;} be cut and paste at STEP 2 of {\tt triangulation.cpp} program above. One important difference between the two examples above is that the first uses -\emph{little} memory but traverses \emph{all} the cells, while the second -visits \emph{only} the infinite cells but stores handles to them into a +\emph{little} memory but traverses \emph{all} the full cells, while the second +visits \emph{only} the infinite full cells but stores handles to them into a \emph{potentially big} array. % - - - - - - - - - - - - - - - - - - - - - - - - - - - - - DELAUNAY TRIANGULATIONS \section{Delaunay Triangulations}%and regular triangulationes} -The class \ccc{CGAL::Delaunay_triangulation} derives from -\ccc{CGAL::Triangulation} and adds further constraints to a +The class \ccc{CGAL::Delaunay_triangulation} derives from +\ccc{CGAL::Triangulation} and adds further constraints to a triangulation, in that all its full cells must have the so-called -\textbf{Delaunay} or \textbf{empty-ball} property: the interior of the ball +\em{Delaunay} or \em{empty-ball} property: the interior of the ball circumscribing any full cell must be free from any vertex of the triangulation. -The \textbf{circumscribing ball} of a full cell \ccc{fc} is the ball +The \em{circumscribing ball} of a full cell is the ball having all vertices of the full cell on its boundary. In case of degeneracies (co-spherical points) the triangulation is not uniquely defined, note however that the \cgal\ implementation computes a unique triangulation even in these cases. -%The \textbf{circumscribing sphere} of a face \ccc{s} is the smallest sphere +%The \em{circumscribing sphere} of a face \ccc{c} is the smallest sphere %touching all vertices of the face. A triangulation of the convex %hull of a finite point set has the Delaunay (or empty-ball) property if all %its full cells have the Delaunay (or empty-ball) property: @@ -462,11 +475,11 @@ triangulation even in these cases. %interior of its circumscribing sphere. When a new point \ccc{p} is inserted into a Delaunay triangulation, the -finite cells whose circumscribing sphere contain \ccc{p} are said to -\textbf{be in conflict} with point \ccc{p}. The set of cells that are in -conflict with \ccc{p} form the \textbf{conflict zone}. That conflict zone is -augmented with the infinite cells whose finite facet does not lie -anymore on the convex hull of the triangulation (with \ccc{p} added). The cells +finite full cells whose circumscribing sphere contain \ccc{p} are said to +\em{be in conflict} with point \ccc{p}. The set of full cells that are in +conflict with \ccc{p} form the \em{conflict zone}. That conflict zone is +augmented with the infinite full cells whose finite facet does not lie +anymore on the convex hull of the triangulation (with \ccc{p} added). The full cells in the conflict zone are removed, leaving a hole that contains \ccc{p}. That hole is then re-triangulated in a ``star shape'' centered at \ccc{p}. @@ -476,13 +489,13 @@ Delaunay triangulations also support vertex removal. \subsection{Implementation} -The class \ccc{CGAL::Delaunay_triangulation} derives from -\ccc{CGAL::Triangulation}. It thus stores a model \ccc{TDS} of +The class \ccc{CGAL::Delaunay_triangulation} derives from +\ccc{CGAL::Triangulation}. It thus stores a model \tds of the concept \ccc{TriangulationDataStructure} which is instantiated with a vertex type that stores a geometric point, and a full cell type that allows the retrieval of the points of its vertices. -The template parameter \ccc{DTTraits} must be a model of the concept +The template parameter \ccc{DelaunayTriangulationTraits} must be a model of the concept \ccc{DelaunayTriangulationTraits} which provides the geometric \ccc{Point} type as well as various geometric predicates used by the \ccc{Delaunay_triangulation} class. The concept \ccc{DelaunayTriangulationTraits} refines the concept @@ -493,14 +506,14 @@ for the computation of Delaunay triangulations. \subsection{Examples} -\subsubsection{Access to the conflict zone and created cells during point +\subsubsection{Access to the conflict zone and created full cells during point insertion} -When using a cell type containing additional custom information, it may be -useful to get an efficient access to the cells that are going to be erased +When using a full cell type containing additional custom information, it may be +useful to get an efficient access to the full cells that are going to be erased upon the insertion of a new point in the Delaunay triangulation, and to the newly -created cells. The second part of code example below shows how one can have efficient -access to both the conflict zone and the created cells, while still +created full cells. The second part of code example below shows how one can have efficient +access to both the conflict zone and the created full cells, while still retaining an efficient update of the Delaunay triangulation. \ccIncludeExampleCode{Triangulation/delaunay.cpp} diff --git a/Triangulation/doc_tex/Triangulation_ref/DelaunayTriangulationTraits.tex b/Triangulation/doc_tex/Triangulation_ref/DelaunayTriangulationTraits.tex index f70c034c639..c326a1d97df 100644 --- a/Triangulation/doc_tex/Triangulation_ref/DelaunayTriangulationTraits.tex +++ b/Triangulation/doc_tex/Triangulation_ref/DelaunayTriangulationTraits.tex @@ -5,9 +5,9 @@ The concept \ccRefName\ describes the various types and functions that a class has to provide as the first parameter (\ccc{DCTraits}) to the class template -\ccc{Delaunay_triangulation}. It brings the geometric ingredient to +\ccc{Delaunay_triangulation}. It brings the geometric ingredient to the definition of a Delaunay complex, while the combinatorial ingredient is -brought by the second template parameter, \ccc{TDS}. +brought by the second template parameter, \ccc{TriangulationDataStructure}. \ccRefines diff --git a/Triangulation/doc_tex/Triangulation_ref/Delaunay_triangulation.tex b/Triangulation/doc_tex/Triangulation_ref/Delaunay_triangulation.tex index a325a11ff41..487b48090ae 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Delaunay_triangulation.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Delaunay_triangulation.tex @@ -1,4 +1,4 @@ -\begin{ccRefClass}{Delaunay_triangulation} +\begin{ccRefClass}{Delaunay_triangulation} \ccDefinition @@ -14,26 +14,26 @@ means. \ccParameters -\ccc{DTTraits} is the geometric traits class that provides the geometric types -and predicates needed by Delaunay triangulations. \ccc{DTTraits} must be a model of +\ccc{DelaunayTriangulationTraits} is the geometric traits class that provides the geometric types +and predicates needed by Delaunay triangulations. \ccc{DelaunayTriangulationTraits} must be a model of the concept \ccc{DelaunayTriangulationTraits}. -\ccc{TDS} is the class used to store the underlying triangulation data -structure. \ccc{TDS} must be a model of the concept +\ccc{TriangulationDataStructure} is the class used to store the underlying triangulation data +structure. \ccc{TriangulationDataStructure} must be a model of the concept \ccc{TriangulationDataStructure}. The class template \ccRefName\ accepts that no second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as -second parameter. In both cases, \ccc{TDS} defaults to +second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to \ccc{Triangulation_data_structure< - Ambient_dimension::type, - Triangulation_vertex, - Triangulation_full_cell >}. + Ambient_dimension::type, + Triangulation_vertex, + Triangulation_full_cell >}. \ccInheritsFrom -\ccc{Triangulation}. +\ccc{Triangulation}. -The class \ccc{Delaunay_triangulation} inherits all the types -defined in the base class \ccc{Triangulation}. Additionally, it +The class \ccc{Delaunay_triangulation} inherits all the types +defined in the base class \ccc{Triangulation}. Additionally, it defines or overloads the following methods: \ccCreation % - - - - - - - - - - - - - - - - - - - - - - - - - - - CREATION @@ -43,7 +43,7 @@ defines or overloads the following methods: \ccConstructor{Delaunay_triangulation(const int dim, const Geom_traits k = Geom_traits());}{Instantiates a Delaunay triangulation with one vertex (the vertex at infinity). See the description of the inherited nested type -\ccc{Triangulation::Ambient_dimension} for an explanation of +\ccc{Triangulation::Ambient_dimension} for an explanation of the use of the parameter \ccc{dim}. The complex stores a copy of the geometric traits \ccc{k}.} @@ -52,7 +52,7 @@ traits \ccc{k}.} \ccMethod{Full_cell_handle remove(Vertex_handle v);}{Remove the vertex \ccc{v} from the Delaunay triangulation. If the current dimension of the triangulation has not -changed after the removal, then the returned cell \ccc{c} geometrically +changed after the removal, then the returned full cell \ccc{c} geometrically contains the removed vertex \ccc{v} (\ccc{c} can be finite or infinite). Otherwise, the default-constructed \ccc{Full_cell_handle} is returned. \ccPrecond \ccc{v} is a vertex of the triangulation, different from the @@ -62,8 +62,8 @@ Otherwise, the default-constructed \ccc{Full_cell_handle} is returned. % the Delaunay triangulation. If a vertex is found at position \ccc{p}, it is removed % from it, otherwise, the default-constructed \ccc{Full_cell_handle} is returned. % If \ccc{p} is found and if the current dimension of the complex has not -% changed after the removal, then the returned simplex \ccc{s} geometrically -% contains the removed point \ccc{p} (\ccc{s} can be finite or infinite). +% changed after the removal, then the returned full cell \ccc{c} geometrically +% contains the removed point \ccc{p} (\ccc{c} can be finite or infinite). % Otherwise, the default-constructed \ccc{Full_cell_handle} is returned.} % \ccMethod{Full_cell_handle remove(const Point & p, Full_cell_handle hint);}{Same @@ -108,7 +108,8 @@ value of \ccc{lt}:\begin{itemize} \item[\ccc{OUTSIDE_AFFINE_HULL}] Point triangulation. The method \ccVar.\ccc{insert_outside_affine_hull()} is called. \item[\ccc{ON_VERTEX}] The position of the vertex \ccc{v} described by \ccc{f} is set to \ccc{p}. \ccc{v} is returned. \item[Anything else] The point \ccc{p} -is inserted in the conflict zone \textbf{which is assumed} to contain cell +is inserted in the conflict zone \em{which is assumed} to contain +full cell \ccc{c}. (Roughly speaking, the method \ccVar.\ccc{insert_in_conflict_zone()} is called.)\end{itemize} \ccPrecond The parameters \ccc{lt}, \ccc{f}, \ccc{ft} and \ccc{c} must be consistent with the localization of point \ccc{p} in the @@ -133,16 +134,16 @@ must be in conflict with the full cell \ccc{c}.} \ccMethod{bool conflict(const Point & p, Full_cell_const_handle c) const;}{Returns \ccc{true} if and only if the point \ccc{p} is in (Delaunay) -conflict with cell \ccc{c} ({i.e.}, the circumscribing ball of +conflict with full cell \ccc{c} ({i.e.}, the circumscribing ball of $c$ contains $p$ in its interior). } \begin{ccAdvanced} \ccMethod{Facet compute_conflict_zone(const Point & p, const Full_cell_handle c, -OutputIterator out) const;}{Outputs handles to the simplices in confict with -point \ccc{p} into the \ccc{OutputIterator out}. The cell \ccc{c} is used -as a starting point for gathering the cells in conflict with \ccc{p}. +OutputIterator out) const;}{Outputs handles to the full cells in confict with +point \ccc{p} into the \ccc{OutputIterator out}. The full cell \ccc{c} is used +as a starting point for gathering the full cells in conflict with \ccc{p}. \ccPrecond \ccc{c} is in conflict with \ccc{p}.\\ \ccVar.\ccc{current_dimension()}$\geq 2$. } diff --git a/Triangulation/doc_tex/Triangulation_ref/RegularTriangulationTraits.tex b/Triangulation/doc_tex/Triangulation_ref/RegularTriangulationTraits.tex index 1cf0dd39645..ddde754c74d 100644 --- a/Triangulation/doc_tex/Triangulation_ref/RegularTriangulationTraits.tex +++ b/Triangulation/doc_tex/Triangulation_ref/RegularTriangulationTraits.tex @@ -46,7 +46,7 @@ subspace Aff. It is guaranteed that the affine subspace Aff is given a consistent orientation when it is called many times with simplex points (in range \ccc{[start,end)}) living in a same affine subspace.\\ \textbf{Important.} Information about the affine subspace Aff is computed -\textbf{once} and then stored in the predicate class, so it is wise to keep an +\em{once} and then stored in the predicate class, so it is wise to keep an instance of the predicate around as long as one is sure that the affine subspace Aff doesn't change. \ccPrecond \ccc{std::distance(start,end)>=3} and \ccc{std::distance(start,end)<=start->dimension()+1}. The points in range diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation.tex index 444426f6631..50eb1fbb56b 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation.tex @@ -1,36 +1,36 @@ -\begin{ccRefClass}{Triangulation} +\begin{ccRefClass}{Triangulation} \ccDefinition -The class \ccRefName\ is used to store and query the cells and vertices of +The class \ccRefName\ is used to store and query the full cells and vertices of a triangulation embedded in $\real^d$. \ccInclude{CGAL/Triangulation.h} \ccParameters -\ccc{TrTraits} is the geometric traits class that provides the geometric types -and predicates needed by triangulations. \ccc{TrTraits} must be a model of the +\ccc{TriangulationTraits} is the geometric traits class that provides the geometric types +and predicates needed by triangulations. \ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. -\ccc{TDS} is the class used to store the underlying triangulation data -structure. \ccc{TDS} must be a model of the concept +\ccc{TriangulationDataStructure} is the class used to store the underlying triangulation data +structure. \ccc{TriangulationDataStructure} must be a model of the concept \ccc{TriangulationDataStructure}. The class template \ccRefName\ accepts that no second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as -second parameter. In both cases, \ccc{TDS} defaults to -\ccc{Triangulation_data_structure::type, -Triangulation_vertex, Triangulation_full_cell>}. +second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to +\ccc{Triangulation_data_structure::type, +Triangulation_vertex, Triangulation_full_cell>}. \ccTypes %The following types are self-explanatory: % but we are explaining anyway -\ccTypedef{typedef TrTraits Geom_traits;}% +\ccTypedef{typedef TriangulationTraits Geom_traits;}% {The model for the \ccc{TriangulationTraits} concept.} -\ccTypedef{typedef TrTraits::Point_d Point;}{A point in Euclidean space.} +\ccTypedef{typedef TriangulationTraits::Point_d Point;}{A point in Euclidean space.} -\ccTypedef{typedef Ambient_dimension::type +\ccTypedef{typedef Ambient_dimension::type Ambient_dimension;}% {This indicates whether the dimension of the ambient Euclidean space is static (\ccc{Ambient_dimension}=\ccGlobalScope\ccc{Dimension_tag}) or @@ -38,46 +38,40 @@ dynamic (\ccc{Ambient_dimension}=\ccGlobalScope\ccc{Dynamic_dimension_tag}). In the latter case, the \ccc{dim} parameter passed to the class's constructor is used.} -\ccTypedef{typedef TDS Triangulation_ds;}% +\ccTypedef{typedef TriangulationDataStructure Triangulation_ds;}% {The second template parameter.} -\ccTypedef{typedef TDS::Vertex Vertex;}{A model of the concept +\ccTypedef{typedef TriangulationDataStructure::Vertex Vertex;}{A model of the concept \ccc{TriangulationVertex}.} \ccGlue -\ccTypedef{typedef TDS::Full_cell Full_cell;}{A model of the concept +\ccTypedef{typedef TriangulationDataStructure::Full_cell Full_cell;}{A model of the concept \ccc{TriangulationFullCell}.} \ccGlue -\ccTypedef{typedef TDS::Facet Facet;}{} +\ccTypedef{typedef TriangulationDataStructure::Facet Facet;}{} \ccGlue -\ccTypedef{typedef TDS::Face Face;}% +\ccTypedef{typedef TriangulationDataStructure::Face Face;}% {A model of the concept \ccc{TriangulationFace}.} -The vertices and cells of triangulations are accessed through handles, +The vertices and full cells of triangulations are accessed through handles, iterators and circulators. A handle is a model of the \ccc{Handle} concept, and supports the two dereference operators \ccc{operator*} and \ccc{operator->}. A circulator is a model of the concept \ccc{Circulator}. Iterators and circulators are bidirectional and non-mutable. -%The edges and facets of the triangulation can also be visited through -%iterators and circulators which are bidirectional and non-mutable. Iterators and circulators are convertible to the corresponding handles, thus the user can pass them directly as arguments to the functions. -\ccTypedef{typedef TDS::Vertex_handle Vertex_handle;}{} -\ccGlue\ccTypedef{typedef TDS::Vertex_iterator Vertex_iterator;}{} -%\ccGlue\ccTypedef{typedef TDS::Vertex_const_handle Vertex_const_handle;}{} -%\ccGlue\ccTypedef{typedef TDS::Vertex_const_iterator Vertex_const_iterator;}{} +\ccTypedef{typedef TriangulationDataStructure::Vertex_handle Vertex_handle;}{} +\ccGlue\ccTypedef{typedef TriangulationDataStructure::Vertex_iterator Vertex_iterator;}{} -\ccTypedef{typedef TDS::Full_cell_handle Full_cell_handle;}{} -\ccGlue\ccTypedef{typedef TDS::Full_cell_iterator Full_cell_iterator;}{} -%\ccGlue\ccTypedef{typedef TDS::Full_cell_const_handle Full_cell_const_handle;}{} -%\ccGlue\ccTypedef{typedef TDS::Full_cell_const_iterator Full_cell_const_iterator;}{} +\ccTypedef{typedef TriangulationDataStructure::Full_cell_handle Full_cell_handle;}{} +\ccGlue\ccTypedef{typedef TriangulationDataStructure::Full_cell_iterator Full_cell_iterator;}{} -\ccTypedef{typedef TDS::Facet_iterator Facet_iterator;}{} +\ccTypedef{typedef TriangulationDataStructure::Facet_iterator Facet_iterator;}{} -\ccTypedef{typedef TDS::size_type size_type;}{Size type (an unsigned integral +\ccTypedef{typedef TriangulationDataStructure::size_type size_type;}{Size type (an unsigned integral type).} -\ccGlue\ccTypedef{typedef TDS::difference_type difference_type;}{Difference +\ccGlue\ccTypedef{typedef TriangulationDataStructure::difference_type difference_type;}{Difference type (a signed integral type).} The \ccRefName\ class also defines the following enum type to specify @@ -135,19 +129,19 @@ reference to the underlying triangulation data structure.} {Returns the number of finite vertices in the triangulation.} \ccGlue \ccMethod{size_type number_of_full_cells() const;}% -{Returns the number of cells of maximal dimension in the triangulation -(cells incident to the vertex at infinity are counted).} +{Returns the number of full cells of maximal dimension in the triangulation +(full cells incident to the vertex at infinity are counted).} \ccMethod{Vertex_handle infinite_vertex() const;}% {Returns a handle to the vertex at infinity.} \ccMethod{Full_cell_handle infinite_full_cell() const;}% -{Returns a handle to some cell incident to the vertex at infinity.} +{Returns a handle to some full cell incident to the vertex at infinity.} \ccHeading{Non-constant-time access functions} \ccMethod{size_type number_of_finite_full_cells() const;}% -{Returns the number of cells of maximal dimension that are not +{Returns the number of full cells of maximal dimension that are not incident to the vertex at infinity.} \ccHeading{Tests for finite and infinite elements} @@ -173,32 +167,8 @@ vertex. \ccMethod{bool is_infinite(const Face & f) const;}{Returns \ccc{true} if and only if the face \ccc{f} is incident to the infinite vertex. -%\ccPrecond $2\leq$\ccVar.\ccc{current_dimension()}. } -% \ccMethod{bool is_finite(const Vertex_handle v) const;} {Returns \ccc{true} if -% and only if the vertex \ccc{v} is not the infinite vertex.} - -% \ccGlue - -% \ccMethod{bool is_finite(const Full_cell_handle s) const;}{Returns \ccc{true} if -% and only if all vertices of \ccc{s} are finite. -% %\ccPrecond\ccc{0 <=}\ccVar.\ccc{current_dimension()}. -% } - -% \ccGlue - -% \ccMethod{bool is_finite(const Facet & ft) const;}{Returns \ccc{true} if and -% only if all vertices of the facet \ccc{ft} are finite. -% %\ccPrecond\ccc{1 <=}\ccVar.\ccc{current_dimension()}. -% } - -% \ccGlue - -% \ccMethod{bool is_finite(const Face & f) const;}{Returns \ccc{true} if and -% only if all vertices of the face \ccc{f} are finite. -% %\ccPrecond{\ccc{2 <=}\ccVar.\ccc{current_dimension()}}. -% } \ccHeading{Queries} @@ -214,37 +184,37 @@ an optional parameter that is used as a hint for the point location.} {Tests whether \ccc{v} is a vertex of \ccVar.} \ccMethod{bool is_full_cell(Full_cell_handle c) const;} -{Tests whether \ccc{c} is a cell of \ccVar.} +{Tests whether \ccc{c} is a full cell of \ccVar.} \ccMethod{Orientation orientation(Full_cell_handle c) const;} -{Returns the orientation of the finite cell \ccc{c}: +{Returns the orientation of the finite full cell \ccc{c}: \ccGlobalScope\ccc{POSITIVE}, \ccGlobalScope\ccc{NEGATIVE} or \ccGlobalScope\ccc{COPLANAR}. If \ccVar.\ccc{current_dimension() == 0}, then \ccGlobalScope\ccc{POSITIVE} is returned. Under normal circumstances, the function should always return \ccGlobalScope\ccc{POSITIVE}. \ccPrecond Full cell \ccc{c} must be finite. -\note{should be removed, a valid cell is positive}\note{SH: what if user modifies the triangulation arbitrarily?} +\note{should be removed, a valid full cell is positive}\note{SH: what if user modifies the triangulation arbitrarily?} } \ccMethod{template< typename OutputIterator > OutputIterator incident_full_cells(Vertex_const_handle v, OutputIterator out) const;} -{Insert in \ccc{out} all the cells that are incident to the vertex -\ccc{v}, {i.e.}, the cells that have the \ccc{Vertex v} as a vertex. +{Insert in \ccc{out} all the full cells that are incident to the vertex +\ccc{v}, {i.e.}, the full cells that have the \ccc{Vertex v} as a vertex. Returns the (modified) output iterator. %\ccPrecond\ccc{is_full_cell(f.full_cell())}. } \ccMethod{template< typename OutputIterator > OutputIterator incident_full_cells(const Face & f, OutputIterator out) const;} -{Insert in \ccc{out} all the cells that are incident to the face \ccc{f}, -{i.e.}, the cells that have the \ccc{Face f} as a subface. +{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f}, +{i.e.}, the full cells that have the \ccc{Face f} as a subface. Returns the (probably modified) output iterator. %\ccPrecond\ccc{is_full_cell(f.full_cell())}. } \ccMethod{template< typename OutputIterator > OutputIterator star(const Face & f, OutputIterator out) const;} -{Insert in \ccc{out} all the cells that share at least one vertex with the \ccc{Face +{Insert in \ccc{out} all the full cells that share at least one vertex with the \ccc{Face f}. Returns the (probably modified) output iterator. %\ccPrecond\ccc{is_full_cell(f.full_cell())}. } @@ -260,11 +230,11 @@ constructed. \ccMethod{template< typename OutputIterator > OutputIterator incident_upper_faces(Vertex_const_handle v, int d, OutputIterator -out);}{Constructs all the \textbf{upper} \ccc{Face}s of dimension \ccc{d} +out);}{Constructs all the \em{upper} \ccc{Face}s of dimension \ccc{d} incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\ Assuming some total ordering on the vertices of the triangulation (which is invariant as long as no vertex is inserted in or removed from the triangulation), a -\ccc{Face} incident to \ccc{v} is an \emph{upper} \ccc{Face} if and only if +\ccc{Face} incident to \ccc{v} is an \em{upper} \ccc{Face} if and only if its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In particular, taking the disjoint union of the upper \ccc{Face}s of dimension \ccc{d} incident to every vertex of the triangulation yields exactly the set of @@ -287,11 +257,11 @@ the vertex ordering to define the upper faces.} \ccHeading{Faces and Facets} % - - - - - - - - - - - - - - - - - - - - FACETS \ccMethod{Full_cell_handle full_cell(const Facet & f) const;} -{Returns a cell containing the facet \ccc{f}} +{Returns a full cell containing the facet \ccc{f}} \ccMethod{int index_of_covertex(const Facet & f) const;} -{Returns the index of the vertex of the cell -\ccc{c=}\ccVar.\ccc{full_cell(f)} which does \textbf{not} belong to \ccc{c}.} +{Returns the index of the vertex of the full cell +\ccc{c=}\ccVar.\ccc{full_cell(f)} which does {not} belong to \ccc{c}.} %\begin{ccAdvanced} %\ccMethod{Face make_empty_face() const;}{Returns an empty \ccc{Face}.} @@ -318,17 +288,17 @@ the vertex ordering to define the upper faces.} %\ccMethod{Full_cell_const_iterator full_cells_begin()const;}{}\ccGlue \ccMethod{Full_cell_iterator full_cells_begin();} -{The first cell of \ccVar.} +{The first full cell of \ccVar.} %\ccGlue\ccMethod{Full_cell_const_iterator full_cells_end() const;}{} \ccGlue\ccMethod{Full_cell_iterator full_cells_end();} -{The beyond cell of \ccVar.} +{The beyond full cell of \ccVar.} %\ccMethod{Finite_full_cell_const_iterator finite_full_cells_begin() const;}{}\ccGlue \ccMethod{Finite_full_cell_iterator finite_full_cells_begin();} -{The first finite cell of \ccVar.} +{The first finite full cell of \ccVar.} %\ccGlue\ccMethod{Finite_full_cell_const_iterator finite_full_cells_end() const;}{} \ccGlue\ccMethod{Finite_full_cell_iterator finite_full_cells_end();} -{The beyond finite cell of \ccVar.} +{The beyond finite full cell of \ccVar.} \ccMethod{Facet_iterator facets_begin();} {Iterator to the first facet of the triangulation.} @@ -349,20 +319,20 @@ the triangulation: \ccMethod{Full_cell_handle locate(const Point & query, Full_cell_handle hint = Full_cell_handle()) const;} -{If the point \ccc{query} lies inside a bounded (finite) cell of \ccVar, -the latter cell is returned.\\ -If \ccc{query} lies on the boundary of some finite cells, one of them +{If the point \ccc{query} lies inside a bounded (finite) full cell of \ccVar, +the latter full cell is returned.\\ +If \ccc{query} lies on the boundary of some finite full cells, one of them is returned.\\ Let $d=$\ccVar.\ccc{current_dimension()}. If the point \ccc{query} lies -outside the convex hull of the points, an infinite cell with vertices $\{ -p_1, p_2, \ldots, p_d, \infty\}$ is returned such that the cell $(p_1, p_2, +outside the convex hull of the points, an infinite full cell with vertices $\{ +p_1, p_2, \ldots, p_d, \infty\}$ is returned such that the full cell $(p_1, p_2, \ldots, p_d, query)$ is positively oriented (the rest of the triangulation lies on the other side of facet $(p_1, p_2, \ldots, p_d)$).\\ The optional argument \ccc{hint} is used as a starting place for the search.} \ccMethod{Full_cell_handle locate(const Point & query, Vertex_handle hint) const;} -{Same as above but \ccc{hint} is a vertex and not a cell.} +{Same as above but \ccc{hint} is a vertex and not a full cell.} \ccMethod{Full_cell_handle locate(const Point & query, Locate_type & loc_type, Face & f, Facet & ft, Full_cell_handle hint = Full_cell_handle()) const;} @@ -370,27 +340,27 @@ Face & f, Facet & ft, Full_cell_handle hint = Full_cell_handle()) const;} search.\\ If the \ccc{query} point lies outside the affine hull of the points, which can happen when \ccVar.\ccc{current_dimension() < } \ccVar.\ccc{ambient_dimension()}, \ccc{loc_type} is set to -\ccc{OUTSIDE_AFFINE_HULL}, and the returned cell has no meaning. As a +\ccc{OUTSIDE_AFFINE_HULL}, and the returned full cell has no meaning. As a particular case, if there is no finite vertex yet in the triangulation, \ccc{loc_type} is set to \ccc{OUTSIDE_AFFINE_HULL} and \textit{locate} returns \ccc{Full_cell_handle()}.\\ If the \ccc{query} point lies inside the affine hull -of the points, a $k$-face that contains \ccc{query} \textbf{in its relative +of the points, a $k$-face that contains \ccc{query} {in its relative interior} is returned. (If the $k$-face is finite, it is unique.)\begin{itemize} \item[$k=0$] \ccc{loc_type} is set to \ccc{ON_VERTEX}, -\ccc{f} is set to the vertex \ccc{v} the \ccc{query} lies on and a cell +\ccc{f} is set to the vertex \ccc{v} the \ccc{query} lies on and a full cell having \ccc{v} as a vertex is returned. \item[$0 Vertex_handle insert_in_hole(const Point & p, ForwardIterator s, -ForwardIterator e, const Facet & ft, OutputIterator out);}{The cells in +ForwardIterator e, const Facet & ft, OutputIterator out);}{The full cells in the range $C=$\ccc{[s, e)} are removed, thus forming a hole. A \ccc{Vertex} is inserted at position \ccc{p} and connected to the boundary of the hole in order to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is returned. The facet \ccc{ft} must lie on the boundary of $C$ and its -defining cell, \ccVar.\ccc{full_cell(ft)} must lie inside $C$. Handles -to the newly created cells are output in the \ccc{out} output iterator. +defining full cell, \ccVar.\ccc{full_cell(ft)} must lie inside $C$. Handles +to the newly created full cells are output in the \ccc{out} output iterator. \ccPrecond $C$ must be a (geometric) ball, must contain \ccc{p} in its -interior and not contain any vertex all of whose incident cells are in +interior and not contain any vertex all of whose incident full cells are in $C$. (This implies that \ccVar.\ccc{current_dimension()}$\geq2$ if $|C|>1$.) The boundary of $C$ must be a triangulation of the sphere $\sphere^{k-1}$.} \ccMethod{template < typename ForwardIterator > Vertex_handle insert_in_hole(const Point & p, ForwardIterator s, ForwardIterator e, const -Facet & ft);}{Same as above, but the newly created cells are not +Facet & ft);}{Same as above, but the newly created full cells are not retrieved.} \ccMethod{Vertex_handle insert_in_face(const Point & p, const Face & f);}% @@ -475,19 +445,19 @@ retrieved.} \ccPrecond \ccc{p} must lie in the relative interior of \ccc{ft}.} \ccMethod{Vertex_handle insert_in_full_cell(const Point & p, Full_cell_handle -s);}% +c);}% {Inserts point \ccc{p} in the triangulation. \ccPrecond \ccc{p} must lie in the -interior of \ccc{s}.} +interior of \ccc{c}.} \ccMethod{Vertex_handle insert_outside_convex_hull(const Point &, - Full_cell_handle s);}% + Full_cell_handle c);}% {Inserts point \ccc{p} in the triangulation. \ccPrecond \ccc{p} must lie outside the convex hull of \ccVar. The half-space -defined by the infinite cell \ccc{s} must contain \ccc{p}.} +defined by the infinite full cell \ccc{c} must contain \ccc{p}.} \ccMethod{Vertex_handle insert_outside_affine_hull(const Point &);}% {Inserts point \ccc{p} in the triangulation. -\ccPrecond \ccc{p} must lie outside the \textbf{affine} hull of \ccVar.} +\ccPrecond \ccc{p} must lie outside the {affine} hull of \ccVar.} \end{ccAdvanced} @@ -498,14 +468,14 @@ defined by the infinite cell \ccc{s} must contain \ccc{p}.} \ccc{true} if the combinatorial triangulation data structure's \ccc{is_valid()} test returns \ccc{true} and if some geometric tests are passed with success. %\note{is it really necessary to have the following : -%For each infinite cell, it is checked that the index of the infinite +%For each infinite full cell, it is checked that the index of the infinite %vertex is 0. } -For each finite cell, it is checked that its orientation is +For each finite full cell, it is checked that its orientation is positive.} \ccMethod{bool are_incident_full_cells_valid(Vertex_const_handle v, bool verbose = true, int level = 0) const;} {Returns \ccc{true} if and only if all -finite cells incident to \ccc{v} have positive orientation.} +finite full cells incident to \ccc{v} have positive orientation.} \ccHeading{Input/Output} @@ -514,9 +484,9 @@ finite cells incident to \ccc{v} have positive orientation.} calling the corresponding input operator of the triangulation data structure class (note that the infinite vertex is numbered 0), and the non-combinatorial information by calling the corresponding input -operators of the vertex and the cell classes (such as point +operators of the vertex and the full cell classes (such as point coordinates), which are provided by overloading the stream operators -of the vertex and cell types. Assigns the resulting triangulation to +of the vertex and full cell types. Assigns the resulting triangulation to \ccc{t}.} \ccFunction{ostream& operator<< (ostream& os, const Triangulation & t);} @@ -524,16 +494,16 @@ of the vertex and cell types. Assigns the resulting triangulation to The information in the \ccc{iostream} is: the current dimension, the number of finite vertices, the non-combinatorial information about vertices (point, -\emph{etc.}), the number of cells, the indices of the vertices of each -cell, plus the non-combinatorial information about each cell, then the -indices of the neighbors of each cell, where the index corresponds to the -preceding list of cells. +\emph{etc.}), the number of full cells, the indices of the vertices of each +full cell, plus the non-combinatorial information about each full cell, then the +indices of the neighbors of each full cell, where the index corresponds to the +preceding list of full cells. \ccSeeAlso -\ccc{Triangulation_data_structure},\\ -\ccc{Delaunay_triangulation},\\ -%\ccc{Regular_triangulation}. +\ccc{Triangulation_data_structure},\\ +\ccc{Delaunay_triangulation},\\ +%\ccc{Regular_triangulation}. \end{ccRefClass} diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationDSFullCell.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationDSFullCell.tex index 61c07ca1e59..0ae37378319 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationDSFullCell.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationDSFullCell.tex @@ -5,9 +5,9 @@ The concept \ccRefName\ describes what a full cell is in a model of the concept \ccc{TriangulationDataStructure}. It sets requirements of combinatorial nature only, as geometry is not concerned here. -In the context of triangulation, the term cell refer to a face of -\emph{maximal} dimension. We emphasize this maximality characteristic by using -the term {\em full cell}. +In the context of triangulation, the term full cell refer to a face of +\emph{maximal} dimension. This maximality characteristic is emphasized by using +the adjective {\em full}. A \ccRefName\ is responsible for storing handles to the vertices of a full cell as well as handles to its neighbors. @@ -17,50 +17,50 @@ concept. \ccHasModels -\ccc{Triangulation_ds_full_cell}\\ -\ccc{Triangulation_full_cell} +\ccc{Triangulation_ds_full_cell}\\ +\ccc{Triangulation_full_cell} \ccTypes \ccNestedType{Vertex_handle}%{} %\ccGlue\ccNestedType{Vertex_const_handle} {A handle to a vertex. It must be the same as the -nested type \ccc{TDS::Vertex_handle} of the \ccc{TDS} in which the +nested type \ccc{TriangulationDataStructure::Vertex_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationDSFullCell} is defined/used.} \ccNestedType{Vertex_handle_iterator}{An iterator over the handles to -the vertices of the cell.} +the vertices of the full cell.} \ccNestedType{Full_cell_handle}%{} %\ccGlue\ccNestedType{Full_cell_const_handle} {A handle to a full cell. It must be the same as the -nested type \ccc{TDS::Full_cell_handle} of the \ccc{TDS} in which the +nested type \ccc{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationDSFullCell} is defined/used.} -\ccTypedef{typedef TDS::Full_cell_data TDS_data;}{} +\ccTypedef{typedef TriangulationDataStructure::Full_cell_data TDS_data;}{} \ccNestedType{template Rebind_TDS}{This nested template -class must define a nested type \ccc{Other} which is the rebound cell +class must define a nested type \ccc{Other} which is the rebound full cell class template, that is: \ccc{Other == TriangulationDSFullCell}.} \ccCreation \ccCreationVariable{c} \ccConstructor{TriangulationDSFullCell(int dmax);}{Sets the maximum possible -dimension of the cell.} +dimension of the full cell.} \ccConstructor{TriangulationDSFullCell(const TriangulationDSFullCell & fc);}% {Copy constructor.} -If you want to create a cell as part of a \ccc{TriangulationDataStructure}, +If you want to create a full cell as part of a \ccc{TriangulationDataStructure}, you would rather want to call the \ccc{new_full_cell()} from the latter concept, -as it is not possible to incorporate an existing external cell into +as it is not possible to incorporate an existing external full cell into a triangulation. \ccHeading{Access functions} \ccMethod{int ambient_dimension() const;}{Returns one less than the maximum -number of vertices that the full cell can store. This does \textbf{not} return +number of vertices that the full cell can store. This does {not} return the dimension of the actual full cell stored in \ccVar.} \ccMethod{Vertex_handle_iterator vertices_begin() const;} @@ -72,29 +72,29 @@ full cell.} the full cell.} \ccMethod{Vertex_handle vertex(const int i) const;}{Returns the \ccc{i}-th vertex -of the cell. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} +of the full cell. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} \ccGlue\ccMethod{Full_cell_handle neighbor(const int i) const;}{Returns the -cell opposite to the \ccc{i}-th vertex of the cell \ccVar. \ccPrecond +full cell opposite to the \ccc{i}-th vertex of the full cell \ccVar. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} \ccMethod{int mirror_index(const int i) const;}{Returns the index \ccc{j} of -the cell \ccc{s} as a neighbor in the cell \ccVar\ccc{.neighbor(i);}. If the +the full cell \ccVar as a neighbor in the full cell \ccVar\ccc{.neighbor(i);}. If the returned integer is not negative, it holds that \ccVar.% \ccc{neighbor(i)->neighbor(j) == }\ccVar. Returns -\ccc{-1} if \ccc{s} has no neighboring cell of index \ccc{i}. +\ccc{-1} if \ccVar has no neighboring full cell of index \ccc{i}. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} \ccMethod{int index(Full_cell_handle n) const;}{Returns the index \ccc{i} of the neighbor \ccc{n} such that \ccVar\ccc{.neighbor(i)==n}. \ccPrecond \ccc{n} -must be a neighbor of \ccc{s}.} +must be a neighbor of \ccVar.} \ccGlue \ccMethod{int index(Vertex_handle v) const;}{Returns the index \ccc{i} of the vertex \ccc{v} such that \ccVar\ccc{.vertex(i)==v}. \ccPrecond \ccc{v} must be -a vertex of the \ccc{s}.} +a vertex of the \ccVar.} \ccMethod{const TDS_data & get_tds_data() const;}{Returns the data member of -type \ccc{TDS_data}. It is typically used to mark the cell as \emph{visited} +type \ccc{TDS_data}. It is typically used to mark the full cell as \emph{visited} during operations on a \ccc{TriangulationDataStructure}.} \ccMethod{TDS_data & get_tds_data();}{Same as above, but returns a reference to @@ -102,7 +102,7 @@ a non-\ccc{const} object.} \begin{ccAdvanced} \ccMethod{Vertex_handle mirror_vertex(const int i, const int cur_dim) const;} -{Returns a handle to the mirror vertex of the \ccc{i}-th vertex of cell +{Returns a handle to the mirror vertex of the \ccc{i}-th vertex of full cell \ccVar. This function works even if the neighboring information stored in the neighbor full cell \ccc{*}\ccVar\ccc{.neighbor(i)} is corrupted. This is useful when temporary corruption is necessary during surgical operation on a @@ -114,49 +114,49 @@ i,$\ccc{cur_dim}$\leq$\ccc{ambient_dimension()}.} \ccHeading{Update functions} % - - - - - - - - - - - - - - - - - UPDATES \ccMethod{void set_vertex(const int i, Vertex_handle v);}{Sets the $i$-th -vertex of the cell. +vertex of the full cell. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} \ccMethod{void set_neighbor(const int i, Full_cell_handle n);} {Sets the -\ccc{i}-th neighboring cell of \ccVar\ to \ccc{n}. Full cell \ccc{n} is +\ccc{i}-th neighboring full cell of \ccVar\ to \ccc{n}. Full cell \ccc{n} is opposite to the $i$-th vertex of \ccVar. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} \ccMethod{void set_mirror_index(const int i, const int index);} {Sets the mirror index of the $i$-th vertex of \ccVar\ to \ccc{index}. This corresponds -to the index, in \ccVar\ccc{->neighbor(i)}, of the cell \ccVar.\\ +to the index, in \ccVar\ccc{->neighbor(i)}, of the full cell \ccVar.\\ Note: an implementation of the concept \ccVar\ may choose not to store mirror indices, in which case this function should do nothing. \ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.} \ccMethod{void swap_vertices(int d1, int d2);}{Switches the orientation of the -cell \ccVar\ by swapping its vertices with index \ccc{d1} and \ccc{d2}. +full cell \ccVar\ by swapping its vertices with index \ccc{d1} and \ccc{d2}. \ccPrecond $0\leq d1,d2\leq$\ccc{ambient_dimension()}.} \ccHeading{Queries} \ccMethod{bool has_vertex(Vertex_handle v) const;}{Returns \ccc{true} -if the vertex \ccc{v} is a vertex of the cell \ccVar. Returns \ccc{false} +if the vertex \ccc{v} is a vertex of the full cell \ccVar. Returns \ccc{false} otherwise.} \ccMethod{bool has_vertex(Vertex_handle v, int & ret) const;}% {Returns \ccc{true} and sets the value of \ccc{ret} to the index of \ccc{v} in -\ccVar\ if the vertex \ccc{v} is a vertex of the cell \ccVar. Returns +\ccVar\ if the vertex \ccc{v} is a vertex of the full cell \ccVar. Returns \ccc{false} otherwise.} \ccMethod{bool has_neighbor(Full_cell_handle n) const;}{Returns \ccc{true} -if the cell \ccc{n} is a neighbor of the cell \ccVar. Returns +if the full cell \ccc{n} is a neighbor of the full cell \ccVar. Returns \ccc{false} otherwise.} \ccMethod{bool has_neighbor(Full_cell_handle n, int & ret) const;}% {Returns \ccc{true} and sets the value of \ccc{ret} to the index of \ccc{n} as -a neighbor of \ccVar\ if the cell \ccc{n} is a neighbor of the cell +a neighbor of \ccVar\ if the full cell \ccc{n} is a neighbor of the full cell \ccVar. Returns \ccc{false} otherwise.} \ccHeading{Validity check} \ccMethod{bool is_valid(bool verbose=false, int level=0) const;}{Performs any -desired test on a cell. \emph{E.g.}, checks that for each existing vertex, +desired test on a full cell. \emph{E.g.}, checks that for each existing vertex, there is an existing neighbor.} % \ccHeading{Memory management} @@ -165,21 +165,21 @@ there is an existing neighbor.} % \ccGlue\ccMethod{void* & for_compact_container();}{} % These member functions are required by the classes -% \ccc{Triangulation_data_structure} and -% \ccc{Triangulation} (and its derived classes) because they use -% \ccc{Compact_container} to store their vertices and simplices. See the +% \ccc{Triangulation_data_structure} and +% \ccc{Triangulation} (and its derived classes) because they use +% \ccc{Compact_container} to store their vertices and full cells. See the % documentation of \ccc{Compact_container} for the exact requirements. \ccHeading{Input/Output} -\ccFunction{template istream& operator>>(istream & is, - Triangulation_ds_full_cell & c);} -{Reads (possible) non-combinatorial information about a cell from the stream \ccc{is} +\ccFunction{template istream& operator>>(istream & is, + Triangulation_ds_full_cell & c);} +{Reads (possible) non-combinatorial information about a full cell from the stream \ccc{is} into \ccc{c}.} -\ccFunction{template ostream& operator<<(ostream & os, const - Triangulation_ds_full_cell & c);} -{Writes (possible) non-combinatorial information about cell \ccc{c} to the stream +\ccFunction{template ostream& operator<<(ostream & os, const + Triangulation_ds_full_cell & c);} +{Writes (possible) non-combinatorial information about full cell \ccc{c} to the stream \ccc{os}.} \ccSeeAlso diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationDSVertex.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationDSVertex.tex index bd8beaa172b..aeca4e9b613 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationDSVertex.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationDSVertex.tex @@ -12,13 +12,13 @@ concept. \ccHasModels -\ccc{Triangulation_ds_vertex}\\ -\ccc{Triangulation_vertex} +\ccc{Triangulation_ds_vertex}\\ +\ccc{Triangulation_vertex} \ccTypes \ccNestedType{Full_cell_handle}{A handle to a cell. It must be the same as the -nested type \ccc{TDS::Full_cell_handle} of the \ccc{TDS} in which the +nested type \ccc{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationDSVertex} is defined/used.} \ccNestedType{template Rebind_TDS}{This nested template @@ -29,16 +29,16 @@ class template, that is: \ccc{Other == TriangulationDSVertex}.} \ccCreationVariable{v} \ccConstructor{TriangulationDSVertex();}{The default constructor (no incident -cell is set).} +full cell is set).} \ccGlue -\ccConstructor{TriangulationDSVertex(Full_cell_handle s);}{Sets the incident -cell to \ccc{s}. \ccPrecond \ccc{s} must not be the default-constructed +\ccConstructor{TriangulationDSVertex(Full_cell_handle c);}{Sets the incident +full cell to \ccc{c}. \ccPrecond \ccc{c} must not be the default-constructed \ccc{Full_cell_handle}.} \ccOperations \ccMethod{void set_full_cell(Full_cell_handle c);}{Set \ccc{c} as the vertex's -incident cell. \ccPrecond \ccc{c} must not be the default-constructed +incident full cell. \ccPrecond \ccc{c} must not be the default-constructed \ccc{Full_cell_handle}.} \ccMethod{Full_cell_handle full_cell() const;}{Returns a handle to a @@ -48,7 +48,7 @@ incident cell. \ccPrecond \ccc{c} must not be the default-constructed \ccMethod{bool is_valid(bool verbose=false, int level=0) const;}{Performs any desired test on a vertex. Al least, checks that the pointer to an incident -cell is not the default constructed handle ({i.e.}, is not +full cell is not the default constructed handle ({i.e.}, is not \ccc{NULL}). The parameter \ccc{level} is not used, but can be used in derived classes.} @@ -58,21 +58,21 @@ classes.} % \ccGlue\ccMethod{void* & for_compact_container();}{} % These member functions are required by the classes -% \ccc{Triangulation_data_structure} and -% \ccc{Triangulation} (and its derived classes) because they use +% \ccc{Triangulation_data_structure} and +% \ccc{Triangulation} (and its derived classes) because they use % the \cgal\ container class \ccc{Compact_container} to store their vertices and -% simplices. See the documentation of \ccc{Compact_container} for the exact +% full cells. See the documentation of \ccc{Compact_container} for the exact % requirements. \ccHeading{Input/Output} -\ccFunction{template istream& operator>>(istream & is, - Triangulation_ds_vertex & v);} +\ccFunction{template istream& operator>>(istream & is, + Triangulation_ds_vertex & v);} {Reads (possible) non-combinatorial information about a vertex from the stream \ccc{is} into \ccc{v}.} -\ccFunction{template ostream& operator<<(ostream & os, const - Triangulation_ds_vertex & v);} +\ccFunction{template ostream& operator<<(ostream & os, const + Triangulation_ds_vertex & v);} {Writes (possible) non-combinatorial information about vertex \ccc{v} to the stream \ccc{os}.} diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationDataStructure.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationDataStructure.tex index 4d1f63a3e16..9342b2cdfd8 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationDataStructure.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationDataStructure.tex @@ -19,14 +19,14 @@ Values of $d$ (the \emph{current dimension} of the complex) include \begin{itemi \item[-2] This corresponds to the non-existence of any object in $\sphere^D.$ -\item[-1] This corresponds to a single vertex and a single simplex. In a +\item[-1] This corresponds to a single vertex and a single full cell. In a geometric realization of the \ccRefName\ (\emph{e.g.}, in a -\ccc{Triangulation} or a -\ccc{Delaunay_triangulation}), this vertex +\ccc{Triangulation} or a +\ccc{Delaunay_triangulation}), this vertex corresponds to \emph{the vertex at infinity}. \item[0] This corresponds to two vertices, each incident to one $0$-face; -the two cells being neighbor of each other. This is the unique +the two full cells being neighbor of each other. This is the unique triangulation of the $0$-sphere. \item[$d>0$] This corresponds to a standard triangulation of the sphere @@ -34,25 +34,23 @@ $\sphere^d$. \end{itemize} An $i$-simplex is a simplex with $i+1$ vertices. An $i$-simplex $\sigma$ is -\textbf{incident} to a $j$-simplex $\sigma'$, $j} +\ccc{Triangulation_data_structure} \ccTypes \ccNestedType{Vertex} { -A model of the concept \ccc{TriangulationDSVertex}. +Vertex type. } \ccGlue \ccNestedType{Full_cell} { -A model of the concept \ccc{TriangulationDSFullCell}. +Full cell type. } The concept \ccRefName\ also defines a type for describing facets of the @@ -67,28 +65,25 @@ full cell \ccc{c} opposite to its \ccc{i}-th vertex} \ccNestedType{Face} {A model of the concept \ccc{TriangulationFace}.} -Vertices and simplices are manipulated via \emph{handles}. Handles support the +Vertices and full cells are manipulated via \emph{handles}. Handles support the usual two dereference operators \ccc{operator*} and \ccc{operator->}. \ccNestedType{Vertex_handle} { Handle to a \ccc{Vertex}. } -%\ccGlue -%\ccNestedType{Vertex_const_handle} -%{ -%Handle to a \ccc{const Vertex}. -%} \ccGlue \ccNestedType{Full_cell_handle} { Handle to a \ccc{Full_cell}. } -%\ccGlue -%\ccNestedType{Full_cell_const_handle} -%{ -%Handle to a \ccc{const Full_cell}. -%} + + +Requirements for \ccc{Vertex} and \ccc{Full_cell} are described in concepts +\ccc{TriangulationDataStructure::Vertex} and +\ccc{TriangulationDataStructure::FullCell} \lcTex{( +\ccRefPage{TriangulationDataStructure::Vertex} and +\ccRefPage{TriangulationDataStructure::FullCell})}. \begin{ccAdvanced} \ccNestedType{template struct Rebind_vertex} @@ -105,7 +100,7 @@ one whose \ccc{TriangulationDSFullCellBase} will be \ccc{Fcb2}.} \end{ccAdvanced} -Vertices, facets and cells can be iterated over using \emph{iterators}. +Vertices, facets and full cells can be iterated over using \emph{iterators}. Iterators support the usual two dereference operators \ccc{operator*} and \ccc{operator->}. @@ -113,21 +108,11 @@ Iterators support the usual two dereference operators \ccc{operator*} and { Iterator over the list of vertices. } -%\ccGlue -%\ccNestedType{Vertex_const_iterator} -%{ -%Iterator over the list of vertices (\ccc{const} casted). -%} \ccGlue \ccNestedType{Full_cell_iterator} { -Iterator over the list of cells. +Iterator over the list of full cells. } -%\ccGlue -%\ccNestedType{Simplex_const_iterator} -%{ -%Iterator over the list of simplices (\ccc{const} casted). -%} \ccGlue \ccNestedType{Facet_iterator} { @@ -142,7 +127,7 @@ Iterator over the facets of the complex. \ccCreationVariable{tds} \ccConstructor{XXXXXXXXXX(const int dim);} {Creates an instance \ccVar\ of -type \ccRefName. The maximal dimension of its cells is \ccc{dim} and +type \ccRefName. The maximal dimension of its full cells is \ccc{dim} and \ccVar\ is initialized to the empty triangulation. Thus, \ccVar.\ccc{current_dimension()} equals \ccc{-2}.} @@ -151,7 +136,7 @@ type \ccRefName. The maximal dimension of its cells is \ccc{dim} and \ccHeading{Queries} % --------------------------------------------- QUERIES \ccMethod{int ambient_dimension() const;} { Returns the maximal dimension of -the cells that can be stored in the triangulation \ccVar. \ccPostcond the +the full dimensional cells that can be stored in the triangulation \ccVar. \ccPostcond the returned value is positive. } \ccMethod{int current_dimension() const;} { Returns the dimension of the @@ -160,14 +145,14 @@ full dimensional cells stored in the triangulation. It holds that \ccc{true}. \ccPostcond the returned value \ccc{d} satisfies $-2\leq d \leq$\ccVar.\ccc{ambient_dimension()}. } -\ccMethod{bool empty() const;} { Returns \ccc{true} if the regular complex -contains no simplex. Returns \ccc{false} otherwise. } +\ccMethod{bool empty() const;} { Returns \ccc{true} if thetriangulation +contains nothing. Returns \ccc{false} otherwise. } \ccMethod{size_type number_of_vertices() const;} {Returns the number of vertices in the triangulation.} \ccMethod{size_type number_of_full_cells() const;} -{Returns the number of cells in the triangulation.} +{Returns the number of full cells in the triangulation.} \ccMethod{bool is_vertex(const Vertex_handle & v) const;} {} @@ -179,23 +164,23 @@ contains no simplex. Returns \ccc{false} otherwise. } void full_cells(Full_cell_handle c, TraversalPredicate & tp, OutputIterator & out) const;} {This function computes (\emph{gathers}) a connected set of full cells -satifying a common criteria. Call them \emph{good} cells. It is assumed -that the argument \ccc{c} is a good cell. The cells are then -recursively explored by examining if, from a given good cell, its neighboring -cells are also good.\\ +satifying a common criteria. Call them \emph{good} full cells. It is assumed +that the argument \ccc{c} is a good full cell. The full cells are then +recursively explored by examining if, from a given good full cell, its neighboring +full cells are also good.\\ The argument \ccc{tp} is a predicate that takes as argument a \ccc{Facet} whose containing \ccc{Full_cell} is good. The predicate must return \ccc{true} -if the traversal of that \ccc{Facet} leads to a good cell.\\ -All the good cells are outputted into the last argument \ccc{out}.} +if the traversal of that \ccc{Facet} leads to a good full cell.\\ +All the good full cells are outputted into the last argument \ccc{out}.} \ccMethod{template< typename OutputIterator > OutputIterator incident_full_cells(Vertex_handle v, OutputIterator out) const;} -{Insert in \ccc{out} all the cells that are incident to the vertex +{Insert in \ccc{out} all the full cells that are incident to the vertex \ccc{v}, {i.e.}, the full cells that have the \ccc{Vertex v} as a vertex. Returns the (modified) output iterator.} \ccMethod{template< typename OutputIterator > OutputIterator incident_full_cells(const Face & f, OutputIterator out) const;} -{Insert in \ccc{out} all the cells that are incident to the face \ccc{f}, +{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f}, {i.e.}, the full cells that have the \ccc{Face f} as a subface. Returns the (probably modified) output iterator. %\ccPrecond\ccc{is_full_cell(f.full_cell())}. @@ -219,11 +204,11 @@ f}. Returns the (probably modified) output iterator. \ccMethod{template< typename OutputIterator > OutputIterator incident_upper_faces(Vertex_handle v, const int d, OutputIterator - out);}{Constructs all the \textbf{upper} \ccc{Face}s of dimension \ccc{d} + out);}{Constructs all the \em{upper} \ccc{Face}s of dimension \ccc{d} incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\ Assuming some total ordering on the vertices of the complex (which is invariant as long as no vertex is inserted in or removed from the complex), a - \ccc{Face} incident to \ccc{v} is an \emph{upper} \ccc{Face} if and only if + \ccc{Face} incident to \ccc{v} is an \em{upper} \ccc{Face} if and only if its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In particular, taking the disjoint union of the upper \ccc{Face}s of dimension \ccc{d} incident to every vertex of the complex yields exactly the set of @@ -249,9 +234,8 @@ $d\geq$\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is \ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension()}.} \ccMethod{int mirror_index(Full_cell_handle c, int i) const;}%{} -%\ccGlue\ccMethod{int mirror_index(Full_cell_const_handle s, int i) const;} {Returns the index of the vertex mirror of the \ccc{i}-th vertex of \ccc{c}. -Equivalently, returns the index of \ccc{s} in its \ccc{i}-th neighbor. +Equivalently, returns the index of \ccc{c} in its \ccc{i}-th neighbor. \ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension}()\\ and $s$ is not the default constructed \ccc{Full_cell_handle}. } @@ -263,10 +247,6 @@ and $s$ is not the default constructed \ccc{Full_cell_handle}. } { The first vertex of \ccVar. } -%\ccGlue -%\ccMethod{Vertex_const_iterator vertices_end() const;} -%{ -%} \ccGlue \ccMethod{Vertex_iterator vertices_end();} { @@ -276,32 +256,21 @@ The beyond vertex of \ccVar. \ccHeading{Accessing the full cells} % ------------------- ACCESS TO CELLS \ccMethod{Full_cell_handle full_cell(Vertex_handle v) const;}%{} -%\ccGlue -%\ccMethod{Full_cell_const_handle simplex(Vertex_const_handle v) const;} -{Returns a full cell incident to \ccc{Vertex} \ccc{v}. Note that this simplex is -not unique (\ccc{v} is typically incident to more than one simplex). +{Returns a full cell incident to \ccc{Vertex} \ccc{v}. Note that this + full cell is +not unique (\ccc{v} is typically incident to more than one full cell). \ccPrecond\ccc{v} is not the default constructed \ccc{Vertex_handle}} \ccMethod{Full_cell_handle neighbor(Full_cell_handle c, int i) const;}%{} -%\ccGlue -%\ccMethod{Full_cell_const_handle neighbor(Full_cell_const_handle s, int i) const;} { Returns a \ccc{Full_cell_handle} pointing to the \ccc{Full_cell} -opposite to the \ccc{i}-th vertex of \ccc{s}. +opposite to the \ccc{i}-th vertex of \ccc{c}. \ccPrecond$0\leq i \leq$\ccVar.\ccc{current_dimension()}\\ and \ccc{c} is not the default constructed \ccc{Full_cell_handle}} -%\ccMethod{Simplex_const_iterator full_cells_begin() const;} -%{ -%} -%\ccGlue \ccMethod{Full_cell_iterator full_cells_begin();} { The first full cell of \ccVar. } -%\ccGlue -%\ccMethod{Simplex_const_iterator full_cells_end() const;} -%{ -%} \ccGlue \ccMethod{Full_cell_iterator full_cells_end();} { @@ -320,8 +289,8 @@ The beyond full cell of \ccVar. {Returns a full cell containing the facet \ccc{f}} \ccMethod{int index_of_covertex(const Facet & f) const;} -{Returns the index of vertex of the cell \ccc{c=}\ccVar.\ccc{full_cell(f)} -which does \textbf{not} belong to \ccc{c}.} +{Returns the index of vertex of the full cell \ccc{c=}\ccVar.\ccc{full_cell(f)} +which does {not} belong to \ccc{c}.} \ccMethod{Face make_empty_face() const;}{Returns an empty \ccc{Face} ready to be setup with any $k$-face of the (combinatorial) triangulation with @@ -344,10 +313,11 @@ $k<$\ccVar.\ccc{current_dimension()}. See \ccc{TriangulationFace}.} \ccHeading{Vertex insertion} % - - - - - - - - - - - - - - - - - - INSERTIONS \ccMethod{Vertex_handle insert_in_full_cell(Full_cell_handle c);}{Inserts a new -vertex \ccc{v} in the cell \ccc{c} and returns a handle to it. The cell -\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} cells which +vertex \ccc{v} in the full cell \ccc{c} and returns a handle to +it. The full cell +\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} full cells which share the vertex \ccc{v}. -\ccPrecond Current dimension is positive and \ccc{c} is a simplex of \ccVar.} +\ccPrecond Current dimension is positive and \ccc{c} is a full cell of \ccVar.} \begin{ccTexOnly} \begin{center} \includegraphics{Triangulation_ref/fig/insert-in-cell.pdf} @@ -355,7 +325,7 @@ share the vertex \ccc{v}. \end{ccTexOnly} \begin{ccHtmlOnly}
-The effect of insert_in_simplex() +The effect of insert_in_full_cell()
\end{ccHtmlOnly} @@ -379,18 +349,18 @@ share the vertex \ccc{v}. \ccMethod{template< class ForwardIterator > Vertex_handle insert_in_hole(ForwardIterator start, ForwardIterator end, Facet f);}{The -simplices in the range $C=$\ccc{[start, end)} are removed, thus forming a hole. +full cells in the range $C=$\ccc{[start, end)} are removed, thus forming a hole. A \ccc{Vertex} is inserted and connected to the boundary of the hole in order to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is returned. \ccPrecond $C$ must be a (combinatorial) ball and not contain any vertex -all of whose incident simplices are in $C$. (This implies that +all of whose incident full cells are in $C$. (This implies that \ccVar.\ccc{current_dimension()}$\geq2$ if $|C|>1$.)\\ The boundary of $C$ must be a (combinatorial) triangulation of the sphere $\sphere^{d-1}$. $f$ must be on the boundary of $C$.} \ccGlue \ccMethod{template< class ForwardIterator, class OutputIterator > Vertex_handle insert_in_hole(ForwardIterator start, ForwardIterator end, Facet -f, OutputIterator out);}{Same as above, but handles to the new simplices are +f, OutputIterator out);}{Same as above, but handles to the new full cells are appended to the \ccc{out} output iterator.} \ccMethod{Vertex_handle insert_increase_dimension(Vertex_handle star);} @@ -401,11 +371,11 @@ triangulation of the sphere $\sphere^{d+1}$ by adding a new vertex $\sphere^{d+1}$ ($v$ is added as $d+2^{th}$ vertex to all full cells) and \ccc{star} is used to triangulate the other half-sphere -(all cells that do not already has star as vertex are duplicated, -and \ccc{star} replaces \ccc{v} in these cells). +(all full cells that do not already has star as vertex are duplicated, +and \ccc{star} replaces \ccc{v} in these full cells). The indexing of the vertices in the -full cell is such that, if \ccc{f} was a cell of maximal dimension in the -initial complex, then \ccc{(f,v)}, in this order, is the corresponding cell +full cell is such that, if \ccc{f} was a full cell of maximal dimension in the +initial complex, then \ccc{(f,v)}, in this order, is the corresponding full cell in the updated triangulation. A handle to \ccc{v} is returned. \ccPrecond\ccVar. If the current dimension is -2 (empty triangulation), then \ccc{star} @@ -418,17 +388,17 @@ and \ccc{star} must be a vertex of \ccVar.} The following methods may destroy the integrity %(the ``purity'', one may say) of the data structure. They are used internally. Use at your own risks. -\ccMethod{Full_cell_handle new_full_cell();} {Adds a new cell to \ccVar\ and -returns a handle to it. The new cell has no vertex and no neighbor yet.} +\ccMethod{Full_cell_handle new_full_cell();} {Adds a new full cell to \ccVar\ and +returns a handle to it. The new full cell has no vertex and no neighbor yet.} \ccMethod{Vertex_handle new_vertex();} {Adds a new vertex to \ccVar\ and returns a handle to it. The new vertex has -no associated cell nor index yet.} +no associated full cell nor index yet.} \ccMethod{void associate_vertex_with_full_cell(Full_cell_handle c, int i, Vertex_handle v);} {Sets the \ccc{i}-th vertex of \ccc{c} to \ccc{v} and, if \ccc{v} is non-NULL, -sets \ccc{c} as the incident cell of \ccc{v}.} +sets \ccc{c} as the incident full cell of \ccc{v}.} \ccMethod{void set_neighbors(Full_cell_handle ci, int i, Full_cell_handle cj, int j);} @@ -466,13 +436,13 @@ dimension is not -2.} erasing the references to \ccc{v} in other parts of the triangulation.} \ccMethod{void delete_full_cell(Full_cell_handle c);} -{Remove the cell \ccc{c} from the triangulation. This does not take care of +{Remove the full cell \ccc{c} from the triangulation. This does not take care of erasing the references to \ccc{c} in other parts of the triangulation.} \ccMethod{template< typename ForwardIterator > void delete_full_cells(ForwardIterator start, ForwardIterator end);} -{Remove the cells in the range \ccc{[start,end)} from the triangulation. -This does not take care of erasing the references to these cells in other parts of +{Remove the full cells in the range \ccc{[start,end)} from the triangulation. +This does not take care of erasing the references to these full cells in other parts of the triangulation.} \end{ccAdvanced} @@ -481,17 +451,17 @@ the triangulation.} \ccMethod{bool is_valid(bool verbose = true, int level = 0) const;} {Partially checks whether \ccVar\ is a triangulation. This function -returns \ccc{true} if each vertex is a vertex of the cell of which it -claims to be a vertex, if the vertices of every cell are pairwise distinct, -if the neighbor relationship is symmetric, and if neighboring cells share +returns \ccc{true} if each vertex is a vertex of the full cell of which it +claims to be a vertex, if the vertices of every full cell are pairwise distinct, +if the neighbor relationship is symmetric, and if neighboring full cells share exactly \ccVar.\ccc{current_dimension()} vertices and the induced -orientation of these two cells are compatible. +orientation of these two full cells are compatible. It prints an error message if one of these conditions is violated and the \ccc{verbose} parameter is \ccc{true}. Passing these tests does not garanty that we have a triangulation (abstract pure complex). In particular, for example, it is not -checked whether cells that share \ccVar.\ccc{current_dimension()} vertices +checked whether full cells that share \ccVar.\ccc{current_dimension()} vertices are neighbors in the data structure.} \ccHeading{Input/Output} % ---------------------------- I/O @@ -508,10 +478,10 @@ equal to \ccVar.\ccc{ambient_dimension()}.} The information stored in the \ccc{iostream} is: the current dimension (which must be \ccc{<=} \ccVar.\ccc{ambient_dimension()}), the number of vertices, -the number of cells, the indices of the vertices of each cell and then the -indices of the neighbors of each cell, where the index corresponds to the -preceding list of cells. -If the TDS vertices and full cells contains some extra information +the number of full cells, the indices of the vertices of each full cell and then the +indices of the neighbors of each full cell, where the index corresponds to the +preceding list of full cells. +If the \ccc{TriangulationDataStructure} vertices and full cells contains some extra information (i.e. geometric information) the classes \ccc{Vertex} and \ccc{Full_cell} has to provide the relevant I/O operators. @@ -519,6 +489,6 @@ If the TDS vertices and full cells contains some extra information \ccSeeAlso \ccc{TriangulationDSVertex}\\ -\ccc{TriangulationDSSimplex} +\ccc{TriangulationDSFullCell} \end{ccRefConcept} diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationFace.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationFace.tex index 94fa1237d5d..7ff2d6d9b89 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationFace.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationFace.tex @@ -5,38 +5,38 @@ A \ccRefName\ simply describes a \ccc{k}-face \ccc{f} in a triangulation. It gives access to a handle to a full cell \ccc{c} containing the face \ccc{f} in its boundary, as well as the indices of the vertices of \ccc{f} in -\ccc{c}. It must hold that \ccc{f} is a \textbf{proper} face of cell +\ccc{c}. It must hold that \ccc{f} is a \em{proper} face of full cell \ccc{c}, {i.e.}, the dimension of \ccc{f} is strictly less than the dimension of \ccc{c}. \ccTypes \ccNestedType{Full_cell_handle}{Must be the same as the nested type -\ccc{TDS::Full_cell_handle} of the \ccc{TDS} in which the \ccc{TriangulationFace} is +\ccc{TriangulationDataStructure::Full_cell_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationFace} is defined/used.} \ccNestedType{Vertex_handle}{Must be the same as the nested type -\ccc{TDS::Vertex_handle} of the \ccc{TDS} in which the \ccc{TriangulationFace} is +\ccc{TriangulationDataStructure::Vertex_handle} of the \ccc{TriangulationDataStructure} in which the \ccc{TriangulationFace} is defined/used.} \ccHasModels -\ccc{Triangulation_face}. +\ccc{Triangulation_face}. \ccCreation \ccCreationVariable{f} There is no default constructor, since the ambient dimension (the maximal -dimension of the simplices) must be known by the constructors of a \ccRefName. +dimension of the full cells) must be known by the constructors of a \ccRefName. \ccConstructor{Triangulation_face(Triangulation_face g);}{Copy constructor.} \ccConstructor{Triangulation_face(Full_cell_handle c);}{Sets the \ccc{Face}'s -cell to \ccc{c}. \ccPrecond \ccc{s} must be a handle to an existing -cell (not the default-constructed \ccc{Full_cell_handle()}).} +full cell to \ccc{c}. \ccPrecond \ccc{c} must be a handle to an existing +full cell (not the default-constructed \ccc{Full_cell_handle()}).} \ccConstructor{Triangulation_face(const int ad);}{Setup the \ccc{Face} knowing -the ambient dimension \ccc{ad}. Sets the \ccc{Face}'s cell to the +the ambient dimension \ccc{ad}. Sets the \ccc{Face}'s full cell to the default-constructed one.} \ccHeading{Access functions} @@ -70,6 +70,6 @@ vertex of the face. \ccSeeAlso \ccc{TriangulationDataStructure}, \\ -\ccc{Triangulation_face}. +\ccc{Triangulation_face}. \end{ccRefConcept} diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationFullCell.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationFullCell.tex index e67284a13dd..3076940e53c 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationFullCell.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationFullCell.tex @@ -3,8 +3,8 @@ \ccDefinition The concept \ccRefName\ describes the requirements on the type used by the -class \ccc{Triangulation}, and its derived classes, to -represent a cell. +class \ccc{Triangulation}, and its derived classes, to +represent a full cell. \ccRefines @@ -13,41 +13,41 @@ represent a cell. We only list below the additional specific requirements of \ccRefName. Compared to \ccc{TriangulationDSFullCell}, the main difference is the addition of -methods to access and iterate over the position of the cell's vertices as -well as a method for constructing the center of the cell's circumsphere. +methods to access and iterate over the position of the full cell's vertices as +well as a method for constructing the center of the full cell's circumsphere. \ccHasModels -\ccc{Triangulation_full_cell} +\ccc{Triangulation_full_cell} \ccTypes \ccNestedType{Point}% -{The type of the point stored in the cell's vertices. It must be the same +{The type of the point stored in the full cell's vertices. It must be the same as the point type \ccc{TriangulationTraits::Point} (or its refined concepts) -defined by the geometric traits of the \ccc{Triangulation} +defined by the geometric traits of the \ccc{Triangulation} class.} \ccNestedType{Point_const_iterator}{An iterator over the points of the -cell.} +full cell.} \ccCreationVariable{c} \ccOperations \ccMethod{Point_const_iterator points_begin() const;} -{Returns an iterator pointing to the first point of the cell.} +{Returns an iterator pointing to the first point of the full cell.} \ccGlue \ccMethod{Point_const_iterator points_end() const;} -{Returns an iterator pointing beyond the last point of the cell.} +{Returns an iterator pointing beyond the last point of the full cell.} \ccMethod{Point circumcenter() const;}{Returns the center of the sphere -circumscribing the cell.} +circumscribing the full cell.} \ccSeeAlso -\ccc{Triangulation_full_cell}\\ +\ccc{Triangulation_full_cell}\\ \ccc{TriangulationVertex}\\ -\ccc{Triangulation} +\ccc{Triangulation} \end{ccRefConcept} diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationTraits.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationTraits.tex index ef497a473e3..be72d58b90f 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationTraits.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationTraits.tex @@ -3,14 +3,14 @@ \ccDefinition The concept \ccRefName\ describes the various types and functions that a class -must provide as the first parameter (\ccc{TrTraits}) to the class template -\ccc{Triangulation}. It brings the geometric ingredient to the +must provide as the first parameter (\ccc{TriangulationTraits}) to the class template +\ccc{Triangulation}. It brings the geometric ingredient to the definition of a triangulation, while the combinatorial ingredient is brought by -the second template parameter, \ccc{TDS}. +the second template parameter, \ccc{TriangulationDataStructure}. Inserting a range of points in a triangulation is optimized using spatial sorting, thus besides the requirements below, -a class provided as \ccc{TrTraits} should also satisfies the concept +a class provided as \ccc{TriangulationTraits} should also satisfies the concept \ccc{SpatialSortingTraits_d}. \ccRefines @@ -47,7 +47,7 @@ the templated operator\\\ccc{template bool operator()(ForwardIterator start, ForwardIterator end, const Point_d & p)}.\\The operator returns \ccc{true} if and only if point \ccc{p} is contained in the affine space spanned by the points in the range \ccc{[start, -end)}. That affine space is also called the \textbf{affine hull} of the points +end)}. That affine space is also called the \em{affine hull} of the points in the range. \ccPrecond The $k$ points in the range must be affinely independent. diff --git a/Triangulation/doc_tex/Triangulation_ref/TriangulationVertex.tex b/Triangulation/doc_tex/Triangulation_ref/TriangulationVertex.tex index afbccd2d032..8fdb9d629ab 100644 --- a/Triangulation/doc_tex/Triangulation_ref/TriangulationVertex.tex +++ b/Triangulation/doc_tex/Triangulation_ref/TriangulationVertex.tex @@ -3,7 +3,7 @@ \ccDefinition The concept \ccRefName\ describes the requirements on the type used by the -class \ccc{Triangulation}, and its derived classes, to +class \ccc{Triangulation}, and its derived classes, to represent a vertex. \ccRefines @@ -17,23 +17,23 @@ an embedding of the vertex into a geometric point. \ccHasModels -\ccc{Triangulation_vertex} +\ccc{Triangulation_vertex} \ccTypes \ccNestedType{Point}{The type of the point stored in the vertex. It must be -the same as the point type \ccc{TrTraits::Point} (or its refined +the same as the point type \ccc{TriangulationTraits::Point} (or its refined concepts) when the \ccc{TriangulationVertex} is used in the class -\ccc{Triangulation} (or its derived classes).} +\ccc{Triangulation} (or its derived classes).} \ccCreation \ccCreationVariable{v} -\ccConstructor{TriangulationVertex(Full_cell_handle s, const Point & p);}% -{Constructs a vertex with incident cell \ccc{s}. The vertex is embedded at point \ccc{p}.} +\ccConstructor{TriangulationVertex(Full_cell_handle c, const Point & p);}% +{Constructs a vertex with incident full cell \ccc{c}. The vertex is embedded at point \ccc{p}.} \ccGlue\ccConstructor{TriangulationVertex(const Point & p);}% -{Same as above, but without incident cell.}%{ (Who would have guessed?)} +{Same as above, but without incident full cell.}%{ (Who would have guessed?)} \ccGlue\ccConstructor{TriangulationVertex();}% {Same as above, but with a default-constructed \ccc{Point}.} @@ -58,8 +58,8 @@ the point and other possible information.} \ccSeeAlso -\ccc{Triangulation_vertex}\\ +\ccc{Triangulation_vertex}\\ \ccc{TriangulationFullCell}\\ -\ccc{Triangulation} +\ccc{Triangulation} \end{ccRefConcept} diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_data_structure.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_data_structure.tex index 571658271a4..ecbc82db9b2 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_data_structure.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_data_structure.tex @@ -1,4 +1,4 @@ -\begin{ccRefClass}{Triangulation_data_structure} +\begin{ccRefClass}{Triangulation_data_structure} \ccDefinition This class is used for storing the combinatorial information of a triangulation @@ -19,19 +19,19 @@ triggers some optimizations. Or dimension of the simplices (full cells) is passed as an integer argument to an instance constructor (see \ccc{TriangulationDataStructure}).\end{itemize} -\ccc{TDSVertex} is the class to be used as the base \ccc{Vertex} type in the +\ccc{TriangulationDSVertex} is the class to be used as the base \ccc{Vertex} type in the triangulation data structure. It must be a model of the concept \ccc{TriangulationDSVertex}. The class template \ccRefName\ accepts that no second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as -second parameter. In both cases, \ccc{TDSVertex} defaults to +second parameter. In both cases, \ccc{TriangulationDSVertex} defaults to \ccc{CGAL::Triangulation_ds_vertex<>}. -\ccc{TDSFullCell} is the class to be used as the base \ccc{Full_cell} type in +\ccc{TriangulationDSFullCell} is the class to be used as the base \ccc{Full_cell} type in the triangulation data structure. It must be a model of the concept \ccc{TriangulationDSFullCell}. The class template \ccRefName\ accepts that no third parameter be specified. It also accepts the tag \ccc{CGAL::Default} as -third parameter. In both cases, \ccc{TDSFullCell} defaults to +third parameter. In both cases, \ccc{TriangulationDSFullCell} defaults to \ccc{CGAL::Triangulation_ds_full_cell<>}. \ccIsModel @@ -53,17 +53,18 @@ In addition, the class \ccRefName\ provides the following types and methods: \ccNestedType{Full_cell_data} {A data member of type \ccc{Full_cell_data} is stored in every full cell (models -of the concept \ccc{TriangulationDSFullCell}). It is used to mark some full -cells, during modifications of the triangulation data structure.} +of the concept \ccc{TriangulationDSFullCell}). It is used to mark +some +full cells, during modifications of the triangulation data structure.} \ccHeading{Vertex insertion} % - - - - - - - - - - - - - - - - - - INSERTIONS \ccMethod{template< OutputIterator > Full_cell_handle insert_in_tagged_hole( - Vertex_handle v, Facet f, OutputIterator new_simplices);} -{A set \ccc{C} of simplices satisfying the same condition as in method + Vertex_handle v, Facet f, OutputIterator new_full_cells);} +{A set \ccc{C} of full cells satisfying the same condition as in method \ccRefName\ccc{::insert_in_hole()} is assumed to be marked. This -method creates new simplices from \ccc{Vertex} v to the boundary of \ccc{C}. -The boundary is recognized by checking the mark of the simplices. +method creates new full cells from \ccc{Vertex} v to the boundary of \ccc{C}. +The boundary is recognized by checking the mark of the full cells. This method is used by \ccRefName\ccc{::insert_in_hole()}.} \end{ccAdvanced} diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_full_cell.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_full_cell.tex index ea175e041dd..49ede402fa0 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_full_cell.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_full_cell.tex @@ -1,10 +1,10 @@ -\begin{ccRefClass}{Triangulation_ds_full_cell} +\begin{ccRefClass}{Triangulation_ds_full_cell} \ccDefinition The class \ccRefName\ serves as the default full cell template parameter in the -class \ccc{Triangulation_data_structure}. +class \ccc{Triangulation_data_structure}. This class does not provide any geometric capabilities but only combinatorial (adjacency) information. Thus, if the \ccc{Triangulation_data_structure} is @@ -19,7 +19,7 @@ with some additional attributes tuned for a specific application. \ccParameters -The first template parameter, \ccc{TDS}, must be a model of the +The first template parameter, \ccc{TriangulationDataStructure}, must be a model of the \ccc{TriangulationDataStructure} concept. It defaults to \ccc{void}, which is used to break some dependency cycles. @@ -36,11 +36,11 @@ equivalent to setting \ccc{TDSFullCellStoragePolicy} to When the second parameter is specified, its possible ``values'' are:\begin{itemize} -\item \ccc{CGAL::Default}, which is the \textbf{default} value. In that case, the +\item \ccc{CGAL::Default}, which is the \em{default} value. In that case, the policy \ccc{CGAL::TDS_full_cell_default_storage_policy} is used. \item \ccc{CGAL::TDS_full_cell_default_storage_policy}. In that case, the mirror -indices are \textbf{not stored}. +indices are {not stored}. \item \ccc{CGAL::TDS_full_cell_mirror_storage_policy}. In that case, the mirror indices are stored. @@ -53,6 +53,6 @@ See the user manual \note{TODO} for how to choose the second option. \ccSeeAlso -\ccc{Triangulation_ds_vertex} +\ccc{Triangulation_ds_vertex} \end{ccRefClass} diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_vertex.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_vertex.tex index 73998713b48..420ed3fadd7 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_vertex.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_vertex.tex @@ -1,10 +1,10 @@ -\begin{ccRefClass}{Triangulation_ds_vertex} +\begin{ccRefClass}{Triangulation_ds_vertex} \ccDefinition The class \ccRefName\ serves as the default vertex template parameter in the -class \ccc{Triangulation_data_structure}. +class \ccc{Triangulation_data_structure}. This class does not contain any geometric information but only combinatorial (adjacency) information. Thus, if the \ccc{Triangulation_data_structure} is @@ -20,7 +20,7 @@ example). \ccParameters -The template parameter \ccc{TDS} must be a model of the +The template parameter \ccc{TriangulationDataStructure} must be a model of the \ccc{TriangulationDataStructure} concept. It defaults to \ccc{void}, which is used to break some dependency cycles. @@ -30,6 +30,6 @@ used to break some dependency cycles. \ccSeeAlso -\ccc{Triangulation_ds_full_cell} +\ccc{Triangulation_ds_full_cell} \end{ccRefClass} diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_face.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_face.tex index 96b64359372..9e511a08c6b 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_face.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_face.tex @@ -1,4 +1,4 @@ -\begin{ccRefClass}{Triangulation_face} +\begin{ccRefClass}{Triangulation_face} \ccDefinition @@ -6,7 +6,7 @@ A \ccRefName\ is a model of the concept \ccc{TriangulationFace}. \ccParameters -\ccc{TDS} must be a \textbf{very loose} model of the concept +Parameter \ccc{TriangulationDataStructure} must be a \em{very loose} model of the concept \ccc{TriangulationDataStructure} in that it must only provide the types\begin{itemize} \item \ccc{Full_cell_handle}, diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_full_cell.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_full_cell.tex index 1d26d102aec..8378d23689c 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_full_cell.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_full_cell.tex @@ -1,10 +1,10 @@ -\begin{ccRefClass}{Triangulation_full_cell} +\begin{ccRefClass}{Triangulation_full_cell} \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}. +\ccc{Triangulation}. A \ccRefName\ stores handles to the vertices of the cell as well as handles to its neighboring cells. @@ -13,22 +13,23 @@ to its neighboring cells. \ccParameters -\ccc{TrTraits} must be a model of the concept \ccc{TriangulationTraits}. It +\ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. It provides geometric types and predicates for use in the -\ccc{Triangulation} class. +\ccc{Triangulation} class. \ccc{Data} is an optional type of data to be stored in the vertex class. The class template \ccRefName\ accepts that no second parameter be specified. In this case, \ccc{Data} defaults to \ccc{CGAL::No_full_cell_data}. -\ccc{TDSFullCell} must be a model of the concept \ccc{TriangulationDSFullCell}. +Parameter \ccc{TriangulationDSFullCell} must be a model of the concept +\ccc{TriangulationDSFullCell}. The class template \ccRefName\ accepts that no third parameter be specified. It also accepts the tag \ccc{CGAL::Default} as third parameter. In both -cases, \ccc{TDSFullCell} defaults to \ccc{CGAL::Triangulation_ds_full_cell<>}. +cases, \ccc{TriangulationDSFullCell} defaults to \ccc{CGAL::Triangulation_ds_full_cell<>}. \ccInheritsFrom -\ccc{TDSFullCell} (the third template parameter) +\ccc{TriangulationDSFullCell} (the third template parameter) \ccIsModel @@ -61,15 +62,15 @@ The parameter \ccc{t} is passed to the \ccc{Data} constructor.} \ccFunction{istream & operator>>(istream & is, Triangulation_full_cell & v);}% {Inputs the non-combinatorial information given by the cell, {i.e.}, the point and other possible information. The data of type \ccc{Data} is -\textbf{also} read.} +{also} read.} \ccFunction{ostream & operator<<(ostream & os, const Triangulation_full_cell & v);}% {Outputs the non-combinatorial information given by the cell, {i.e.}, the point and other possible information. The data of type \ccc{Data} is -\textbf{also} written.} +{also} written.} \ccSeeAlso -\ccc{Triangulation_vertex} +\ccc{Triangulation_vertex} \end{ccRefClass} diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_locate_type.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_locate_type.tex index 92a809c05e8..83bbdb1c668 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_locate_type.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_locate_type.tex @@ -4,7 +4,7 @@ \ccDefinition The enum \ccRefName\ is defined by the class \ccc{Triangulation} to specify -in what kind of simplex a point has been located in a triangulation. +in what kind of face a point has been located in a triangulation. \ccEnum{enum Locate_type {ON_VERTEX, IN_FACE, IN_FACET, IN_FULL_CELL, OUTSIDE_CONVEX_HULL, OUTSIDE_AFFINE_HULL};} diff --git a/Triangulation/doc_tex/Triangulation_ref/Triangulation_vertex.tex b/Triangulation/doc_tex/Triangulation_ref/Triangulation_vertex.tex index 40b7f849a0a..5953f038232 100644 --- a/Triangulation/doc_tex/Triangulation_ref/Triangulation_vertex.tex +++ b/Triangulation/doc_tex/Triangulation_ref/Triangulation_vertex.tex @@ -1,10 +1,10 @@ -\begin{ccRefClass}{Triangulation_vertex} +\begin{ccRefClass}{Triangulation_vertex} \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}. +\ccc{Triangulation}. A \ccRefName\ stores a point and an incident full cell. @@ -12,23 +12,24 @@ A \ccRefName\ stores a point and an incident full cell. \ccParameters -\ccc{TrTraits} must be a model of the concept \ccc{TriangulationTraits}. It +\ccc{TriangulationTraits} must be a model of the concept \ccc{TriangulationTraits}. It provides geometric types and predicates for use in the -\ccc{Triangulation} class. It is of interest here for its +\ccc{Triangulation} class. It is of interest here for its declaration of the \ccc{Point} type. \ccc{Data} is an optional type of data to be stored in the vertex class. The class template \ccRefName\ accepts that no second parameter be specified. In this case, \ccc{Data} defaults to \ccc{CGAL::No_vertex_data}. -\ccc{TDSVertex} must be a model of the concept \ccc{TriangulationDSVertex}. The +Parameter +\ccc{TriangulationDSVertex} must be a model of the concept \ccc{TriangulationDSVertex}. The class template \ccRefName\ accepts that no third parameter be specified. It also accepts the tag \ccc{CGAL::Default} as third parameter. In both cases, -\ccc{TDSVertex} defaults to \ccc{CGAL::Triangulation_ds_vertex<>}. +\ccc{TriangulationDSVertex} defaults to \ccc{CGAL::Triangulation_ds_vertex<>}. \ccInheritsFrom -\ccc{TDSVertex} (the third template parameter) +\ccc{TriangulationDSVertex} (the third template parameter) \ccIsModel @@ -49,12 +50,12 @@ type.} \ccConstructor{template< typename T> Triangulation_vertex(Full_cell_handle c, -const Point & p, const T & t);}{Constructs a vertex with incident cell +const Point & p, const T & t);}{Constructs a vertex with incident full cell \ccc{c}. The vertex is embedded at point \ccc{p} and the parameter \ccc{t} is passed to the \ccc{Data} constructor.} \ccGlue\ccConstructor{template< typename T> Triangulation_vertex(const Point -& p, const T & t);}{Same as above, but without incident cell.} +& p, const T & t);}{Same as above, but without incident full cell.} \ccGlue\ccConstructor{Triangulation_vertex();}% {Same as above, but with default-constructed \ccc{Point} and \ccc{Data}.} @@ -69,15 +70,15 @@ passed to the \ccc{Data} constructor.} \ccFunction{istream & operator>>(istream & is, Triangulation_vertex & v);}% {Inputs the non-combinatorial information given by the vertex, {i.e.}, the point and other possible information. The data of type \ccc{Data} is -\textbf{also} read.} +{also} read.} \ccFunction{ostream & operator<<(ostream & os, const Triangulation_vertex & v);}% {Outputs the non-combinatorial information given by the vertex, {i.e.}, the point and other possible information. The data of type \ccc{Data} is -\textbf{also} written.} +{also} written.} \ccSeeAlso -\ccc{Triangulation_full_cell} +\ccc{Triangulation_full_cell} \end{ccRefClass} diff --git a/Triangulation/doc_tex/Triangulation_ref/intro.tex b/Triangulation/doc_tex/Triangulation_ref/intro.tex index 14f4ef566c3..3b80f048ffc 100644 --- a/Triangulation/doc_tex/Triangulation_ref/intro.tex +++ b/Triangulation/doc_tex/Triangulation_ref/intro.tex @@ -13,27 +13,28 @@ The basic triangulation class of \cgal\ is primarily designed to represent the triangulations of a set of points $A$ in $\R^d$. It can be viewed as a partition of the convex hull of $A$ into simplices whose -vertices are the points of $A$. Together with the unbounded cells having +vertices are the points of $A$. Together with the unbounded full cells having the convex hull boundary as its frontier, the triangulation forms a partition of $\R^d$. In order to deal only with full dimensional simplices (full cells), which is convenient for many -applications, the space outside the convex hull is subdivided into simplices by +applications, the space outside the convex hull is subdivided into +full cells by considering that each convex hull facet is incident to an infinite -cell having as vertex an auxiliary vertex called the infinite -vertex. In that way, each facet is incident to exactly two cells and +full cell having as vertex an auxiliary vertex called the infinite +vertex. In that way, each facet is incident to exactly two full cells and special cases at the boundary of the convex hull are simple to deal with. -A triangulation is a collection of vertices and cells that are linked -together through incidence and adjacency relations. Each cell gives +A triangulation is a collection of vertices and full cells that are linked +together through incidence and adjacency relations. Each full cell gives access to its its incident vertices and to its its adjacent -cells. Each vertex gives access to one of its incident cells. +full cells. Each vertex gives access to one of its incident full cells. -The vertices of a cell are indexed in positive +The vertices of a full cell are indexed in positive orientation, the positive orientation being defined by the orientation -of the underlying Euclidean space $\R^d$. The neighbors of a cell are also +of the underlying Euclidean space $\R^d$. The neighbors of a full cell are also indexed in such a way that the neighbor indexed by $i$ is opposite to the vertex with the same index. @@ -47,7 +48,7 @@ is opposite to the vertex with the same index. \ccRefConceptPage{TriangulationDataStructure} -The above concept is also abbreviated as \ccc{TDS}. It defines three types, +The above concept is also abbreviated as \ccc{TriangulationDataStructure}. It defines three types, \ccc{Vertex}, \ccc{Full_cell} and \ccc{Face}, that must respectively fulfill the following concepts: @@ -55,9 +56,6 @@ following concepts: \ccRefConceptPage{TriangulationDSFullCell}\\ \ccRefConceptPage{TriangulationFace} -The above first two concepts are also abbreviated respectively as -\ccc{TDSVertex} and \ccc{TDSFullCell}. - \subsubsection*{(Geometric) triangulations} \ccRefConceptPage{TriangulationTraits}\\ @@ -67,8 +65,8 @@ The above first two concepts are also abbreviated respectively as \ccRefConceptPage{TriangulationVertex}\\ \ccRefConceptPage{TriangulationFullCell} -The above concepts are also abbreviated respectively as \ccc{TrTraits}, -\ccc{DTTraits}, +The above concepts are also abbreviated respectively as \ccc{TriangulationTraits}, +\ccc{DelaunayTriangulationTraits}, %\ccc{RTTraits}, \ccc{TrVertex} and \ccc{TrFullCell}. @@ -76,20 +74,20 @@ The above concepts are also abbreviated respectively as \ccc{TrTraits}, \subsubsection*{Triangulation data structure} -\ccRefIdfierPage{CGAL::Triangulation_data_structure}\\ -\ccRefIdfierPage{CGAL::Triangulation_ds_vertex}\\ -\ccRefIdfierPage{CGAL::Triangulation_ds_full_cell} +\ccRefIdfierPage{CGAL::Triangulation_data_structure}\\ +\ccRefIdfierPage{CGAL::Triangulation_ds_vertex}\\ +\ccRefIdfierPage{CGAL::Triangulation_ds_full_cell} -\ccRefIdfierPage{CGAL::Triangulation_face} +\ccRefIdfierPage{CGAL::Triangulation_face} \subsubsection*{(Geometric) triangulations} -\ccRefIdfierPage{CGAL::Triangulation}\\ -\ccRefIdfierPage{CGAL::Delaunay_triangulation} -%\ccRefIdfierPage{CGAL::Regular_triangulation} +\ccRefIdfierPage{CGAL::Triangulation}\\ +\ccRefIdfierPage{CGAL::Delaunay_triangulation} +%\ccRefIdfierPage{CGAL::Regular_triangulation} -\ccRefIdfierPage{CGAL::Triangulation_vertex}\\ -\ccRefIdfierPage{CGAL::Triangulation_full_cell} +\ccRefIdfierPage{CGAL::Triangulation_vertex}\\ +\ccRefIdfierPage{CGAL::Triangulation_full_cell} \subsection{Enums} diff --git a/Triangulation/doc_tex/Triangulation_ref/main.tex b/Triangulation/doc_tex/Triangulation_ref/main.tex index 48966f535c3..abb376d0ba2 100644 --- a/Triangulation/doc_tex/Triangulation_ref/main.tex +++ b/Triangulation/doc_tex/Triangulation_ref/main.tex @@ -6,6 +6,8 @@ % Concepts \input{Triangulation_ref/TriangulationDataStructure.tex} +\input{Triangulation_ref/Tds_vertex.tex} +\input{Triangulation_ref/Tds_full_cell.tex} \input{Triangulation_ref/TriangulationDSVertex.tex} \input{Triangulation_ref/TriangulationDSFullCell.tex}