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

implementing reviews of concept TDS

This commit is contained in:
Olivier Devillers 2012-05-25 14:45:48 +00:00
parent 0ce7e7e53b
commit 53d5c41759
26 changed files with 300 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitattributes vendored
View File

@ -4247,6 +4247,8 @@ Triangulation/doc_tex/Triangulation_ref/fig/insert-in-face.pdf -text
Triangulation/doc_tex/Triangulation_ref/fig/insert-in-face.png -text
Triangulation/doc_tex/Triangulation_ref/fig/insert-in-hole.pdf -text
Triangulation/doc_tex/Triangulation_ref/fig/insert-in-hole.png -text
Triangulation/doc_tex/Triangulation_ref/fig/insert-increase-dim.pdf -text
Triangulation/doc_tex/Triangulation_ref/fig/insert-increase-dim.png -text
Triangulation/doc_tex/Triangulation_ref/intro.tex -text
Triangulation/doc_tex/Triangulation_ref/main.tex -text
Triangulation/dont_submit -text

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

@ -15,26 +15,26 @@ it under insertions (and deletions in the Delaunay case).
\section{Introduction\label{triangulation:intro}}
A \em{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
\em{faces} or \em{simplices} (the
singular of which is \em{simplex}).
{\em faces} or {\em simplices} (the
singular of which is {\em simplex}).
%
A simplex $s\in S$ is \em{maximal} if it is not a proper subset of some other
set in $S$. The simplicial complex is \em{pure} %(or \em{homogeneous})
A simplex $s\in S$ is {\em maximal} if it is not a proper subset of some other
set in $S$. The simplicial complex is {\em pure} %(or {\em homogeneous})
if all the maximal simplices have the same cardinality, i.e., they have the same
number of vertices.
In the sequel, we will call these maximal simplices \em{full cells}.
A \em{face} of a simplex is a subset of it.
A \em{proper face} of a simplex is a strict subset of it.
In the sequel, we will call these maximal simplices {\em full cells}.
A {\em face} of a simplex is a subset of it.
A {\em proper face} of a simplex is a strict subset of it.
If the vertices are embedded into Euclidean space $\real^d$, we deal with
\em{finite simplicial complexes} which have slightly different simplices
{\em finite simplicial complexes} which have slightly different simplices
and additional requirements:
\begin{itemize}
\item vertices corresponds to points in space.
@ -48,7 +48,7 @@ entry} for more about simplicial complexes.
This \cgal\ package deals with pure finite simplicial complexes
without boundary, which
we will simply call in the sequel \em{triangulations}. It provides three main classes
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,
@ -69,7 +69,7 @@ infinite full cells to triangulate the outside of the convex hull.
The class \ccc{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} adds further
constraints to a triangulation, in that all its simplices must have the
so-called \em{Delaunay} or \em{empty-ball} property: the interior of
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.
@ -94,15 +94,15 @@ affinely independent.
If the maximal dimension of a simplex in the triangulation is
$d$, we call:\begin{itemize}
\item an $i$-face for some $i\in[0,d]$ a \em{face};
\item a $0$-face a \em{vertex};
\item a $1$-face an \em{edge};
\item a $(d-2)$-face a \em{ridge};
\item a $(d-1)$-face a \em{facet}; and
\item a $d$-face a \em{full cell}.
\item an $i$-face for some $i\in[0,d]$ a {\em face};
\item a $0$-face a {\em vertex};
\item a $1$-face an {\em edge};
\item a $(d-2)$-face a {\em ridge};
\item a $(d-1)$-face a {\em facet}; and
\item a $d$-face a {\em full cell}.
\end{itemize}
Two faces $\sigma$ and $\sigma'$ are \em{incident} if and only if
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}}
@ -119,11 +119,11 @@ TriangulationDSFullCell>}. For simplicity, we use the abbreviation \tds.
A \tds\ can represent an abstract pure complex,
such that any facet is incident to exactly two full cells.
A \tds\ has a property called the \em{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 \em{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$.
@ -145,7 +145,7 @@ The special meaning of negative values for $d$ will be explain below.
%% dimension. This means that, whatever the current dimension is, a
%% full cell is always represented by the \ccc{FullCell} nested type, And a
%% \ccc{Facet} represents a face of dimension \ccc{current_dimension()-1}
%% \em{and not} \ccc{ambient_dimension()-1}.
%% {\em and not} \ccc{ambient_dimension()-1}.
\subsubsection{The data structure triangulates $\sphere^\cd$}
@ -155,17 +155,17 @@ i.e., its faces can be embedded to form a partition of
$\sphere^\cd$ into $\cd$-simplices.
% When a
% \tds\ is used as the combinatorial part of a geometric triangulation, one
% special vertex of the \tds\ plays the role of the \em{vertex at
% special vertex of the \tds\ plays the role of the {\em vertex at
% infinity}; we can consider that the triangulation covers the whole
% affine hull of its vertices
% using \em{infinite} or \em{unbounded} full cells to fill the space outside the convex
% using {\em infinite} or {\em unbounded} full cells to fill the space outside the convex
% hull of the triangulation's finite vertices. (More details are given in the next section.)
One nice consequence of the above important fact is that a full cell has
always exactly $\cd+1$ neighbors.
Two full cells $\sigma$ and $\sigma'$ sharing a facet are called
\em{neighbors}.
{\em neighbors}.
Possible values of $\cd$ (the \emph{current dimension} of the triangulation) include
@ -204,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$ \em{opposite} to
$\sigma$; in other words, it is the neighbor of $\sigma$ {\em opposite} to
the $i$-th vertex of $\sigma$.
\begin{figure}[htbp]
@ -258,7 +258,7 @@ concepts: \ccc{Triangulation_ds_vertex<TriangulationDataStructure>} and
can see, take the \tds\ as a template parameter in order to get access to
some nested types in \tds.
\em{This creates a circular dependency}, which we resolve in the same way
{\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
@ -294,7 +294,7 @@ 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{c} in a triangulation data structure. The other
full cells neighboring \ccc{c} are automatically subdivided to match the
full cells adjacent to \ccc{c} are automatically subdivided to match the
subdivision of the full cell \ccc{c}. The barycentric subdivision of \ccc{c} is
obtained by enumerating all the faces of \ccc{c} in order of decreasing
dimension, from the dimension of~\ccc{c} to dimension~1, and inserting a new
@ -330,7 +330,7 @@ triangulation into Euclidean space. More precisely, it
maintains a triangulation (a partition into pairwise interior-disjoint
full cells) of the convex hull of the points (the embedded vertices) of the
triangulation, as well as a triangulation of the complement of the convex hull
\em{in the affine subspace} spanned by the triangulation's points
{\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
@ -339,7 +339,7 @@ as well as the localization of a query point inside the triangulation.
Infinite full cells outside the convex hull are each incident to
a finite facet on the convex hull of the triangulation and to a unique special
\em{vertex at infinity}.
{\em vertex at infinity}.
%\note{In every infinite full cell, the vertex at infinity always has index $0$.}
%\note{SH: the above note this should go in the documentation of the
%\ccc{TriangulationDataStructure} concept, or that of the class?}
@ -455,17 +455,17 @@ visits \emph{only} the infinite full cells but stores handles to them into a
The class \ccc{CGAL::Delaunay_triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} derives from
\ccc{CGAL::Triangulation<DelaunayTriangulationTraits, TriangulationDataStructure>} and adds further constraints to a
triangulation, in that all its full cells must have the so-called
\em{Delaunay} or \em{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 \em{circumscribing ball} of a full cell 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 \em{circumscribing sphere} of a face \ccc{c} 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:
@ -476,8 +476,8 @@ triangulation even in these cases.
When a new point \ccc{p} is inserted into a Delaunay triangulation, the
finite full cells whose circumscribing sphere contain \ccc{p} are said to
\em{be in conflict} with point \ccc{p}. The set of full cells that are in
conflict with \ccc{p} form the \em{conflict zone}. That conflict zone is
{\em be in conflict} with point \ccc{p}. The set of full cells that are in
conflict with \ccc{p} form the {\em conflict zone}. That conflict zone is
augmented with the infinite full cells whose finite facet does not lie
anymore on the convex hull of the triangulation (with \ccc{p} added). The full cells
in the conflict zone are removed, leaving a hole that contains \ccc{p}. That

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

@ -103,9 +103,9 @@ const;}
\ccHasModels
\ccc{Cartesian_d<FT, Dim, LA>},\\
\ccc{Simple_cartesian_d<FT, Dim, LA>},\\
\ccc{Filtered_kernel_d} (recommended)
\ccc{CGAL::Cartesian_d<FT, Dim, LA>},\\
\ccc{CGAL::Simple_cartesian_d<FT, Dim, LA>},\\
\ccc{CGAL::Filtered_kernel_d} (recommended)
\ccSeeAlso

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

@ -108,7 +108,7 @@ 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 \em{which is assumed} to contain
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}

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

@ -46,7 +46,7 @@ subspace Aff. It is guaranteed that the affine subspace Aff is given a
consistent orientation when it is called many times with simplex points (in
range \ccc{[start,end)}) living in a same affine subspace.\\
\textbf{Important.} Information about the affine subspace Aff is computed
\em{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
@ -72,9 +72,9 @@ side_of_oriented_subphere_d_object() const;}
\ccHasModels
\ccc{Cartesian_d<FT, Dim, LA>},\\
\ccc{Simple_cartesian_d<FT, Dim, LA>},\\
\ccc{Filtered_kernel_d<K>} (recommended).
\ccc{CGAL::Cartesian_d<FT, Dim, LA>},\\
\ccc{CGAL::Simple_cartesian_d<FT, Dim, LA>},\\
\ccc{CGAL::Filtered_kernel_d<K>} (recommended).
\ccSeeAlso

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

@ -208,14 +208,14 @@ Returns the (modified) output iterator.
incident_full_cells(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f},
{i.e.}, the full cells that have the \ccc{Face f} as a subface.
Returns the (probably modified) output iterator.
Returns the output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
star(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the full cells that share at least one vertex with the \ccc{Face
f}. Returns the (probably modified) output iterator.
f}. Returns the output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
}
@ -228,31 +228,31 @@ constructed.
\ccPrecond$0 < d$.
}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_upper_faces(Vertex_const_handle v, int d, OutputIterator
out);}{Constructs all the \em{upper} \ccc{Face}s of dimension \ccc{d}
incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\
Assuming some total ordering on the vertices of the triangulation (which is
invariant as long as no vertex is inserted in or removed from the triangulation), a
\ccc{Face} incident to \ccc{v} is an \em{upper} \ccc{Face} if and only if
its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In
particular, taking the disjoint union of the upper \ccc{Face}s of dimension
\ccc{d} incident to every vertex of the triangulation yields exactly the set of
faces of dimension \ccc{d} of the triangulation.\\ The constructed \ccc{Faces} are
lexicographically ordered using the vertex order as base ordering. In order to
make it easy to find the infinite \ccc{Faces}, the latter ordering makes the
vertex at infinity the smallest vertex; so calling the method on a finite
vertex will construct only finite faces and calling it on the vertex at
infinity will produce all infinite \ccc{d}-faces. (Elle est pas belle, la vie
?) If $d\geq $\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
constructed.
\ccPrecond$0 < d$.
}
% \ccMethod{template< typename OutputIterator > OutputIterator
% incident_upper_faces(Vertex_const_handle v, int d, OutputIterator
% out);}{Constructs all the {\em upper} \ccc{Face}s of dimension \ccc{d}
% incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\
% Assuming some total ordering on the vertices of the triangulation (which is
% invariant as long as no vertex is inserted in or removed from the triangulation), a
% \ccc{Face} incident to \ccc{v} is an {\em upper} \ccc{Face} if and only if
% its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In
% particular, taking the disjoint union of the upper \ccc{Face}s of dimension
% \ccc{d} incident to every vertex of the triangulation yields exactly the set of
% faces of dimension \ccc{d} of the triangulation.\\ The constructed \ccc{Faces} are
% lexicographically ordered using the vertex order as base ordering. In order to
% make it easy to find the infinite \ccc{Faces}, the latter ordering makes the
% vertex at infinity the smallest vertex; so calling the method on a finite
% vertex will construct only finite faces and calling it on the vertex at
% infinity will produce all infinite \ccc{d}-faces. (Elle est pas belle, la vie
% ?) If $d\geq $\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
% constructed.
% \ccPrecond$0 < d$.
% }
\ccGlue\ccMethod{template< typename OutputIterator, typename Comparator >
OutputIterator incident_upper_faces(Vertex_const_handle v, const int d,
OutputIterator out, Comparator cmp);} {Same as above, but uses \ccc{cmp} as
the vertex ordering to define the upper faces.}
% \ccGlue\ccMethod{template< typename OutputIterator, typename Comparator >
% OutputIterator incident_upper_faces(Vertex_const_handle v, const int d,
% OutputIterator out, Comparator cmp);} {Same as above, but uses \ccc{cmp} as
% the vertex ordering to define the upper faces.}
\ccHeading{Faces and Facets} % - - - - - - - - - - - - - - - - - - - - FACETS
@ -263,11 +263,6 @@ the vertex ordering to define the upper faces.}
{Returns the index of the vertex of the full cell
\ccc{c=}\ccVar.\ccc{full_cell(f)} which does {not} belong to \ccc{c}.}
%\begin{ccAdvanced}
%\ccMethod{Face make_empty_face() const;}{Returns an empty \ccc{Face}.}
%%\note{to be removed, internal use only. at least should be advanced}
%\end{ccAdvanced}
\ccHeading{Triangulation traversal} % - - - - - - - - - - - - - - - - - - TRAVERSAL
%\ccMethod{Vertex_const_iterator vertices_begin() const;}{}
@ -356,10 +351,10 @@ having \ccc{v} as a vertex is returned.
\ccc{IN_FACET}, \ccc{ft} is set to one of the two finite facets containing the
\ccc{query} point. The full cell of \ccc{ft} is returned.
\item[$k=$\ccc{c.current_dimension()}] If the \ccc{query} point lies
\em{outside} the convex hull of the points in the triangulation, then
{\em outside} the convex hull of the points in the triangulation, then
\ccc{loc_type} is set to \ccc{OUTSIDE_CONVEX_HULL} and a full cell is returned
as in the \ccc{locate} method above. If the \ccc{query} point lies
\em{inside} the convex hull of the points in the triangulation, then
{\em inside} the convex hull of the points in the triangulation, then
\ccc{loc_type} is set to \ccc{IN_FULL_CELL} and the unique full cell containing
the \ccc{query} point is returned. \end{itemize}}

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

