after reviews of user manual

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)
+
 
 
 

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

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<DTTraits, TDS>}. It brings the geometric ingredient to
+\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}. It brings the geometric ingredient to
 the definition of a Delaunay complex, while the combinatorial ingredient is
-brought by the second template parameter, \ccc{TDS}.
+brought by the second template parameter, \ccc{TriangulationDataStructure}.
 
 \ccRefines
 

Triangulation/doc_tex/Triangulation_ref/Delaunay_triangulation.tex

@@ -1,4 +1,4 @@
-\begin{ccRefClass}{Delaunay_triangulation<DTTraits, TDS>}
+\begin{ccRefClass}{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
 
 \ccDefinition
 
@@ -14,26 +14,26 @@ means.
 
 \ccParameters
 
-\ccc{DTTraits} is the geometric traits class that provides the geometric types
+\ccc{DelaunayTriangulationTraits} is the geometric traits class that provides the geometric types
-and predicates needed by Delaunay triangulations. \ccc{DTTraits} must be a model of
+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
+\ccc{TriangulationDataStructure} is the class used to store the underlying triangulation data
-structure. \ccc{TDS} must be a model of the concept
+structure. \ccc{TriangulationDataStructure} must be a model of the concept
 \ccc{TriangulationDataStructure}. The class template \ccRefName\ accepts that no
 second parameter be specified. It also accepts the tag \ccc{CGAL::Default} as
-second parameter. In both cases, \ccc{TDS} defaults to
+second parameter. In both cases, \ccc{TriangulationDataStructure} defaults to
 \ccc{Triangulation_data_structure<
-                    Ambient_dimension<DTTraits::Point_d>::type,
+                    Ambient_dimension<DelaunayTriangulationTraits::Point_d>::type,
-                    Triangulation_vertex<DTTraits>,
+                    Triangulation_vertex<DelaunayTriangulationTraits>,
-                    Triangulation_full_cell<DTTraits> >}.
+                    Triangulation_full_cell<DelaunayTriangulationTraits> >}.
 
 
 \ccInheritsFrom
-\ccc{Triangulation<DTTraits, TDS>}.
+\ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}.
 
-The class \ccc{Delaunay_triangulation<DTTraits, TDS>} inherits all the types
+The class \ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} inherits all the types
-defined in the base class \ccc{Triangulation<DTTraits, TDS>}. Additionally, it
+defined in the base class \ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}. Additionally, it
 defines or overloads the following methods:
 
 \ccCreation % - - - - - - - - - - - - - - - - - - - - - - - - - - - CREATION
@@ -43,7 +43,7 @@ defines or overloads the following methods:
 \ccConstructor{Delaunay_triangulation(const int dim, const Geom_traits k =
 Geom_traits());}{Instantiates a Delaunay triangulation with one vertex (the vertex
 at infinity). See the description of the inherited nested type
-\ccc{Triangulation<DTTraits, TDS>::Ambient_dimension} for an explanation of
+\ccc{Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>::Ambient_dimension} for an explanation of
 the use of the parameter \ccc{dim}. The complex stores a copy of the geometric
 traits \ccc{k}.}
 
@@ -52,7 +52,7 @@ traits \ccc{k}.}
 
 \ccMethod{Full_cell_handle remove(Vertex_handle v);}{Remove the vertex \ccc{v}
 from the Delaunay triangulation. If the current dimension of the triangulation has not
-changed after the removal, then the returned cell \ccc{c} geometrically
+changed after the removal, then the returned full cell \ccc{c} geometrically
 contains the removed vertex \ccc{v} (\ccc{c} can be finite or infinite).
 Otherwise, the default-constructed \ccc{Full_cell_handle} is returned.
 \ccPrecond \ccc{v} is a vertex of the triangulation, different from the
@@ -62,8 +62,8 @@ Otherwise, the default-constructed \ccc{Full_cell_handle} is returned.
 % the Delaunay triangulation. If a vertex is found at position \ccc{p}, it is removed
 % from it, otherwise, the default-constructed \ccc{Full_cell_handle} is returned.
 % If \ccc{p} is found and if the current dimension of the complex has not
-% changed after the removal, then the returned simplex \ccc{s} geometrically
+% changed after the removal, then the returned full cell \ccc{c} geometrically
-% contains the removed point \ccc{p} (\ccc{s} can be finite or infinite).
+% 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
+OutputIterator out) const;}{Outputs handles to the full cells in confict with
-point \ccc{p} into the \ccc{OutputIterator out}. The cell \ccc{c} is used
+point \ccc{p} into the \ccc{OutputIterator out}. The full cell \ccc{c} is used
-as a starting point for gathering the cells in conflict with \ccc{p}. 
+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$.
 }

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

Triangulation/doc_tex/Triangulation_ref/Triangulation.tex

@@ -1,36 +1,36 @@
-\begin{ccRefClass}{Triangulation<TrTraits, TDS>}
+\begin{ccRefClass}{Triangulation<TriangulationTraits, TriangulationDataStructure>}
 
 \ccDefinition
 
-The class \ccRefName\ is used to store and query the cells and vertices of
+The class \ccRefName\ is used to store and query the full cells and vertices of
 a triangulation embedded in $\real^d$.
 
 \ccInclude{CGAL/Triangulation.h}
 
 \ccParameters
 
-\ccc{TrTraits} is the geometric traits class that provides the geometric types
+\ccc{TriangulationTraits} is the geometric traits class that provides the geometric types
-and predicates needed by triangulations. \ccc{TrTraits} must be a model of the
+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
+\ccc{TriangulationDataStructure} is the class used to store the underlying triangulation data
-structure. \ccc{TDS} must be a model of the concept
+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<TrTraits::Point_d>::type,
+\ccc{Triangulation_data_structure<Ambient_dimension<TriangulationTraits::Point_d>::type,
-Triangulation_vertex<TrTraits>, Triangulation_full_cell<TrTraits>>}.
+Triangulation_vertex<TriangulationTraits>, Triangulation_full_cell<TriangulationTraits>>}.
 
 \ccTypes
 
 %The following types are self-explanatory: % but we are explaining anyway
 
-\ccTypedef{typedef TrTraits Geom_traits;}%
+\ccTypedef{typedef TriangulationTraits Geom_traits;}%
 {The model for the \ccc{TriangulationTraits} concept.}
 
-\ccTypedef{typedef  TrTraits::Point_d Point;}{A point in Euclidean space.}
+\ccTypedef{typedef  TriangulationTraits::Point_d Point;}{A point in Euclidean space.}
 