@ -17,8 +17,8 @@ concept.
\ccHasModels
\ccc{Triangulation_ds_full_cell<TriangulationDataStructure,DSFullCellStoragePolicy>}\\
\ccc{Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
\ccc{CGAL::Triangulation_ds_full_cell<TriangulationDataStructure,DSFullCellStoragePolicy>}\\
\ccc{CGAL::Triangulation_full_cell<TriangulationTraits, Data, TriangulationDSFullCell>}
\ccTypes
@ -82,7 +82,7 @@ $0\leq i\leq$\ccc{ambient_dimension()}.}
the full cell \ccVar as a neighbor in the full cell \ccVar\ccc{.neighbor(i);}. If the
returned integer is not negative, it holds that \ccVar.%
\ccc{neighbor(i)->neighbor(j) == }\ccVar. Returns
\ccc{-1} if \ccVar has no neighboring full cell of index \ccc{i}.
\ccc{-1} if \ccVar has no adjacent 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}
@ -103,7 +103,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 full cell
\ccVar. This function works even if the neighboring information stored in the
\ccVar. This function works even if the adjacency information stored in the
neighbor full cell \ccc{*}\ccVar\ccc{.neighbor(i)} is corrupted. This is useful
when temporary corruption is necessary during surgical operation on a
triangulation. \ccPrecond $0\leq
@ -118,7 +118,7 @@ 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 full cell of \ccVar\ to \ccc{n}. Full cell \ccc{n} is
\ccc{i}-th neighbor of \ccVar\ to \ccc{n}. Full cell \ccc{n} is
opposite to the $i$-th vertex of \ccVar.
\ccPrecond $0\leq i\leq$\ccc{ambient_dimension()}.}

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

@ -12,8 +12,8 @@ concept.
\ccHasModels
\ccc{Triangulation_ds_vertex<TriangulationDataStructure>}\\
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccc{CGAL::Triangulation_ds_vertex<TriangulationDataStructure>}\\
\ccc{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccTypes

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

@ -7,14 +7,14 @@ maintaining the combinatorial part of a
$\cd$-dimensional pure simplicial complex (all simplices that are not
sub-faces of another have the same dimension $\cd$).
Its topology is the topology
of the sphere $\sphere^\cd$ with $d\in[-2,\ad]$
or possibly of another $\cd$-dimensional manifold without boundary
(that can be embedded in an higher dimension).
of the sphere $\sphere^\cd$ with $d\in[-2,\ad]$.
%possibly of another $\cd$-dimensional manifold without boundary
%(that can be embedded in a higher dimension).
In a pure (or homogeneous) simplicial $\cd$-complex, all
faces are sub-faces of some $\cd$-simplex. (A
simplex is also a face of itself.) In particular, it does not
contain any $\cd+1$-face, and any $\cd-1$-face belongs to exactly
two $\cd$-dimensional {\em full cell}.
two $\cd$-dimensional {full cells}.
Values of $\cd$ (the \emph{current dimension} of the complex) include \begin{itemize}
@ -42,13 +42,19 @@ An $i$-simplex is a simplex with $i+1$ vertices. An $i$-simplex $\sigma$ is
{incident} to a $j$-simplex $\sigma'$, $j<i$, if and only if $\sigma'$
is a proper face of $\sigma$.
We call a $0$-simplex a {\em vertex}, a $(d-1)$-simplex a {\em facet} and a
$d$-simplex a {\em full cell}. A {\em face} can have any dimension.
Two full cells are {\em adjacent} if they share a facet. Two faces are
{\em incident} if one is included un the other.
\ccHasModels
\ccc{Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
\ccc{CGAL::Triangulation_data_structure<Dimensionality, TriangulationDSVertex, TriangulationDSFullCell>}
\ccTypes
\ccTwo{Triangulation_data_structure::Full_cell_iteratorxx}{}
\ccThree{typedef std::pair<Full_cell_handle, int>}{Facet;}{}
\ccThreeToTwo
\ccNestedType{Vertex}
{
@ -63,11 +69,16 @@ Full cell type.
The concept \ccRefName\ also defines a type for describing facets of the
triangulation with codimension~1:
%\ccTypedef{typedef std::pair<Full_cell_handle, int> Facet;}
\ccNestedType{Facet}
{A facet of a full cell. Its dimension is
\ccc{current_dimension()-1}. \ccc{Facet f(c,i)} represents the facet of
full cell \ccc{c} opposite to its \ccc{i}-th vertex}
\ccThree{typedef std::pair<Full_cell_handle, int>}{Facet;}{}
\ccTypedef{typedef std::pair<Full_cell_handle, int> Facet;}
%\ccNestedType{Facet}
{
\ccc{Facet f(c,i)} represents the facet of
full cell \ccc{c} opposite to its \ccc{i}-th vertex.
Its dimension is \ccc{current_dimension()-1}.
}
\ccThreeToTwo
\ccNestedType{Face}
{A model of the concept \ccc{TriangulationFace}.}
@ -133,11 +144,12 @@ Iterator over the facets of the complex.
\ccCreation
\ccCreationVariable{tds}
\ccConstructor{XXXXXXXXXX(const int dim);} {Creates an instance \ccVar\ of
\ccConstructor{(int dim);} {Creates an instance \ccVar\ of
type \ccRefName. The maximal dimension of its full cells is \ccc{dim} and
\ccVar\ is initialized to the empty triangulation. Thus,
\ccVar.\ccc{current_dimension()} equals \ccc{-2}.
Parameter \ccc{dim} is ignored if the dimension tag is static.}
Parameter \ccc{dim} is ignored if the dimension tag is static.
\ccPrecond \ccc{dim>0}.}
%\ccOperations
@ -173,33 +185,38 @@ contains nothing. 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} full cells. It is assumed
satifying a common criterion. Call them \emph{good} full cells. It is assumed
that the argument \ccc{c} is a good full cell. The full cells are then
recursively explored by examining if, from a given good full cell, its neighboring
recursively explored by examining if, from a given good full cell, its adjacent
full cells are also good.\\
The argument \ccc{tp} is a predicate that takes as argument a \ccc{Facet}
whose containing \ccc{Full_cell} is good. The predicate must return \ccc{true}
whose defining \ccc{Full_cell} is good. The predicate must return \ccc{true}
if the traversal of that \ccc{Facet} leads to a good full cell.\\
All the good full cells are outputted into the last argument \ccc{out}.}
All the good full cells are output into the last argument \ccc{out}.
\ccPrecond \ccc{c!=Full_cell_handle()} and \ccc{tp(c)==true}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_full_cells(Vertex_handle v, OutputIterator out) const;}
{Insert in \ccc{out} all the full cells that are incident to the vertex
\ccc{v}, {i.e.}, the full cells that have the \ccc{Vertex v} as a vertex.
Returns the (modified) output iterator.}
Returns the output iterator.
\ccPrecond \ccc{v!=Vertex_handle()}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_full_cells(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the full cells that are incident to the face \ccc{f},
{i.e.}, the full cells that have the \ccc{Face f} as a subface.
Returns the (probably modified) output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
Returns the output iterator.
\ccPrecond\ccc{f.full_cell()!=Full_cell_handle()}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
star(const Face & f, OutputIterator out) const;}
{Insert in \ccc{out} all the full cells that share at least one vertex with the \ccc{Face
f}. Returns the (probably modified) output iterator.
%\ccPrecond\ccc{is_full_cell(f.full_cell())}.
f}. Returns the output iterator.
%\ccPrecond\ccc{f.full_cell()!=Full_cell_handle()}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
@ -208,55 +225,61 @@ f}. Returns the (probably modified) output iterator.
\ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}. If \ccc{d
>=} \ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
constructed.
\ccPrecond\ccc{0 < d}.
\ccPrecond\ccc{0 < d} and \ccc{v!=Vertex_handle()}.
}
\ccMethod{template< typename OutputIterator > OutputIterator
incident_upper_faces(Vertex_handle v, const int d, OutputIterator
out);}{Constructs all the \em{upper} \ccc{Face}s of dimension \ccc{d}
incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\
Assuming some total ordering on the vertices of the complex (which is
invariant as long as no vertex is inserted in or removed from the complex), a
\ccc{Face} incident to \ccc{v} is an \em{upper} \ccc{Face} if and only if
its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In
particular, taking the disjoint union of the upper \ccc{Face}s of dimension
\ccc{d} incident to every vertex of the complex yields exactly the set of
faces of dimension \ccc{d} of the complex.\\ The constructed \ccc{Faces} are
lexicographically ordered (using the vertex order as base
ordering). If
$d\geq$\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
constructed.
\ccPrecond\ccc{0 < d}.
}
\ccGlue\ccMethod{template< typename OutputIterator, typename Comparator >
OutputIterator incident_upper_faces(Vertex_handle v, const int d,
OutputIterator out, Comparator cmp);} {Same as above, but uses \ccc{cmp} as
the vertex ordering to define the upper faces.}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Since unused from the moment and usage is not clear, I remove it
% for the moment.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% \ccMethod{template< typename OutputIterator > OutputIterator
% incident_upper_faces(Vertex_handle v, const int d, OutputIterator
% out);}{Constructs all the {\em upper} \ccc{Face}s of dimension \ccc{d}
% incident to \ccc{Vertex} v and inserts them in the \ccc{OutputIterator out}.\\
% Assuming some total ordering on the vertices of the complex (which is
% invariant as long as no vertex is inserted in or removed from the complex), a
% \ccc{Face} incident to \ccc{v} is an {\em upper} \ccc{Face} if and only if
% its vertices occur at \ccc{v} or beyond \ccc{v} in the ordering.\\ In
% particular, taking the disjoint union of the upper \ccc{Face}s of dimension
% \ccc{d} incident to every vertex of the complex yields exactly the set of
% faces of dimension \ccc{d} of the complex.\\ The constructed \ccc{Faces} are
% lexicographically ordered (using the vertex order as base
% ordering). If
% $d\geq$\ccVar.\ccc{current_dimension()}, then no \ccc{Face} is
% constructed.
% \ccPrecond\ccc{0 < d} and \ccc{v!=Vertex_handle()}.
% }
% \ccGlue\ccMethod{template< typename OutputIterator, typename Comparator >
% OutputIterator incident_upper_faces(Vertex_handle v, const int d,
% OutputIterator out, Comparator cmp);} {Same as above, but uses \ccc{cmp} as
% the vertex ordering to define the upper faces.}
\ccHeading{Accessing the vertices} % --------------------- ACCESS TO VERTICES
\ccThree{Vertex_iterator}{tds.number_of_full_cells() const}{}
\ccMethod{Vertex_handle vertex(Full_cell_handle c, const int i) const;}%{}
{ Returns a handle to the \ccc{i}-th \ccc{Vertex} of the \ccc{Full_cell} \ccc{c}.
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension()}.}
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension()} and \ccc{c!=Full_cell_handle()}.}
\ccMethod{int mirror_index(Full_cell_handle c, int i) const;}%{}
{Returns the index of the vertex mirror of the \ccc{i}-th vertex of \ccc{c}.
Equivalently, returns the index of \ccc{c} in its \ccc{i}-th neighbor.
Equivalently, returns the index of \ccc{c} as a neighbor of its \ccc{i}-th neighbor.
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension}()\\
and \ccc{c} is not the default constructed \ccc{Full_cell_handle}. }
and \ccc{c!=Full_cell_handle()}. }
\ccMethod{Vertex_handle mirror_vertex(Full_cell_handle c, int i) const;}%{}
{Returns the vertex mirror of the \ccc{i}-th vertex of \ccc{c}.
Equivalently, returns the vertex of the \ccc{i}-th neighbor of \ccc{c}
that is not vertex of \ccc{c}.
\ccPrecond $0\leq i\leq$\ccVar.\ccc{current_dimension}()\\
and \ccc{c} is not the default constructed \ccc{Full_cell_handle}. }
and \ccc{c!=Full_cell_handle()}. }
\ccMethod{Vertex_iterator vertices_begin();}
{
The first vertex of \ccVar.
The first vertex of \ccVar. User has no control on the order.
}
\ccGlue
\ccMethod{Vertex_iterator vertices_end();}
@ -265,6 +288,7 @@ The beyond vertex of \ccVar.
}
\ccHeading{Accessing the full cells} % ------------------- ACCESS TO CELLS
\ccThree{Full_cell_iterator}{tds.number_of_full_cells() const}{}
\ccMethod{Full_cell_handle full_cell(Vertex_handle v) const;}%{}
{Returns a full cell incident to \ccc{Vertex} \ccc{v}. Note that this
@ -280,7 +304,7 @@ and \ccc{c} is not the default constructed \ccc{Full_cell_handle}}
\ccMethod{Full_cell_iterator full_cells_begin();}
{
The first full cell of \ccVar.
The first full cell of \ccVar. User has no control on the order.
}
\ccGlue
\ccMethod{Full_cell_iterator full_cells_end();}
@ -303,10 +327,6 @@ The beyond full cell of \ccVar.
{Returns the index of vertex of the full cell \ccc{c=}\ccVar.\ccc{full_cell(f)}
which does {not} belong to \ccc{c}.}
\ccMethod{Face make_empty_face() const;}{Returns an empty \ccc{Face}
ready to be setup with any $k$-face of the (combinatorial) triangulation with
$k<$\ccVar.\ccc{current_dimension()}. See \ccc{TriangulationFace}.}
%\begin{ccAdvanced}
%
%\ccMethod{bool is_boundary_facet(const Facet & f) const;}
@ -323,12 +343,16 @@ $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
\ccMethod{Vertex_handle insert_in_full_cell(Full_cell_handle c);}
{Inserts a new
vertex \ccc{v} in the full cell \ccc{c} and returns a handle to
it. The full cell
\ccc{c} is subdivided into \ccVar.\ccc{current_dimension())+1} full cells which
share the vertex \ccc{v}.
\ccPrecond Current dimension is positive and \ccc{c} is a full cell of \ccVar.}
\ccc{c} is subdivided into \ccVar.\ccc{current_dimension()}+1 full cells which
share the vertex \ccc{v} (see Figure~\ref{triangulation:fig:insert-full-cell}).
\ccPrecond Current dimension is positive and \ccc{c} is a full cell of
\ccVar.}
\begin{figure}[ht]
\begin{ccTexOnly}
\begin{center}
\includegraphics{Triangulation_ref/fig/insert-in-cell.pdf}
@ -339,10 +363,15 @@ share the vertex \ccc{v}.
<img border=0 src="./fig/insert-in-cell.png" align="middle" alt="The effect of insert_in_full_cell()">
</center>
\end{ccHtmlOnly}
\caption{Insertion in a full cell, $\cd=2$\label{triangulation:fig:insert-full-cell}}
\end{figure}
\ccMethod{Vertex_handle insert_in_face(const Face & f);}
{Inserts a vertex in the triangulation data structure by subdividing the
\ccc{Face f}. Returns a handle to the newly created \ccc{Vertex}.}
\ccc{Face f}. Returns a handle to the newly created \ccc{Vertex} (see
Figure below~\ref{triangulation:fig:insert-face}).}
\begin{figure}[ht]
\begin{ccTexOnly}
\begin{center}
\includegraphics{Triangulation_ref/fig/insert-in-face.pdf}
@ -353,51 +382,87 @@ share the vertex \ccc{v}.
<img border=0 src="./fig/insert-in-face.png" align="middle" alt="The effect of insert_in_face()">
</center>
\end{ccHtmlOnly}
\caption{Insertion in face, $\cd=3$\label{triangulation:fig:insert-face}}
\end{figure}
\ccMethod{Vertex_handle insert_in_facet(const Facet & ft);}
{Inserts a vertex in the triangulation data structure by subdividing the
\ccc{Facet ft}. Returns a handle to the newly created \ccc{Vertex}.}
\ccMethod{template< class ForwardIterator > Vertex_handle
insert_in_hole(ForwardIterator start, ForwardIterator end, Facet f);}{The
full cells in the range $C=$\ccc{[start, end)} are removed, thus forming a hole.
full cells in the range $C=$\ccc{[start, end)} are removed, thus
forming a hole $H$.
A \ccc{Vertex} is inserted and connected to the boundary of the hole in order
to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is returned.
\ccPrecond $C$ must be a (combinatorial) ball 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 (combinatorial) triangulation of the sphere
$\sphere^{d-1}$. $f$ must be on the boundary of $C$.}
to ``fill it''. A \ccc{Vertex_handle} to the new \ccc{Vertex} is returned
(see Figure~\ref{triangulation:fig:insert-hole}).
\ccPrecond
\ccc{c} belongs to $C$ and \ccc{c->neighbor(i)}
does not, with\ccc{f=(c,i)}.
$H$ the union of full cells in $C$ is simply connected and its
boundary $\partial H$ is a
combinatorial triangulation of the sphere $\sphere^{d-1}$.
All vertices of the triangulation are on $\partial H$.
}
\ccGlue
\ccMethod{template< class ForwardIterator, class OutputIterator >
Vertex_handle insert_in_hole(ForwardIterator start, ForwardIterator end, Facet
f, OutputIterator out);}{Same as above, but handles to the new full cells are
appended to the \ccc{out} output iterator.}
\begin{figure}[ht]
\begin{ccTexOnly}
\begin{center}
\includegraphics{Triangulation_ref/fig/insert-in-hole.pdf}
\end{center}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<center>
<img border=0 src="./fig/insert-in-hole.png" align="middle" alt="The effect of insert_in_hole()">
</center>
\end{ccHtmlOnly}
\caption{Insertion in a hole, $\cd=2$\label{triangulation:fig:insert-hole}}
\end{figure}
\ccMethod{Vertex_handle insert_increase_dimension(Vertex_handle star);}
{Transforms a triangulation of the sphere $\sphere^d$ into the
triangulation of the sphere $\sphere^{d+1}$ by adding a new vertex
\ccc{v}.
\ccc{v} is used to triangulate one of the two half-spheres of
$\sphere^{d+1}$ ($v$ is added as $d+2^{th}$ vertex to all
$\sphere^{d+1}$ ($v$ is added as $(d+2)^{th}$ vertex to all
full cells)
and \ccc{star} is used to triangulate the other half-sphere
(all full cells that do not already has star as vertex are duplicated,
(all full cells that do not already have star as vertex are duplicated,
and \ccc{star} replaces \ccc{v} in these full cells).
The indexing of the vertices in the
full cell is such that, if \ccc{f} was a full cell of maximal dimension in the
initial complex, then \ccc{(f,v)}, in this order, is the corresponding full cell
in the updated triangulation. A handle to \ccc{v} is returned.
in the updated triangulation. A handle to \ccc{v} is returned
(see Figure~\ref{triangulation:fig:insert-increase-dim}).
\ccPrecond\ccVar.
If the current dimension is -2 (empty triangulation), then \ccc{star}
has to be ommitted, otherwise
has to be omitted, otherwise
the current dimension must be strictly less than the ambient dimension
and \ccc{star} must be a vertex of \ccVar.}
\begin{figure}[ht]
\begin{ccTexOnly}
\begin{center}
\includegraphics{Triangulation_ref/fig/insert-increase-dim.pdf}
\end{center}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<center>
<img border=0 src="./fig/insert-increase-dim.png" align="middle" alt="The effect of insert_increase_dimension()">
</center>
\end{ccHtmlOnly}
\caption{Insertion, increasing the dimension from $\cd=1$ to $\cd=2$\label{triangulation:fig:insert-increase-dim}}
\end{figure}
\begin{ccAdvanced}
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 full cell to \ccVar\ and
returns a handle to it. The new full cell has no vertex and no neighbor yet.}
@ -418,8 +483,7 @@ j);}
\ccc{cj} to \ccc{ci}.}
\ccMethod{void set_current_dimension(int d);} { Forces the current dimension
of the complex to \ccc{d}. This will have weird consequences if you don't know
what you are doing.
of the complex to \ccc{d}.
\ccPrecond $-1\leq d\leq$\ccc{ambient_dimension()}.}
\end{ccAdvanced}
@ -430,51 +494,88 @@ what you are doing.
{Reinitializes \ccVar\ to the empty complex.}
\ccMethod{Vertex_handle collapse_face(const Face & f);} {Contracts the
\ccc{Face f} to a single vertex. Returns a handle to that vertex. \ccPrecond
The contracted triangulation must be valid ({i.e.}, be a triangulation of
a sphere of dimension \ccVar.\ccc{current_dimension()}).}
\ccc{Face f} to a single vertex. Returns a handle to that vertex
(see Figure~\ref{triangulation:fig:collapse-face}).
\ccPrecond
The boundary of the full cells incident to \ccc{f}
is a topological sphere of dimension
\ccVar.\ccc{current_dimension()}-1).
}
\begin{figure}[ht]
\begin{ccTexOnly}
\begin{center}
\includegraphics{Triangulation_ref/fig/collapse-face.pdf}
\end{center}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<center>
<img border=0 src="./fig/collapse-face.png" align="middle" alt="The effect of collapse_face()">
</center>
\end{ccHtmlOnly}
\caption{Collapsing an edge in dimension $\cd=3$, \ccc{v} is returned\label{triangulation:fig:collapse-face}}
\end{figure}
\ccMethod{void remove_decrease_dimension(Vertex_handle v, Vertex_handle
star);} {This method does exactly the opposite of
\ccc{insert_increase_dimension()}. \ccPrecond Both vertices \ccc{v} and
\ccc{star} must share an edge with all vertices and the current
dimension is not -2.}
\ccc{insert_increase_dimension()}:
\ccc{v} is removed,
full cells not containing \ccc{star} are removed
full cells containing \ccc{star} but not \ccc{v} loose vertex \ccc{star}
full cells containing \ccc{star} and \ccc{v} loose vertex \ccc{v}
(see Figure~\ref{triangulation:fig:insert-increase-dim}).
\ccPrecond
All cells contains either \ccc{star} or \ccc{v}.
Edge \ccc{star-v} exists in the triangulation
and \ccc{current_dimension()!=2}.
}
\begin{ccAdvanced}
\ccMethod{void delete_vertex(Vertex_handle v);}
{Remove the vertex \ccc{v} from the triangulation. This does not take care of
erasing the references to \ccc{v} in other parts of the triangulation.}
{Remove the vertex \ccc{v} from the triangulation.
%This does not take care of
%erasing the references to \ccc{v} in other parts of the triangulation.
}
\ccMethod{void delete_full_cell(Full_cell_handle c);}
{Remove the full cell \ccc{c} from the triangulation. This does not take care of
erasing the references to \ccc{c} in other parts of the triangulation.}
{Remove the full cell \ccc{c} from the triangulation.
%This does not take care of
%erasing the references to \ccc{c} in other parts of the triangulation.
}
\ccMethod{template< typename ForwardIterator > void
delete_full_cells(ForwardIterator start, ForwardIterator end);}
{Remove the full cells in the range \ccc{[start,end)} from the triangulation.
This does not take care of erasing the references to these full cells in other parts of
the triangulation.}
%This does not take care of erasing the references to these full cells in other parts of
%the triangulation.
}
\end{ccAdvanced}
\begin{ccDebug}
\ccHeading{Validity check} % - - - - - - - - - - - - - - - - - - - - VALIDITY
\ccMethod{bool is_valid(bool verbose = true, int level = 0) const;}
\ccMethod{bool is_valid(bool verbose = true) const;}
{Partially checks whether \ccVar\ is a triangulation. This function
returns \ccc{true} if each vertex is a vertex of the full cell of which it
claims to be a vertex, if the vertices of every full cell are pairwise distinct,
if the neighbor relationship is symmetric, and if neighboring full cells share
if the adjacency (neighbor) relationship is symmetric, and if adjacent full cells share
exactly \ccVar.\ccc{current_dimension()} vertices and the induced
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
\ccc{true}. Passing these tests does not guaranty that we have a
triangulation (abstract pure
complex). In particular, for example, it is not
checked whether full cells that share \ccVar.\ccc{current_dimension()} vertices
are neighbors in the data structure.}
\end{ccDebug}
\ccHeading{Input/Output} % ---------------------------- I/O
\ccFunction{istream & operator>>(istream & is, TriangulationDataStructure &
@ -485,16 +586,21 @@ equal to \ccVar.\ccc{ambient_dimension()}.}
\ccFunction{ostream & operator<<(ostream & os, const TriangulationDataStructure
& tds);}
{Writes \ccc{tds} into the stream \ccc{os}}
{Writes \ccc{tds} into the output stream \ccc{os}}
The information stored in the \ccc{iostream} is: the current dimension (which
must be \ccc{<=} \ccVar.\ccc{ambient_dimension()}), the number of vertices,
the number of full cells, the indices of the vertices of each full cell and then the
indices of the neighbors of each full cell, where the index corresponds to the
preceding list of full cells.
If the \ccc{TriangulationDataStructure} vertices and full cells contains some extra information
(i.e. geometric information) the classes \ccc{Vertex} and
\ccc{Full_cell} has to provide the relevant I/O operators.
The information stored in the \ccc{iostream} is:
\\- the current dimension (which must be \ccc{<=}\ccVar.\ccc{ambient_dimension()}),
\\- the number of vertices,
\\- for each vertex the information of that vertex,
\\- the number of full cells,
\\- for each full cell the indices of its vertices and extra information for that full cell,
\\- for each full cell the indices of its neighbors.
The indices of vertices and full cells correspond to the order in the
file, the user cannot control it.
The classes \ccc{Vertex} and
\ccc{Full_cell} has to provide the relevant I/O operators
(possibly empty).
\ccSeeAlso

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

@ -5,7 +5,7 @@
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 \em{proper} face of full 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}.
@ -21,7 +21,7 @@ defined/used.}
\ccHasModels
\ccc{Triangulation_face<TriangulationDataStructure>}.
\ccc{CGAL::Triangulation_face<TriangulationDataStructure>}.
\ccCreation
\ccCreationVariable{f}

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