-\ccTypedef{typedef Ambient_dimension<TrTraits::Point_d>::type
+\ccTypedef{typedef Ambient_dimension<TriangulationTraits::Point_d>::type
  Ambient_dimension;}%
 {This indicates whether the dimension of the ambient Euclidean space is static
 (\ccc{Ambient_dimension}=\ccGlobalScope\ccc{Dimension_tag<int dim>}) or
@@ -38,46 +38,40 @@ dynamic (\ccc{Ambient_dimension}=\ccGlobalScope\ccc{Dynamic_dimension_tag}).
 In the latter case, the \ccc{dim} parameter passed to the class's constructor
 is used.}
 
-\ccTypedef{typedef TDS Triangulation_ds;}%
+\ccTypedef{typedef TriangulationDataStructure Triangulation_ds;}%
 {The second template parameter.}
 
-\ccTypedef{typedef TDS::Vertex Vertex;}{A model of the concept
+\ccTypedef{typedef TriangulationDataStructure::Vertex Vertex;}{A model of the concept
 \ccc{TriangulationVertex}.}
 \ccGlue
-\ccTypedef{typedef TDS::Full_cell Full_cell;}{A model of the concept
+\ccTypedef{typedef TriangulationDataStructure::Full_cell Full_cell;}{A model of the concept
 \ccc{TriangulationFullCell}.}
 \ccGlue
-\ccTypedef{typedef TDS::Facet Facet;}{}
+\ccTypedef{typedef TriangulationDataStructure::Facet Facet;}{}
 \ccGlue
-\ccTypedef{typedef TDS::Face Face;}%
+\ccTypedef{typedef TriangulationDataStructure::Face Face;}%
 {A model of the concept \ccc{TriangulationFace}.}
 
-The vertices and cells of triangulations are accessed through handles,
+The vertices and full cells of triangulations are accessed through handles,
 iterators and circulators. A handle is a model of the \ccc{Handle} concept,
 and supports the two dereference operators \ccc{operator*} and
 \ccc{operator->}. A circulator is a model of the concept \ccc{Circulator}.
 Iterators and circulators are bidirectional and non-mutable.
-%The edges and facets of the triangulation can also be visited through
-%iterators and circulators which are bidirectional and non-mutable.
 
 Iterators and circulators are convertible to the corresponding handles, thus
 the user can pass them directly as arguments to the functions.
 
-\ccTypedef{typedef  TDS::Vertex_handle            Vertex_handle;}{}
+\ccTypedef{typedef  TriangulationDataStructure::Vertex_handle            Vertex_handle;}{}
-\ccGlue\ccTypedef{typedef  TDS::Vertex_iterator    Vertex_iterator;}{}
+\ccGlue\ccTypedef{typedef  TriangulationDataStructure::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  TDS::Full_cell_handle           Full_cell_handle;}{}
+\ccTypedef{typedef  TriangulationDataStructure::Full_cell_handle           Full_cell_handle;}{}
-\ccGlue\ccTypedef{typedef  TDS::Full_cell_iterator         Full_cell_iterator;}{}
+\ccGlue\ccTypedef{typedef  TriangulationDataStructure::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  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
+{Returns the number of full cells of maximal dimension in the triangulation
-(cells incident to the vertex at infinity are counted).}
+(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
+{Insert in \ccc{out} all the full cells that are incident to the vertex
-\ccc{v}, {i.e.}, the cells that have the \ccc{Vertex v} as a 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},
+{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f},
-{i.e.}, the cells that have the \ccc{Face f} as a subface.
+{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
+{Returns the index of the vertex of the full cell
-\ccc{c=}\ccVar.\ccc{full_cell(f)} which does \textbf{not} belong to \ccc{c}.}
+\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,
+{If the point \ccc{query} lies inside a bounded (finite) full cell of \ccVar,
-the latter cell is returned.\\
+the latter full cell is returned.\\
-If \ccc{query} lies on the boundary of some finite cells, one of them
+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 $\{
+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 cell $(p_1, p_2,
+p_1, p_2, \ldots, p_d, \infty\}$ is returned such that the full cell $(p_1, p_2,
 \ldots, p_d, query)$ is positively oriented (the rest of the triangulation lies
 on the other side of facet $(p_1, p_2, \ldots, p_d)$).\\
 The optional argument \ccc{hint} is used as a starting place for the search.}
 
 \ccMethod{Full_cell_handle locate(const Point & query, Vertex_handle hint)
 const;}
-{Same as above but \ccc{hint} is a vertex and not a cell.}
+{Same as above but \ccc{hint} is a vertex and not a full cell.}
 
 \ccMethod{Full_cell_handle locate(const Point & query, Locate_type & loc_type,
 Face & f, Facet & ft, Full_cell_handle hint = Full_cell_handle()) const;}
@@ -370,27 +340,27 @@ Face & f, Facet & ft, Full_cell_handle hint = Full_cell_handle()) const;}
 search.\\ If the \ccc{query} point lies outside the affine hull of the points,
 which can happen when \ccVar.\ccc{current_dimension() < }
 \ccVar.\ccc{ambient_dimension()}, \ccc{loc_type} is set to
-\ccc{OUTSIDE_AFFINE_HULL}, and the returned cell has no meaning. As a
+\ccc{OUTSIDE_AFFINE_HULL}, and the returned full cell has no meaning. As a
 particular case, if there is no finite vertex yet in the triangulation,
 \ccc{loc_type} is set to \ccc{OUTSIDE_AFFINE_HULL} and \textit{locate} returns
 \ccc{Full_cell_handle()}.\\ If the \ccc{query} point lies inside the affine hull
-of the points, a $k$-face that contains \ccc{query} \textbf{in its relative
+of the points, a $k$-face that contains \ccc{query} {in its relative
 interior} is returned. (If the $k$-face is finite, it is
 unique.)\begin{itemize} \item[$k=0$] \ccc{loc_type} is set to \ccc{ON_VERTEX},
-\ccc{f} is set to the vertex \ccc{v} the \ccc{query} lies on and a cell
+\ccc{f} is set to the vertex \ccc{v} the \ccc{query} lies on and a full cell
 having \ccc{v} as a vertex is returned.
 \item[$0<k<$\ccc{c.current_dimension()-1}] \ccc{loc_type} is set to
 \ccc{IN_FACE}, \ccc{f} is set to the unique finite face containing the
-\ccc{query} point. A cell having \ccc{f} on its boundary is returned.
+\ccc{query} point. A full cell having \ccc{f} on its boundary is returned.
 \item[$k=$\ccc{c.current_dimension()-1}] \ccc{loc_type} is set to
 \ccc{IN_FACET}, \ccc{ft} is set to one of the two finite facets containing the
-\ccc{query} point. The cell of \ccc{ft} is returned.
+\ccc{query} point. The full cell of \ccc{ft} is returned.
 \item[$k=$\ccc{c.current_dimension()}] If the \ccc{query} point lies
-\textbf{outside} the convex hull of the points in the triangulation, then
+\em{outside} the convex hull of the points in the triangulation, then
-\ccc{loc_type} is set to \ccc{OUTSIDE_CONVEX_HULL} and a cell is returned
+\ccc{loc_type} is set to \ccc{OUTSIDE_CONVEX_HULL} and a full cell is returned
 as in the \ccc{locate} method above. If the \ccc{query} point lies
-\textbf{inside} the convex hull of the points in the triangulation, then
+\em{inside} the convex hull of the points in the triangulation, then
-\ccc{loc_type} is set to \ccc{IN_FULL_CELL} and the unique cell containing
+\ccc{loc_type} is set to \ccc{IN_FULL_CELL} and the unique full cell containing
 the \ccc{query} point is returned. \end{itemize}}
 
 \ccMethod{Full_cell_handle
@@ -443,27 +413,27 @@ point \ccc{p} into the triangulation and returns a handle to the
 The point \ccc{p} is inserted in the \ccc{Face f}. \item[\ccc{IN_FACET}]
 The point \ccc{p} is inserted in the \ccc{Facet ft}. \item[Anything else]
 The point \ccc{p} is inserted in the triangulation according to the value
-of \ccc{loc_type}, using the cell \ccc{c}.\end{itemize} This method is used
+of \ccc{loc_type}, using the full cell \ccc{c}.\end{itemize} This method is used
 internally by the other \ccc{insert()} methods.}
 
 \ccMethod{template < typename ForwardIterator, typename OutputIterator >
 Vertex_handle insert_in_hole(const Point & p, ForwardIterator s,
-ForwardIterator e, const Facet & ft, OutputIterator out);}{The cells in
+ForwardIterator e, const Facet & ft, OutputIterator out);}{The full cells in
 the range $C=$\ccc{[s, e)} are removed, thus forming a hole. A \ccc{Vertex} is
 inserted at position \ccc{p} and connected to the boundary of the hole in
 order to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is
 returned. The facet \ccc{ft} must lie on the boundary of $C$ and its
-defining cell, \ccVar.\ccc{full_cell(ft)} must lie inside $C$. Handles
+defining full cell, \ccVar.\ccc{full_cell(ft)} must lie inside $C$. Handles
-to the newly created cells are output in the \ccc{out} output iterator.
+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
+\emph{etc.}), the number of full cells, the indices of the vertices of each
-cell, plus the non-combinatorial information about each cell, then the
+full cell, plus the non-combinatorial information about each full cell, then the
-indices of the neighbors of each cell, where the index corresponds to the
+indices of the neighbors of each full cell, where the index corresponds to the
-preceding list of cells.
+preceding list of full cells.
 
 \ccSeeAlso
 
-\ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>},\\
+\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>},\\
-\ccc{Delaunay_triangulation<DTTraits, TDS>},\\
+\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>},\\
-%\ccc{Regular_triangulation<RTTraits, TDS>}.
+%\ccc{Regular_triangulation<RTTraits, TriangulationDataStructure>}.
 
 \end{ccRefClass}
 

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

Triangulation/doc_tex/Triangulation_ref/TriangulationDSVertex.tex

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

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<TrTraits, TDS>} or a
+\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>} or a
-\ccc{Delaunay_triangulation<DTTraits, TDS>}), this vertex
+\ccc{Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}), this vertex
 corresponds to \emph{the vertex at infinity}.
 
 \item[0] This corresponds to two vertices, each incident to one $0$-face;
-the two cells being neighbor of each other. This is the unique
+the two full cells being neighbor of each other. This is the unique
 triangulation of the $0$-sphere.
 
 \item[$d>0$] This corresponds to a standard triangulation of the sphere
@@ -34,25 +34,23 @@ $\sphere^d$.
 \end{itemize}
 
 An $i$-simplex is a simplex with $i+1$ vertices. An $i$-simplex $\sigma$ is
-\textbf{incident} to a $j$-simplex $\sigma'$, $j<i$, if and only if $\sigma'$
+{incident} to a $j$-simplex $\sigma'$, $j<i$, if and only if $\sigma'$
 is a proper face of $\sigma$. 
-%Two simplices are \textbf{adjacent} if the
-%intersection of their vertex-set is not empty.
 
 \ccHasModels
 
-\ccc{Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>}
+\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
 
 \ccTypes
 
 \ccNestedType{Vertex}
 {
-A model of the concept \ccc{TriangulationDSVertex}.
+Vertex type.
 }
 \ccGlue
 \ccNestedType{Full_cell}
 {
-A model of the concept \ccc{TriangulationDSFullCell}.
+Full cell type.
 }
 
 The concept \ccRefName\ also defines a type for describing facets of the
@@ -67,28 +65,25 @@ full cell \ccc{c} opposite to its \ccc{i}-th vertex}
 \ccNestedType{Face}
 {A model of the concept \ccc{TriangulationFace}.}
 