@ -18,7 +18,7 @@ well as a method for constructing the center of the full cell's circumsphere.
\ccHasModels
\ccc{Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}
\ccc{CGAL::Triangulation_full_cell<TriangulationTraits, TriangulationDSFullCell>}
\ccTypes

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

@ -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 \em{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.
@ -141,9 +141,9 @@ const;}%
\ccHasModels
\ccc{Cartesian_d<FT, Dim, LA>},\\
\ccc{CGAL::Cartesian_d<FT, Dim, LA>},\\
%\ccc{Simple_cartesian_d<FT, Dim, LA>},\\
\ccc{????<K>} (recommended).
\ccc{CGAL::????<K>} (recommended).
\note{The new kernel is currently under developement}
\ccSeeAlso

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

@ -17,7 +17,7 @@ an embedding of the vertex into a geometric point.
\ccHasModels
\ccc{Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccc{CGAL::Triangulation_vertex<TriangulationTraits, Data, TriangulationDSVertex>}
\ccTypes

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

@ -36,7 +36,7 @@ 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 \em{default} value. In that case, the
\item \ccc{CGAL::Default}, which is the {default} value. In that case, the
policy \ccc{CGAL::TDS_full_cell_default_storage_policy} is used.
\item \ccc{CGAL::TDS_full_cell_default_storage_policy}. In that case, the mirror

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

@ -6,7 +6,7 @@ A \ccRefName\ is a model of the concept \ccc{TriangulationFace}.
\ccParameters
Parameter \ccc{TriangulationDataStructure} must be a \em{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},

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

@ -7,7 +7,7 @@ is used by default for representing full cells in the class
\ccc{Triangulation<TriangulationTraits, TriangulationDataStructure>}.
A \ccRefName\ stores handles to the vertices of the cell as well as handles
to its neighboring cells.
to its adjacent cells.
\ccInclude{CGAL/Triangulation_full_cell.h}

BIN
Triangulation/doc_tex/Triangulation_ref/fig/insert-in-hole.pdf
View File

Binary file not shown.

BIN
Triangulation/doc_tex/Triangulation_ref/fig/insert-in-hole.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 36 KiB

After

Width:  |  Height:  |  Size: 25 KiB

BIN
Triangulation/doc_tex/Triangulation_ref/fig/insert-increase-dim.pdf Normal file
View File

Binary file not shown.

BIN
Triangulation/doc_tex/Triangulation_ref/fig/insert-increase-dim.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.0 KiB

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

@ -29,7 +29,7 @@ with.
A triangulation is a collection of vertices and full cells that are linked
together through incidence and adjacency relations. Each full cell gives
access to its its incident vertices and to its its adjacent
access to its incident vertices and to its adjacent
full cells. Each vertex gives access to one of its incident full cells.
The vertices of a full cell are indexed in positive

4
Triangulation/examples/Triangulation/delaunay.cpp
View File

@ -50,7 +50,7 @@ int main(int argc, char **argv)
std::cout << " adding "<<N<<" other points "<< std::endl;
for(int i=0; i<N; ++i){
T::Vertex_handle v;
T::Face f = t.make_empty_face();
T::Face f(t.ambient_dimension());
T::Facet ft;
T::Full_cell_handle c;
T::Locate_type lt;
@ -58,7 +58,7 @@ int main(int argc, char **argv)
Full_cells zone, new_full_cells;
std::back_insert_iterator<Full_cells> out(zone);
c = t.locate(*++rand_it, lt, f, ft, v);
// previously inserted vertex v is a hint for point location (if defined)
// previously inserted vertex v is used as hint for point location (if defined)
T::Facet ftc = t.compute_conflict_zone(*rand_it, c, out);
std::cout<<i<<" conflict zone of size "<<zone.size()<<" -> "<<std::flush;
out = std::back_inserter(new_full_cells);

4
Triangulation/include/CGAL/Delaunay_triangulation.h
View File

@ -102,7 +102,7 @@ public:
using Base::is_infinite;
using Base::is_valid;
using Base::locate;
using Base::make_empty_face;
// using Base::make_empty_face;
using Base::new_full_cell;
using Base::number_of_vertices;
using Base::orientation;
@ -494,7 +494,7 @@ Delaunay_triangulation<DCTraits, TDS>
// Now, compute the conflict zone of v->point() in
// the dark side. This is precisely the set of full_cells
// that we have to glue back into the light side.
Dark_face dark_f = dark_side.make_empty_face();
Dark_face dark_f = Face(dark_side.ambient_dimension());
Dark_facet dark_ft;
typename Dark_triangulation::Locate_type lt;
dark_s = dark_side.locate(v->point(), lt, dark_f, dark_ft);

5
Triangulation/include/CGAL/Triangulation.h
View File

@ -121,11 +121,6 @@ public:
// FACETS OPERATIONS
Face make_empty_face() const
{
return tds().make_empty_face();
}
// works for Face_ = Facet and Face_ = Rotor.
// NOT DOCUMENTED for the Rotor case...
template< typename Face_ >

5
Triangulation/include/CGAL/Triangulation_data_structure.h
View File

@ -301,11 +301,6 @@ public:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - FACETS OPERATIONS
Face make_empty_face() const /* Concept */
{
return Face(ambient_dimension());
}
// works for Face_ = Facet and Face_ = Rotor.
// NOT DOCUMENTED for the Rotor case...
template< typename Face_ >

2
Triangulation/test/Triangulation/tds.cpp
View File

@ -71,7 +71,7 @@ void test(const int d, const string & type)
// << " ( current dimension is " << tds.current_dimension() << " )";
faces.clear();
std::back_insert_iterator<Faces> out(faces);
tds.incident_upper_faces(vit, d, out);
tds.incident_faces(vit, d, out);
typename Faces::iterator fit = faces.begin();
while( fit != faces.end() )
{