-Vertices and simplices are manipulated via \emph{handles}. Handles support the
+Vertices and full cells are manipulated via \emph{handles}. Handles support the
 usual two dereference operators \ccc{operator*} and \ccc{operator->}.
 
 \ccNestedType{Vertex_handle}
 {
 Handle to a \ccc{Vertex}.
 }
-%\ccGlue
-%\ccNestedType{Vertex_const_handle}
-%{
-%Handle to a \ccc{const Vertex}.
-%}
 \ccGlue
 \ccNestedType{Full_cell_handle}
 {
 Handle to a \ccc{Full_cell}.
 }
-%\ccGlue
+
-%\ccNestedType{Full_cell_const_handle}
+
-%{
+Requirements for \ccc{Vertex} and \ccc{Full_cell} are described in concepts
-%Handle to a \ccc{const Full_cell}.
+\ccc{TriangulationDataStructure::Vertex} and
-%}
+\ccc{TriangulationDataStructure::FullCell} \lcTex{(
+\ccRefPage{TriangulationDataStructure::Vertex} and
+\ccRefPage{TriangulationDataStructure::FullCell})}.
 
 \begin{ccAdvanced}
 \ccNestedType{template <typename Vb2> struct Rebind_vertex}
@@ -105,7 +100,7 @@ one whose \ccc{TriangulationDSFullCellBase} will be \ccc{Fcb2}.}
 \end{ccAdvanced}
 
 
-Vertices, facets and cells can be iterated over using \emph{iterators}.
+Vertices, facets and full cells can be iterated over using \emph{iterators}.
 Iterators support the usual two dereference operators \ccc{operator*} and
 \ccc{operator->}.
 
@@ -113,21 +108,11 @@ Iterators support the usual two dereference operators \ccc{operator*} and
 {
 Iterator over the list of vertices.
 }
-%\ccGlue
-%\ccNestedType{Vertex_const_iterator}
-%{
-%Iterator over the list of vertices (\ccc{const} casted).
-%}
 \ccGlue
 \ccNestedType{Full_cell_iterator}
 {
-Iterator over the list of cells.
+Iterator over the list of full cells.
 }
-%\ccGlue
-%\ccNestedType{Simplex_const_iterator}
-%{
-%Iterator over the list of simplices (\ccc{const} casted).
-%}
 \ccGlue
 \ccNestedType{Facet_iterator}
 {
@@ -142,7 +127,7 @@ Iterator over the facets of the complex.
 \ccCreationVariable{tds}
 
 \ccConstructor{XXXXXXXXXX(const int dim);} {Creates an instance \ccVar\ of
-type \ccRefName. The maximal dimension of its cells is \ccc{dim} and
+type \ccRefName. The maximal dimension of its full cells is \ccc{dim} and
 \ccVar\ is initialized to the empty triangulation. Thus,
 \ccVar.\ccc{current_dimension()} equals \ccc{-2}.}
 
@@ -151,7 +136,7 @@ type \ccRefName. The maximal dimension of its cells is \ccc{dim} and
 \ccHeading{Queries}	% --------------------------------------------- QUERIES
 
 \ccMethod{int ambient_dimension() const;} { Returns the maximal dimension of
-the cells that can be stored in the triangulation \ccVar. \ccPostcond the
+the full dimensional cells that can be stored in the triangulation \ccVar. \ccPostcond the
 returned value is positive. }
 
 \ccMethod{int current_dimension() const;} { Returns the dimension of the
@@ -160,14 +145,14 @@ full dimensional cells stored in the triangulation. It holds that
 \ccc{true}. \ccPostcond the returned value \ccc{d} satisfies 
 $-2\leq d \leq$\ccVar.\ccc{ambient_dimension()}. }
 
-\ccMethod{bool empty() const;} { Returns \ccc{true} if the regular complex
+\ccMethod{bool empty() const;} { Returns \ccc{true} if thetriangulation
-contains no simplex. Returns \ccc{false} otherwise. }
+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
+satifying a common criteria. Call them \emph{good} full cells. It is assumed
-that the argument \ccc{c} is a good cell. The cells are then
+that the argument \ccc{c} is a good full cell. The full cells are then
-recursively explored by examining if, from a given good cell, its neighboring
+recursively explored by examining if, from a given good full cell, its neighboring
-cells are also good.\\
+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.\\
+if the traversal of that \ccc{Facet} leads to a good full cell.\\
-All the good cells are outputted into the last argument \ccc{out}.}
+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
+{Returns a full cell incident to \ccc{Vertex} \ccc{v}. Note that this
-%\ccMethod{Full_cell_const_handle simplex(Vertex_const_handle v) const;}
+  full cell is
-{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 full cell).
-not unique (\ccc{v} is typically incident to more than one simplex).
 \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)}
+{Returns the index of vertex of the full cell \ccc{c=}\ccVar.\ccc{full_cell(f)}
-which does \textbf{not} belong to \ccc{c}.}
+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
+vertex \ccc{v} in the full cell \ccc{c} and returns a handle to
-\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} cells which
+it. The full cell
+\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} full cells which
 share the vertex \ccc{v}.
-\ccPrecond Current dimension is positive and \ccc{c} is a simplex of \ccVar.}
+\ccPrecond Current dimension is positive and \ccc{c} is a full cell of \ccVar.}
 \begin{ccTexOnly}
 \begin{center}
 \includegraphics{Triangulation_ref/fig/insert-in-cell.pdf}
@@ -355,7 +325,7 @@ share the vertex \ccc{v}.
 \end{ccTexOnly}
 \begin{ccHtmlOnly}
 <center>
-<img border=0 src="./fig/insert-in-cell.png" align="middle" alt="The effect of insert_in_simplex()">
+<img border=0 src="./fig/insert-in-cell.png" align="middle" alt="The effect of insert_in_full_cell()">
 </center>
 \end{ccHtmlOnly}
 
@@ -379,18 +349,18 @@ share the vertex \ccc{v}.
 
 \ccMethod{template< class ForwardIterator > Vertex_handle
 insert_in_hole(ForwardIterator start, ForwardIterator end, Facet f);}{The
-simplices in the range $C=$\ccc{[start, end)} are removed, thus forming a hole.
+full cells in the range $C=$\ccc{[start, end)} are removed, thus forming a hole.
 A \ccc{Vertex} is inserted and connected to the boundary of the hole in order
 to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is returned.
 \ccPrecond $C$ must be a (combinatorial) ball and not contain any vertex
-all of whose incident simplices are in $C$. (This implies that
+all of whose incident full cells are in $C$. (This implies that
 \ccVar.\ccc{current_dimension()}$\geq2$ if $|C|>1$.)\\ The boundary of
 $C$ must be a (combinatorial) triangulation of the sphere
 $\sphere^{d-1}$. $f$ must be on the boundary of $C$.}
 \ccGlue
 \ccMethod{template< class ForwardIterator, class OutputIterator >
 Vertex_handle insert_in_hole(ForwardIterator start, ForwardIterator end, Facet
-f, OutputIterator out);}{Same as above, but handles to the new simplices are
+f, OutputIterator out);}{Same as above, but handles to the new full cells are
 appended to the \ccc{out} output iterator.}
 
 \ccMethod{Vertex_handle insert_increase_dimension(Vertex_handle star);}
@@ -401,11 +371,11 @@ triangulation of the sphere $\sphere^{d+1}$ by adding a new vertex
 $\sphere^{d+1}$ ($v$ is added as $d+2^{th}$ vertex to all
 full cells)
 and \ccc{star} is used to triangulate the other half-sphere
-(all cells that do not already has star as vertex are duplicated,
+(all full cells that do not already has star as vertex are duplicated,
-and \ccc{star} replaces \ccc{v} in these cells).
+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
+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 cell
+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
+\ccMethod{Full_cell_handle new_full_cell();} {Adds a new full cell to \ccVar\ and
-returns a handle to it. The new cell has no vertex and no neighbor yet.}
+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.
+{Remove the full 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
+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
+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 cell are pairwise distinct,
+claims to be a vertex, if the vertices of every full cell are pairwise distinct,
-if the neighbor relationship is symmetric, and if neighboring cells share
+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
+the number of full cells, the indices of the vertices of each full cell and then the
-indices of the neighbors of each cell, where the index corresponds to the
+indices of the neighbors of each full cell, where the index corresponds to the
-preceding list of cells.
+preceding list of full cells.
-If the TDS vertices and full cells contains some extra information
+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}

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<TDS>}.
+\ccc{Triangulation_face<TriangulationDataStructure>}.
 
 \ccCreation
 \ccCreationVariable{f}
 
 There is no default constructor, since the ambient dimension (the maximal
-dimension of the simplices) must be known by the constructors of a \ccRefName.
+dimension of the full cells) must be known by the constructors of a \ccRefName.
 
 \ccConstructor{Triangulation_face(Triangulation_face g);}{Copy constructor.}
 
 \ccConstructor{Triangulation_face(Full_cell_handle c);}{Sets the \ccc{Face}'s
-cell to \ccc{c}. \ccPrecond \ccc{s} must be a handle to an existing
+full cell to \ccc{c}. \ccPrecond \ccc{c} must be a handle to an existing
-cell (not the default-constructed \ccc{Full_cell_handle()}).}
+full cell (not the default-constructed \ccc{Full_cell_handle()}).}
 
 \ccConstructor{Triangulation_face(const int ad);}{Setup the \ccc{Face} knowing
-the ambient dimension \ccc{ad}. Sets the \ccc{Face}'s cell to the
+the ambient dimension \ccc{ad}. Sets the \ccc{Face}'s full cell to the
 default-constructed one.}
 
 \ccHeading{Access functions}
@@ -70,6 +70,6 @@ vertex of the face.
 \ccSeeAlso
 
 \ccc{TriangulationDataStructure}, \\
-\ccc{Triangulation_face<TDS>}.
+\ccc{Triangulation_face<TriangulationDataStructure>}.
 
 \end{ccRefConcept}

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<TrTraits, TDS>}, and its derived classes, to
+class \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}, and its derived classes, to
-represent a cell.
+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
+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 cell's circumsphere.
+well as a method for constructing the center of the full cell's circumsphere.
 
 \ccHasModels
 
-\ccc{Triangulation_full_cell<TrTraits, TDSFullCell>}
+\ccc{Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}
 
 \ccTypes
 
 \ccNestedType{Point}%
-{The type of the point stored in the cell's vertices. It must be the same
+{The type of the point stored in the full cell's vertices. It must be the same
 as the point type \ccc{TriangulationTraits::Point} (or its refined concepts)
-defined by the geometric traits of the \ccc{Triangulation<TrTraits, TDS>}
+defined by the geometric traits of the \ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
 class.}
 
 \ccNestedType{Point_const_iterator}{An iterator over the points of the
-cell.}
+full cell.}
 
 \ccCreationVariable{c}
 
 \ccOperations
 
 \ccMethod{Point_const_iterator points_begin() const;}
-{Returns an iterator pointing to the first point of the cell.}
+{Returns an iterator pointing to the first point of the full cell.}
 \ccGlue
 \ccMethod{Point_const_iterator points_end() const;}
-{Returns an iterator pointing beyond the last point of the cell.}
+{Returns an iterator pointing beyond the last point of the full cell.}
 
 \ccMethod{Point circumcenter() const;}{Returns the center of the sphere
-circumscribing the cell.}
+circumscribing the full cell.}
 
 \ccSeeAlso
 
-\ccc{Triangulation_full_cell<TrTraits, TDSFullCell>}\\
+\ccc{Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}\\
 \ccc{TriangulationVertex}\\
-\ccc{Triangulation<TrTraits, TDS>}
+\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}
 
 \end{ccRefConcept}

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

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

Triangulation/doc_tex/Triangulation_ref/Triangulation_data_structure.tex

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

Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_full_cell.tex

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

Triangulation/doc_tex/Triangulation_ref/Triangulation_ds_vertex.tex

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

Triangulation/doc_tex/Triangulation_ref/Triangulation_face.tex

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

Triangulation/doc_tex/Triangulation_ref/Triangulation_full_cell.tex

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

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};}

Triangulation/doc_tex/Triangulation_ref/Triangulation_vertex.tex

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

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
+full cell having as vertex an auxiliary vertex called the infinite
-vertex. In that way, each facet is incident to exactly two cells and
+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
+A triangulation is a collection of vertices and full cells that are linked
-together through incidence and adjacency relations. Each cell gives
+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},
+The above concepts are also abbreviated respectively as \ccc{TriangulationTraits},
-\ccc{DTTraits}, 
+\ccc{DelaunayTriangulationTraits}, 
 %\ccc{RTTraits},
  \ccc{TrVertex} and \ccc{TrFullCell}.
 
@@ -76,20 +74,20 @@ The above concepts are also abbreviated respectively as \ccc{TrTraits},
 
 \subsubsection*{Triangulation data structure}
 
-\ccRefIdfierPage{CGAL::Triangulation_data_structure<Dimensionality, TDSVertex, TDSFullCell>}\\
+\ccRefIdfierPage{CGAL::Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}\\
-\ccRefIdfierPage{CGAL::Triangulation_ds_vertex<TDS>}\\
+\ccRefIdfierPage{CGAL::Triangulation_ds_vertex<TriangulationDataStructure>}\\
-\ccRefIdfierPage{CGAL::Triangulation_ds_full_cell<TDS, TDSFullCellStoragePolicy>}
+\ccRefIdfierPage{CGAL::Triangulation_ds_full_cell<TriangulationDataStructure, TDSFullCellStoragePolicy>}
 
-\ccRefIdfierPage{CGAL::Triangulation_face<TDS>}
+\ccRefIdfierPage{CGAL::Triangulation_face<TriangulationDataStructure>}
 
 \subsubsection*{(Geometric) triangulations}
 
-\ccRefIdfierPage{CGAL::Triangulation<TrTraits, TDS>}\\
+\ccRefIdfierPage{CGAL::Triangulation<TriangulationTraits, TriangulationDataStructure>}\\
-\ccRefIdfierPage{CGAL::Delaunay_triangulation<DTTraits, TDS>}
+\ccRefIdfierPage{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>}
-%\ccRefIdfierPage{CGAL::Regular_triangulation<RCTraits, TDS>}
+%\ccRefIdfierPage{CGAL::Regular_triangulation<RCTraits, TriangulationDataStructure>}
 
-\ccRefIdfierPage{CGAL::Triangulation_vertex<TrTraits, Data, TDSVertex>}\\
+\ccRefIdfierPage{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}\\
-\ccRefIdfierPage{CGAL::Triangulation_full_cell<TrTraits, Data, TDSFullCell>}
+\ccRefIdfierPage{CGAL::Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
 
 \subsection{Enums}
 

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}