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

remove trailing whitespaces

This commit is contained in:
Sébastien Loriot 2020-04-10 18:15:32 +02:00
parent e2df1a83aa
commit 2876ad9af1
11 changed files with 1109 additions and 1109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
STL_Extension/include/CGAL/internal/boost/array_binary_tree.hpp
View File

@ -13,7 +13,7 @@
// SPDX-License-Identifier: BSL-1.0
//
// NOTE: this file have been taken from boost 1.46.1 for using
// with Modificable_priority_queue (to enhance the
// with Modificable_priority_queue (to enhance the
// non-documented mutable_queue).
// original file is <boost/graph/detail/array_binary_tree.hpp>
//

2
Triangulation_3/benchmark/Triangulation_3/segment_traverser_benchmark.cpp
View File

@ -14,7 +14,7 @@
//
// $URL$
// $Id$
//
//
//
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>

1600
Triangulation_3/doc/Triangulation_3/CGAL/Triangulation_3.h
View File

File diff suppressed because it is too large Load Diff

2
Triangulation_3/doc/Triangulation_3/PackageDescription.txt
View File

@ -31,7 +31,7 @@
\cgalPkgSummaryEnd
\cgalPkgShortInfoBegin
\cgalPkgSince{2.1}
\cgalPkgDependsOn{\ref PkgTDS3}
\cgalPkgDependsOn{\ref PkgTDS3}
\cgalPkgBib{cgal:pt-t3}
\cgalPkgLicense{\ref licensesGPL "GPL" }
\cgalPkgDemo{3D Triangulations,triangulation_3.zip}

356
Triangulation_3/doc/Triangulation_3/Triangulation_3.txt
View File

@ -1,7 +1,7 @@
namespace CGAL {
/*!
\mainpage User Manual
\mainpage User Manual
\anchor Chapter_3D_Triangulations
\anchor chapterTriangulation3
\cgalAutoToc
@ -20,7 +20,7 @@ partition of \f$ \mathbb{R}^3\f$. Its cells (\f$ 3\f$-faces) are such that two c
either do not intersect or share a common facet (\f$ 2\f$-face), edge
(\f$ 1\f$-face) or vertex (\f$ 0\f$-face).
\section Triangulation3secintro Representation
\section Triangulation3secintro Representation
In order to deal
only with tetrahedra, which is convenient for many applications, the
@ -53,9 +53,9 @@ Orientation of a cell (3-dimensional case).
\cgalFigureEnd
As in the underlying combinatorial triangulation (see
Chapter \ref chapterTDS3 "3D Triangulation Data Structure"),
Chapter \ref chapterTDS3 "3D Triangulation Data Structure"),
edges (\f$ 1\f$-faces) and facets (\f$ 2\f$-faces)
are not explicitly
are not explicitly
represented: a facet is given by a cell and an index (the facet
`i` of a cell `c` is the facet of `c` that is opposite to
the vertex with index `i`) and an edge is given by a cell and two
@ -73,9 +73,9 @@ obtained by linking the additional infinite vertex to each facet of
the convex hull of the points.
<UL>
<LI> <I>dimension 2:</I> when a triangulation only contains
coplanar points (which is the case when there are only three points),
coplanar points (which is the case when there are only three points),
it consists of triangular faces.
<LI> <I>dimension 1:</I> the triangulation contains only collinear
<LI> <I>dimension 1:</I> the triangulation contains only collinear
points (which is the case when there are only two points), it consists
of edges.
<LI> <I>dimension 0:</I> the triangulation contains only one
@ -100,7 +100,7 @@ dimension 2, each cell has only one facet of index 3, and 3 edges
A triangulation of \f$ \mathbb{R}^3\f$ is said to be *locally valid* iff
<B>(a)-(b)</B> Its underlying combinatorial graph, the triangulation
data structure, is *locally valid*
data structure, is *locally valid*
(see Section \ref TDS3secintro "Introduction" of Chapter \ref chapterTDS3 "3D Triangulation Data Structure")
<B>(c)</B> Any cell has its vertices ordered according to positive
@ -120,7 +120,7 @@ When all the points are collinear, this condition becomes:
The method `Triangulation_3::is_valid()` checks
the local validity of a given triangulation. This does not always
ensure global validity \cgalCite{mnssssu-cgpvg-96}, \cgalCite{dlpt-ccpps-98} but it is
ensure global validity \cgalCite{mnssssu-cgpvg-96}, \cgalCite{dlpt-ccpps-98} but it is
sufficient for practical cases.
\section Triangulation_3Delaunay Delaunay Triangulation
@ -138,18 +138,18 @@ computes a unique triangulation even in these cases.
This implementation is fully dynamic: it supports insertions of points, vertex removals
and displacements of points.
\section Triangulation3secclassRegulartriangulation Regular Triangulation
\section Triangulation3secclassRegulartriangulation Regular Triangulation
The class `Regular_triangulation_3` implements incremental regular
triangulations, also known as weighted Delaunay triangulations.
Let\f$ {p}^{(w)}=(p,w_p), p\in\mathbb{R}^3, w_p\in\mathbb{R}\f$ and
\f$ {z}^{(w)}=(z,w_z), z\in\mathbb{R}^3, w_z\in\mathbb{R}\f$ be two weighted points.
Let\f$ {p}^{(w)}=(p,w_p), p\in\mathbb{R}^3, w_p\in\mathbb{R}\f$ and
\f$ {z}^{(w)}=(z,w_z), z\in\mathbb{R}^3, w_z\in\mathbb{R}\f$ be two weighted points.
A weighted point
\f$ {p}^{(w)}=(p,w_p)\f$ can also be seen as a sphere of center \f$ p\f$ and
radius \f$ \sqrt{w_p}\f$.
radius \f$ \sqrt{w_p}\f$.
The <I>power product</I> between \f$ {p}^{(w)}\f$ and \f$ {z}^{(w)}\f$ is
defined as
defined as
\f[ \Pi({p}^{(w)},{z}^{(w)}) = {\|{p-z}\|^2-w_p-w_z} \f]
where \f$ \|{p-z}\|\f$ is the Euclidean distance between \f$ p\f$ and \f$ z\f$.
@ -169,7 +169,7 @@ called the <I>power circle</I>. The
two weighted points on the line defined by these two points.
Let \f$ {S}^{(w)}\f$ be a set of weighted points in \f$ \mathbb{R}^3\f$.
Let \f$ {S}^{(w)}\f$ be a set of weighted points in \f$ \mathbb{R}^3\f$.
A sphere \f$ {z}^{(w)}\f$ is said to be
<I>regular</I> if \f$ \forall {p}^{(w)}\in{S}^{(w)},
\Pi{({p}^{(w)},{z}^{(w)})}\geq 0\f$.
@ -178,9 +178,9 @@ A triangulation of \f$ {S}^{(w)}\f$ is <I>regular</I> if the power spheres
of all simplices are regular.
The regular triangulation of
\f$ {S}^{(w)}\f$ is in fact the projection onto \f$ \mathbb{R}^3\f$ of the convex hull
\f$ {S}^{(w)}\f$ is in fact the projection onto \f$ \mathbb{R}^3\f$ of the convex hull
of the four-dimensional points \f$ (p,\|p-O\|^2-w_p),\f$ for
\f$ {p}^{(w)}=(p,w_p)\in{S}^{(w)}\f$.
\f$ {p}^{(w)}=(p,w_p)\in{S}^{(w)}\f$.
Note that all points of \f$ {S}^{(w)}\f$ do not
necessarily appear as vertices of the regular
triangulation. To know more about regular triangulations, see for
@ -192,7 +192,7 @@ Delaunay triangulation.
The implementation of 3D regular triangulation supports insertions of weighted points, and vertex removals. Displacements are not supported in the current implementation.
\section Triangulation3secdesign Software Design
\section Triangulation3secdesign Software Design
The main classes `Triangulation_3`, `Delaunay_triangulation_3` and
`Regular_triangulation_3` are connected to each other by the
@ -225,17 +225,17 @@ Chapter \ref chapterTDS3 "3D Triangulation Data Structure".
triangulation class, described in Section \ref Triangulation3seclocpol.
</UL>
Optionally, the main Delaunay and regular triangulations algorithms (insert, remove)
Optionally, the main Delaunay and regular triangulations algorithms (insert, remove)
support multi-core shared-memory architectures to take advantage of available parallelism.
For this purpose, a model of the concept `SurjectiveLockDataStructure` can be
given as fourth template parameter; it defaults to
For this purpose, a model of the concept `SurjectiveLockDataStructure` can be
given as fourth template parameter; it defaults to
`Spatial_lock_grid_3`. This data structure
allows to lock points with coordinates (x, y, z) in a 3D domain. When a thread owns the
lock on a point, no other thread can lock this point. Locking a facet (resp. a cell)
boils down to locking all its 3 (resp. 4) incident vertices.
boils down to locking all its 3 (resp. 4) incident vertices.
See Section \ref Triangulation_3ParallelAlgorithms for more details.
\subsection Triangulation3secTraits The Geometric Traits Parameter
\subsection Triangulation3secTraits The Geometric Traits Parameter
The first template parameter of the triangulation class
`Triangulation_3<TriangulationTraits_3, TriangulationDataStructure_3>`
@ -252,7 +252,7 @@ class of `Delaunay_triangulation_3` must define predicates to test for the
In addition to the requirements described before, the geometric traits
class of `Regular_triangulation_3` must define predicates to test for the
<I>power distances</I> and orientation tests for <I>power spheres</I>.
<I>power distances</I> and orientation tests for <I>power spheres</I>.
It is described by the concept
`RegularTriangulationTraits_3`, which refines `TriangulationTraits_3`.
@ -262,7 +262,7 @@ All kernels provided by \cgal can all be used as models for the geometric traits
parameter.
\subsection Triangulation3sectds The Triangulation Data Structure Parameter
\subsection Triangulation3sectds The Triangulation Data Structure Parameter
The second template parameter of the main classes (`Triangulation_3`,
`Delaunay_triangulation_3` and `Regular_triangulation_3`) is a
@ -288,17 +288,17 @@ all the triangulation classes, so it need not be specified by the user unless
he wants to use a different triangulation data structure or a different vertex
or cell base class.
\subsection Triangulation3seclocpol The Location Policy Parameter
\subsection Triangulation3seclocpol The Location Policy Parameter
The Delaunay triangulation class supports an optional feature which maintains
an additional data structure for fast point location queries.
an additional data structure for fast point location queries.
The fast location policy should be used when the user inserts points in a random
order or needs to do many unrelated queries.
If the user is able to give a good hint to help the point location of
its queries (and its newly inserted points), then it should prefer the default
policy. In such a case where good hints are provided,
the default policy save some memory (few percents), and is faster.
Notice that if points are not inserted one by one, but as a range, then a good hint is
Notice that if points are not inserted one by one, but as a range, then a good hint is
automatically computed using spatial sort.
Reading Section \ref Triangulation3seccomplexity on complexity and
@ -395,28 +395,28 @@ Section \ref TDS3secdesign "Software Design" provides more detailed information.
\subsection Triangulation_3ParallelAlgorithms Parallel Algorithms
Parallel algorithms of `Delaunay_triangulation_3` and
`Regular_triangulation_3` are enabled
Parallel algorithms of `Delaunay_triangulation_3` and
`Regular_triangulation_3` are enabled
if the `TriangulationDataStructure_3::Concurrency_tag` type is `Parallel_tag` and a
reference to a lock data structure instance is provided via the constructor or
reference to a lock data structure instance is provided via the constructor or
by using `Triangulation_3::set_lock_data_structure`. This data structure
must be a model of the concept `SurjectiveLockDataStructure` and can be
optionally given as a template parameter of the triangulation;
must be a model of the concept `SurjectiveLockDataStructure` and can be
optionally given as a template parameter of the triangulation;
it defaults to `Spatial_lock_grid_3`.
Note that the parallel Delaunay
triangulation must use the default compact location policy (and not the fast
one). If those conditions are fulfilled, the insertion/removal of a
range of points will be performed in parallel, and the individual
Note that the parallel Delaunay
triangulation must use the default compact location policy (and not the fast
one). If those conditions are fulfilled, the insertion/removal of a
range of points will be performed in parallel, and the individual
insert/remove operations will be optionally thread-safe.
Parallel algorithms require the program to be linked against
Parallel algorithms require the program to be linked against
the <a href="https://www.threadingbuildingblocks.org">Intel TBB library</a>.
To control the number of threads used, the user may use the tbb::task_scheduler_init class.
See the <a href="https://www.threadingbuildingblocks.org/documentation">TBB documentation</a>
See the <a href="https://www.threadingbuildingblocks.org/documentation">TBB documentation</a>
for more details.
\section Triangulation3secexamples Examples
\section Triangulation3secexamples Examples
\subsection Triangulation_3BasicExample Basic Example
@ -431,7 +431,7 @@ cell. It uses the default parameter of the `Triangulation_3` class.
The following two examples show how the user can plug his own vertex base in a
triangulation. Changing the cell base is similar.
\subsubsection Triangulation3secexamplescolor Adding a Color
\subsubsection Triangulation3secexamplescolor Adding a Color
When the user doesn't need to add a type in a vertex which depends on the
`TriangulationDataStructure_3` (e.g. a `Vertex_handle` or
@ -457,10 +457,10 @@ The most efficient method to insert (weighted) points in a
Delaunay (or regular) triangulation is to provide an iterator
range over (weighted) points to the insert function. However, an iterator range of
(weighted) points does not allow to set different information to each vertex.
To solve this problem, in the case the vertex type of the triangulation
To solve this problem, in the case the vertex type of the triangulation
is a model of the concept `TriangulationVertexBaseWithInfo_3`
(such as `Triangulation_vertex_base_with_info_3`), we provide three examples
doing the same operation: set an unsigned integer as the information
(such as `Triangulation_vertex_base_with_info_3`), we provide three examples
doing the same operation: set an unsigned integer as the information
of each vertex. The value of this unsigned integer is the initial order
of the corresponding point given in the range.
@ -505,7 +505,7 @@ Note that you only need the iterator type if you combine the pre \cpp 11 `for`-l
\cgalExample{Triangulation_3/for_loop.cpp}
\subsection Triangulation3secsimplex The Simplex Class
\subsection Triangulation3secsimplex The Simplex Class
The triangulation defines a `Triangulation_3::Simplex` class that represents a
simplex (vertex, edge, facet or cell). This example demonstrates how
@ -513,7 +513,7 @@ simplices can be stored in a set.
\cgalExample{Triangulation_3/simplex.cpp}
\subsection Triangulation3exfastlocation Fast Point Location for Delaunay Triangulations
\subsection Triangulation3exfastlocation Fast Point Location for Delaunay Triangulations
\cgalExample{Triangulation_3/fast_location_3.cpp}
@ -545,7 +545,7 @@ be hidden and do not result in vertices in the triangulation.
\subsubsection Triangulation_3RegularTriangulationInfo Regular Triangulation with Custom Vertex
This example shows that one must use the class `Regular_triangulation_vertex_base_3` as vertex base class,
if one has to specifiy the template parameter.
if one has to specifiy the template parameter.
\cgalExample{Triangulation_3/regular_with_info_3.cpp}
@ -578,7 +578,7 @@ Result of the run of the draw_triangulation_3 program. A window shows the 3D tri
\cgalFigureEnd
\section Triangulation3seccomplexity Complexity and Performance
\section Triangulation3seccomplexity Complexity and Performance
In 3D, the worst case complexity of a triangulation is quadratic in the number
of points. For Delaunay triangulations, this bound is reached in cases such as
@ -594,7 +594,7 @@ as points distributed on surfaces under some conditions.
There are several algorithms provided in this package. We will focus here on
the following ones and give practical numbers on their efficiency :
<UL>
<LI>construction of a triangulation from a range of points,
<LI>construction of a triangulation from a range of points,
<LI>location of a point (using the `locate` function),
<LI>removal of a vertex (using the `remove` function).
</UL>
@ -632,170 +632,170 @@ Xeon 3GHz processor and 32GB of RAM (a recent desktop machine as of 2009).
<TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B>
<B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B>
<B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Regular</B>
<B>Regular</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Regular</B>
<B>Regular</B>
<TR>
<TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>%Fast location</B>
<B>%Fast location</B>
<TD ALIGN=RIGHT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>No hidden points</B>
<B>No hidden points</B>
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^2\f$ points
Construction from \f$ 10^2\f$ points
<TD ALIGN=RIGHT NOWRAP>
0.00054
0.00054
<TD ALIGN=RIGHT NOWRAP>
0.000576
0.000576
<TD ALIGN=RIGHT NOWRAP>
0.000948
0.000948
<TD ALIGN=RIGHT NOWRAP>
0.000955
0.000955
<TR>
<TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^3\f$ points
Construction from \f$ 10^3\f$ points
<TD ALIGN=RIGHT NOWRAP>
0.00724
0.00724
<TD ALIGN=RIGHT NOWRAP>
0.00748
0.00748
<TD ALIGN=RIGHT NOWRAP>
0.0114
0.0114
<TD ALIGN=RIGHT NOWRAP>
0.0111
<TR>
<TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^4\f$ points
Construction from \f$ 10^4\f$ points
<TD ALIGN=RIGHT NOWRAP>
0.0785
0.0785
<TD ALIGN=RIGHT NOWRAP>
0.0838
0.0838
<TD ALIGN=RIGHT NOWRAP>
0.122
0.122
<TD ALIGN=RIGHT NOWRAP>
0.117
0.117
<TR>
<TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^5\f$ points
Construction from \f$ 10^5\f$ points
<TD ALIGN=RIGHT NOWRAP>
0.827
0.827
<TD ALIGN=RIGHT NOWRAP>
0.878
0.878
<TD ALIGN=RIGHT NOWRAP>
1.25
1.25
<TD ALIGN=RIGHT NOWRAP>
1.19
1.19
<TR>
<TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^6\f$ points
Construction from \f$ 10^6\f$ points
<TD ALIGN=RIGHT NOWRAP>
8.5
8.5
<TD ALIGN=RIGHT NOWRAP>
9.07
9.07
<TD ALIGN=RIGHT NOWRAP>
12.6
12.6
<TD ALIGN=RIGHT NOWRAP>
12.2
12.2
<TR>
<TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^7\f$ points
Construction from \f$ 10^7\f$ points
<TD ALIGN=RIGHT NOWRAP>
87.4
87.4
<TD ALIGN=RIGHT NOWRAP>
92.5
92.5
<TD ALIGN=RIGHT NOWRAP>
129
129
<TD ALIGN=RIGHT NOWRAP>
125
125
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^2\f$ points
Point location in \f$ 10^2\f$ points
<TD ALIGN=RIGHT NOWRAP>
9.93e-07
9.93e-07
<TD ALIGN=RIGHT NOWRAP>
1.06e-06
1.06e-06
<TD ALIGN=RIGHT NOWRAP>
7.19e-06
7.19e-06
<TD ALIGN=RIGHT NOWRAP>
6.99e-06
6.99e-06
<TR>
<TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^3\f$ points
Point location in \f$ 10^3\f$ points
<TD ALIGN=RIGHT NOWRAP>
2.25e-06
2.25e-06
<TD ALIGN=RIGHT NOWRAP>
1.93e-06
1.93e-06
<TD ALIGN=RIGHT NOWRAP>
1.73e-05
1.73e-05
<TD ALIGN=RIGHT NOWRAP>
1.76e-05
1.76e-05
<TR>
<TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^4\f$ points
Point location in \f$ 10^4\f$ points
<TD ALIGN=RIGHT NOWRAP>
4.79e-06
4.79e-06
<TD ALIGN=RIGHT NOWRAP>
3.09e-06
3.09e-06
<TD ALIGN=RIGHT NOWRAP>
3.96e-05
3.96e-05
<TD ALIGN=RIGHT NOWRAP>
3.76e-05
3.76e-05
<TR>
<TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^5\f$ points
Point location in \f$ 10^5\f$ points
<TD ALIGN=RIGHT NOWRAP>
2.98e-05
2.98e-05
<TD ALIGN=RIGHT NOWRAP>
6.12e-06
6.12e-06
<TD ALIGN=RIGHT NOWRAP>
1.06e-04
1.06e-04
<TD ALIGN=RIGHT NOWRAP>
1.06e-04
1.06e-04
<TR>
<TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^6\f$ points
Point location in \f$ 10^6\f$ points
<TD ALIGN=RIGHT NOWRAP>
1e-04
1e-04
<TD ALIGN=RIGHT NOWRAP>
9.65e-06
9.65e-06
<TD ALIGN=RIGHT NOWRAP>
2.7e-04
2.7e-04
<TD ALIGN=RIGHT NOWRAP>
2.67e-04
2.67e-04
<TR>
<TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^7\f$ points
Point location in \f$ 10^7\f$ points
<TD ALIGN=RIGHT NOWRAP>
2.59e-04
2.59e-04
<TD ALIGN=RIGHT NOWRAP>
1.33e-05
1.33e-05
<TD ALIGN=RIGHT NOWRAP>
6.25e-04
6.25e-04
<TD ALIGN=RIGHT NOWRAP>
6.25e-04
6.25e-04
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
Vertex removal
Vertex removal
<TD ALIGN=RIGHT NOWRAP>
1e-04
1e-04
<TD ALIGN=RIGHT NOWRAP>
1.03e-04
1.03e-04
<TD ALIGN=RIGHT NOWRAP>
1.42e-04
1.42e-04
<TD ALIGN=RIGHT NOWRAP>
1.38e-04
1.38e-04
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
</TABLE>
</CENTER>
@ -809,16 +809,16 @@ in \cgalCite{msri52:liu-snoeyink-05}.
\subsection Triangulation_3ParallelPerformance Parallel Performance
Figure \cgalFigureRef{Triangulation3figparallelspeedup} shows insertion
and removal speed-ups obtained using the parallel version of the
triangulation algorithms of \cgal 4.5. The machine used is a PC running
Windows 7 64-bits with two 6-core
and removal speed-ups obtained using the parallel version of the
triangulation algorithms of \cgal 4.5. The machine used is a PC running
Windows 7 64-bits with two 6-core
Intel Xeon CPU X5660 clocked at 2.80 GHz
with 32GB of RAM. The program has been compiled with
with 32GB of RAM. The program has been compiled with
Microsoft Visual C++ 2012 in Release mode.
\cgalFigureBegin{Triangulation3figparallelspeedup,DT3_parallel_benchmark.png}
Speed-up obtained for the insertion of 1M points randomly generated inside
a cube (red), and the removal of 100K of them (blue), compared
a cube (red), and the removal of 100K of them (blue), compared
to the sequential version of the algorithm.
\cgalFigureEnd
@ -856,48 +856,48 @@ points, as measured empirically using `Memory_sizer` for large triangulations
<TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B>
<B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B>
<B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Regular</B>
<B>Regular</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Regular</B>
<B>Regular</B>
<TR>
<TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>%Fast location</B>
<B>%Fast location</B>
<TD ALIGN=RIGHT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>No hidden points</B>
<B>No hidden points</B>
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
32bit
32bit
<TD ALIGN=RIGHT NOWRAP>
274
274
<TD ALIGN=RIGHT NOWRAP>
291
291
<TD ALIGN=RIGHT NOWRAP>
336
336
<TD ALIGN=RIGHT NOWRAP>
282
282
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
64bit
64bit
<TD ALIGN=RIGHT NOWRAP>
519
519
<TD ALIGN=RIGHT NOWRAP>
553
553
<TD ALIGN=RIGHT NOWRAP>
635
635
<TD ALIGN=RIGHT NOWRAP>
527
527
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
</TABLE>
</CENTER>
@ -960,15 +960,15 @@ also be found in \cgalCite{cgal:dp-eegpd-03}.
<TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>Random</B>
<B>Random</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Ellipsoid</B>
<B>Ellipsoid</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Buddha</B>
<B>Buddha</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Molecule</B>
<B>Molecule</B>
<TD ALIGN=RIGHT NOWRAP>
<B>Dryer</B>
<B>Dryer</B>
<TR>
<TD ALIGN=LEFT NOWRAP>
@ -981,76 +981,76 @@ also be found in \cgalCite{cgal:dp-eegpd-03}.
<TD ALIGN=RIGHT NOWRAP>
<TD ALIGN=RIGHT NOWRAP>
<B>%Handle</B>
<B>%Handle</B>
<TR>
<TD ALIGN=LEFT NOWRAP>
Number of points
Number of points
<TD ALIGN=RIGHT NOWRAP>
<B>100000</B>
<B>100000</B>
<TD ALIGN=RIGHT NOWRAP>
<B>100000</B>
<B>100000</B>
<TD ALIGN=RIGHT NOWRAP>
<B>542548</B>
<B>542548</B>
<TD ALIGN=RIGHT NOWRAP>
<B>525296</B>
<B>525296</B>
<TD ALIGN=RIGHT NOWRAP>
<B>49787</B>
<B>49787</B>
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
`Simple_cartesian<double>`
`Simple_cartesian<double>`
<TD ALIGN=RIGHT NOWRAP>
0.69
0.69
<TD ALIGN=RIGHT NOWRAP>
0.627
0.627
<TD ALIGN=RIGHT NOWRAP>
4.21
4.21
<TD ALIGN=RIGHT NOWRAP>
3.8
3.8
<TD ALIGN=RIGHT NOWRAP>
\f$ \infty \f$-loop
\f$ \infty \f$-loop
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
`Exact_predicates_inexact_constructions_kernel`
`Exact_predicates_inexact_constructions_kernel`
<TD ALIGN=RIGHT NOWRAP>
0.824
0.824
<TD ALIGN=RIGHT NOWRAP>
0.749
0.749
<TD ALIGN=RIGHT NOWRAP>
4.99
4.99
<TD ALIGN=RIGHT NOWRAP>
4.64
4.64
<TD ALIGN=RIGHT NOWRAP>
1.68
1.68
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
`Exact_predicates_exact_constructions_kernel`
`Exact_predicates_exact_constructions_kernel`
<TD ALIGN=RIGHT NOWRAP>
4.59
4.59
<TD ALIGN=RIGHT NOWRAP>
3.85
3.85
<TD ALIGN=RIGHT NOWRAP>
30.1
30.1
<TD ALIGN=RIGHT NOWRAP>
26.4
26.4
<TD ALIGN=RIGHT NOWRAP>
4.57
4.57
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR>
<TD ALIGN=LEFT NOWRAP>
`Simple_cartesian<Gmpq>`
`Simple_cartesian<Gmpq>`
<TD ALIGN=RIGHT NOWRAP>
492
492
<TD ALIGN=RIGHT NOWRAP>
534
534
<TD ALIGN=RIGHT NOWRAP>
1120
1120
<TD ALIGN=RIGHT NOWRAP>
1030
1030
<TD ALIGN=RIGHT NOWRAP>
75.2
75.2
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
</TABLE>
</CENTER>
@ -1058,7 +1058,7 @@ Number of points
Running times (seconds) for various kernels and data sets.
\cgalFigureCaptionEnd
\cgalFigureBegin{Triangulation3figdatasets,api1_01.png,b35-1.png,HD.png}
Data sets used in the benchmark of \cgalFigureRef{Triangulation3figkernelsanddatasets}.
\cgalFigureEnd
@ -1105,7 +1105,7 @@ in \cgalCite{cgal:dt-pvrdr-06}, which allowed to release this
functionality in \cgal 3.2.
In 2006, Nico Kruithof wrote the `Triangulation_simplex_3` class
that can store simplices of any dimension and improved the internal
that can store simplices of any dimension and improved the internal
organization of the code.
As of March 2007, Christophe Delage made the iterator range insert methods and
@ -1141,6 +1141,6 @@ The authors wish to thank Lutz Kettner for inspiring discussions about
the design of \cgal. Jean-Daniel Boissonnat is also acknowledged
\cgalCite{bdty-tcgal-00}.
*/
*/
} /* namespace CGAL */

4
Triangulation_3/examples/Triangulation_3/CMakeLists.txt
View File

@ -58,8 +58,8 @@ if ( CGAL_FOUND )
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

230
Triangulation_3/include/CGAL/Triangulation_segment_traverser_3.h
View File

@ -59,46 +59,46 @@ struct Incrementer {
Incrementer() {}
void increment( SCI& sci ) { sci.walk_to_next(); }
}; // struct Incrementer
} // namespace internal
// provides an iterator over the cells intersected by a line segment.
/*
* The `Triangulation_segment_traverser_3` iterates over the cells
* of a `Triangulation_3` by following a straight line segment \f$ st \f$.
* The `Triangulation_segment_traverser_3` iterates over the cells
* of a `Triangulation_3` by following a straight line segment \f$ st \f$.
*
* This class is closely related to `Triangulation_3::locate(...)`.
* However, unlike this `locate(...)` method, all the cells traversed
* by the `Triangulation_segment_traverser_3` intersect the interior of the line
* segment \f$ st \f$.
* This class is closely related to `Triangulation_3::locate(...)`.
* However, unlike this `locate(...)` method, all the cells traversed
* by the `Triangulation_segment_traverser_3` intersect the interior of the line
* segment \f$ st \f$.
*
* Traversal starts from a cell containing \f$ s \f$ and it ends in a cell containing
* \f$ t \f$.
* If \f$ st \f$ is coplanar with a facet or collinear with an edge, at most one of the
* incident cells is traversed.
* If \f$ st \f$ intersects an edge or vertex, at most two incident cells are traversed:
* the cells intersected by \f$ st \f$ strictly in their interior.
* Traversal starts from a cell containing \f$ s \f$ and it ends in a cell containing
* \f$ t \f$.
* If \f$ st \f$ is coplanar with a facet or collinear with an edge, at most one of the
* incident cells is traversed.
* If \f$ st \f$ intersects an edge or vertex, at most two incident cells are traversed:
* the cells intersected by \f$ st \f$ strictly in their interior.
*
* If \f$ s \f$ lies on the convex hull, traversal starts in an incident cell inside
* the convex hull. Similarly, if \f$ t \f$ lies on the convex hull, traversal ends in
* an adjacent cell inside the convex hull.
* If \f$ s \f$ lies on the convex hull, traversal starts in an incident cell inside
* the convex hull. Similarly, if \f$ t \f$ lies on the convex hull, traversal ends in
* an adjacent cell inside the convex hull.
*
* Both \f$ s \f$ and \f$ t \f$ may lie outside the convex hull of the triangulation,
* but they must lie within the affine hull of the triangulation. In either case, the
* finite facet of any infinite cells traversed must intersect \f$ st \f$.
* Both \f$ s \f$ and \f$ t \f$ may lie outside the convex hull of the triangulation,
* but they must lie within the affine hull of the triangulation. In either case, the
* finite facet of any infinite cells traversed must intersect \f$ st \f$.
*
* The traverser may be applied to any triangulation of dimension > 0.
* However, for triangulations of dimension 1, the functionality is somewhat trivial.
* The traverser may be applied to any triangulation of dimension > 0.
* However, for triangulations of dimension 1, the functionality is somewhat trivial.
*
* The traverser becomes invalid whenever the triangulation is changed.
* The traverser becomes invalid whenever the triangulation is changed.
*
* \tparam Tr_ is the triangulation type to traverse.
* \tparam Tr_ is the triangulation type to traverse.
*
* \cgalModels{ForwardIterator}
*
* \sa `Triangulation_3`
* \sa `Forward_circulator_base`
* \sa `Triangulation_3`
* \sa `Forward_circulator_base`
*/
template < class Tr_, class Inc = internal::Incrementer<Tr_> >
class Triangulation_segment_cell_iterator_3
@ -136,7 +136,7 @@ public:
typedef std::ptrdiff_t difference_type; //< defines the signed integral type that can hold the distance between two iterators.
typedef std::forward_iterator_tag iterator_category; //< defines the iterator category.
// \}
// describes the iterator type when applied to another type of triangulation or incrementer.
template < class Tr2, class Inc2 >
struct Rebind { typedef Triangulation_segment_cell_iterator_3<Tr2,Inc2> Other; };
@ -172,44 +172,44 @@ public:
// \{
// constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0.
* \param s the source vertex. This vertex must be initialized and cannot be the infinite vertex.
* \param t the target vertex. This vertex must be initialized and cannot be the infinite vertex.
* It cannot equal `s`.
* \param s the source vertex. This vertex must be initialized and cannot be the infinite vertex.
* \param t the target vertex. This vertex must be initialized and cannot be the infinite vertex.
* It cannot equal `s`.
*/
Triangulation_segment_cell_iterator_3( const Tr* tr, Vertex_handle s, Vertex_handle t );
Triangulation_segment_cell_iterator_3( const Tr* tr, Vertex_handle s, Vertex_handle t );
// constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0.
* \param s the source vertex. This vertex must be initialized and cannot be the infinite vertex.
* \param t the target point. This point must be initialized and it cannot be be at the same location as `s`.
* If `tr` has dimension < 3, `t` must lie inside the affine hull of `tr`.
* \param s the source vertex. This vertex must be initialized and cannot be the infinite vertex.
* \param t the target point. This point must be initialized and it cannot be be at the same location as `s`.
* If `tr` has dimension < 3, `t` must lie inside the affine hull of `tr`.
*/
Triangulation_segment_cell_iterator_3( const Tr* tr, Vertex_handle s, const Point& t );
Triangulation_segment_cell_iterator_3( const Tr* tr, Vertex_handle s, const Point& t );
// constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0.
* \param s the source point. This point must be initialized and it cannot be be at the same location as `t`.
* \param t the target vertex. This vertex must be initialized and cannot be the infinite vertex.
* If `tr` has dimension < 3, `s` must lie inside the affine hull of `tr`.
* \param hint the starting point to search for `s`.
* \param s the source point. This point must be initialized and it cannot be be at the same location as `t`.
* \param t the target vertex. This vertex must be initialized and cannot be the infinite vertex.
* If `tr` has dimension < 3, `s` must lie inside the affine hull of `tr`.
* \param hint the starting point to search for `s`.
*/
Triangulation_segment_cell_iterator_3( const Tr* tr, const Point& s, Vertex_handle t, Cell_handle hint = Cell_handle() );
Triangulation_segment_cell_iterator_3( const Tr* tr, const Point& s, Vertex_handle t, Cell_handle hint = Cell_handle() );
// constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0.
* \param s the source point. This point must be initialized. If `tr` has dimension < 3, `s` must lie inside
* the affine hull of `tr`.
* \param t the target point. This point must be initialized and it cannot be be at the same location as `s`.
* If `tr` has dimension < 3, `t` must lie inside the affine hull of `tr`.
* \param hint the starting point to search for `s`.
* \param s the source point. This point must be initialized. If `tr` has dimension < 3, `s` must lie inside
* the affine hull of `tr`.
* \param t the target point. This point must be initialized and it cannot be be at the same location as `s`.
* If `tr` has dimension < 3, `t` must lie inside the affine hull of `tr`.
* \param hint the starting point to search for `s`.
*/
Triangulation_segment_cell_iterator_3( const Tr* tr, const Point& s, const Point& t, Cell_handle hint = Cell_handle() );
// constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0.
* \param S the segment to be traversed. If `tr` has dimension < 3, `S` must lie inside
* the affine hull of `tr`. `S` must not be degenerate, i.e. its source and target must not be equal.
* \param hint the starting point to search for `S`.
* \param S the segment to be traversed. If `tr` has dimension < 3, `S` must lie inside
* the affine hull of `tr`. `S` must not be degenerate, i.e. its source and target must not be equal.
* \param hint the starting point to search for `S`.
*/
Triangulation_segment_cell_iterator_3( const Tr* tr, const Segment& S, Cell_handle hint = Cell_handle() );
// \}
@ -224,7 +224,7 @@ public:
virtual
#endif
~Triangulation_segment_cell_iterator_3() {}
public:
// \name Accessors
@ -239,15 +239,15 @@ public:
// gives the target point of the segment follwoed.
/* \return the target point.
*/
*/
const Point& target() const { return _target; }
// gives a handle to the current cell.
/* By invariance, this cell is intersected by the segment
* between `source()` and `target()`.
* \return a handle to the current cell.
* \sa `cell()`.
*/
* between `source()` and `target()`.
* \return a handle to the current cell.
* \sa `cell()`.
*/
Cell_handle handle()
{
return std::get<0>(_cur);
@ -255,20 +255,20 @@ public:
// gives the previous cell.
/* This cell is uninitialized until the iterator leaves the initial
* cell.
* By invariance, once initialized, this cell must be intersected by the segment
* between `source()` and `target()`.
* \return the previous cell.
* \sa `handle()`.
*/
* cell.
* By invariance, once initialized, this cell must be intersected by the segment
* between `source()` and `target()`.
* \return the previous cell.
* \sa `handle()`.
*/
Cell_handle previous() const
{
return prev_cell();
}
// provides a dereference operator.
/* \return a pointer to the current cell.
*/
/* \return a pointer to the current cell.
*/
Cell* operator->()
{
return &*std::get<0>(_cur);
@ -276,46 +276,46 @@ public:
// provides an indirection operator.
/* \return the current cell.
*/
*/
Cell& operator*()
{
return *std::get<0>(_cur);
}
// provides a conversion operator.
/* \return a handle to the current cell.
*/
/* \return a handle to the current cell.
*/
operator const Cell_handle() const
{
return std::get<0>(_cur);
}
// provides a conversion operator.
/* \return the simplex through wich the current cell was entered.
*/
/* \return the simplex through wich the current cell was entered.
*/
operator const Simplex() const { return _cur; }
// checks whether the iterator has reached the final cell, which contains the `target()`.
/* If the `target()` lies on a facet, edge, or vertex, the final cell is the cell containing
* the interior of the segment between `source()` and `target()`.
* \return true iff the current cell contains the `target()`.
*/
* the interior of the segment between `source()` and `target()`.
* \return true iff the current cell contains the `target()`.
*/
bool has_next() const
{
return this->cell() != Cell_handle();
}
// gives the simplex through which the current cell was entered.
/* For the first cell, containing the `source()` \f$ s \f$,
/* For the first cell, containing the `source()` \f$ s \f$,
* this indicates the location of \f$ s \f$ in this cell.
*/
*/
void entry( Locate_type& lt, int& li, int& lj ) const
{
lt = this->lt(); li = this->li(); lj = this->lj();
}
// gives the simplex through which the previous cell was exited.
/* \pre the current cell is not the initial cell.
*/
/* \pre the current cell is not the initial cell.
*/
void exit( Locate_type& lt, int& li, int& lj ) const
{
lt = prev_lt(); li = prev_li(); lj = prev_lj();
@ -329,63 +329,63 @@ public:
// \name Mutators
// \{
// provides the increment postfix operator.
/* After incrementing the iterator, the current cell intersects the segment
* between `source()` and `target()` closer to the `target()` than the previous cell.
* \sa `operator++(int)`.
/* After incrementing the iterator, the current cell intersects the segment
* between `source()` and `target()` closer to the `target()` than the previous cell.
* \sa `operator++(int)`.
* \pre The current cell does not contain the `target()`.
*/
SCI& operator++();
// provides the increment prefix operator.
/* After incrementing the iterator, the current cell intersects the segment
* between `source()` and `target()` closer to the `target()` than the previous cell.
* than the previous cell.
* \sa `operator++()`.
/* After incrementing the iterator, the current cell intersects the segment
* between `source()` and `target()` closer to the `target()` than the previous cell.
* than the previous cell.
* \sa `operator++()`.
* \pre The current cell does not contain the `target()`.
*/
SCI operator++( int );
// iterates to the final cell, which contains the `target()`.
/* \return the final cell.
/* \return the final cell.
*/
Cell_handle complete();
// \}
public:
// \name Comparison
// \{
// compares this iterator with `sci`.
/* \param sci the other iterator.
* \return true iff the other iterator iterates the same triangulation along the same line segment
* and has the same current cell.
* \sa `operator!=( const SCI& t )`.
* \return true iff the other iterator iterates the same triangulation along the same line segment
* and has the same current cell.
* \sa `operator!=( const SCI& t )`.
*/
bool operator==( const SCI& sci ) const;
// compares this iterator with `sci`.
/* \param sci the other iterator.
* \return `false` iff the other iterator iterates the same triangulation along the same line segment
* and has the same current cell.
* \sa `operator==( const SCI& t ) const`.
* \return `false` iff the other iterator iterates the same triangulation along the same line segment
* and has the same current cell.
* \sa `operator==( const SCI& t ) const`.
*/
bool operator!=( const SCI& sci ) const;
// compares the current cell with `ch`.
/* \param ch a handle to the other cell.
* \return true iff the current cell is the same as the one pointed to by `ch`.
* \sa `operator!=( const Cell_handle& ch ) const`.
* \sa `operator==( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
* \return true iff the current cell is the same as the one pointed to by `ch`.
* \sa `operator!=( const Cell_handle& ch ) const`.
* \sa `operator==( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
*/
bool operator==( const Cell_handle& ch ) const
{
return ch == std::get<0>(_cur);
}
// compares the current cell with `ch`.
/* \param ch a handle to the other cell.
* \return `false` iff the current cell is the same as the one pointed to by `ch`.
* \sa `operator==( const Cell_handle& ch )`.
* \sa `operator!=( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
* \return `false` iff the current cell is the same as the one pointed to by `ch`.
* \sa `operator==( const Cell_handle& ch )`.
* \sa `operator!=( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
*/
bool operator!=( const Cell_handle& ch ) const
{
@ -393,21 +393,21 @@ public:
}
// \}
bool operator==( Nullptr_t CGAL_triangulation_assertion_code(n) ) const;
bool operator!=( Nullptr_t n ) const;
bool operator==( Nullptr_t CGAL_triangulation_assertion_code(n) ) const;
bool operator!=( Nullptr_t n ) const;
protected:
// \internal \name Protected Member Functions
// \{
// walks to the next cell.
/* \sa `complete()`.
*/
*/
void walk_to_next();
// increments the iterator.
/* This method may perform more actions based on the superclass.
* \sa `complete()`.
*/
*/
void increment() {
typedef typename Incrementer::SCI Expected;
#ifdef CGAL_TST_ASSUME_CORRECT_TYPES
@ -429,7 +429,7 @@ private:
std::pair<Simplex, Simplex> walk_to_next_3(const Simplex& prev,
const Simplex& cur) const;
void walk_to_next_3_inf( int inf );
// walk_to_next(), if the triangulation is 2D.
void walk_to_next_2();
void walk_to_next_2_inf( int inf );
@ -481,23 +481,23 @@ private:
int const& prev_lj() const { return std::get<3>(_prev); }
}; // class Triangulation_segment_cell_iterator_3
// compares a handle to a cell to a traverser.
/* \param ch the handle to a cell.
* \param t the traverser.
* \return true iff the cell currently traversed by `t` is the same as the one pointed to by `ch`.
* \sa `operator!=( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
* \sa `Triangulation_segment_cell_iterator_3::operator==( const Cell_handle& ch )`.
* \param t the traverser.
* \return true iff the cell currently traversed by `t` is the same as the one pointed to by `ch`.
* \sa `operator!=( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
* \sa `Triangulation_segment_cell_iterator_3::operator==( const Cell_handle& ch )`.
*/
template < class Tr, class Inc >
inline bool operator==( typename Tr::Cell_handle ch, Triangulation_segment_cell_iterator_3<Tr,Inc> tci ) { return tci == ch; }
// compares a handle to a cell to a traverser.
/* \param ch the handle to a cell.
* \param t the traverser.
* \return `false` iff the cell currently traversed by `t` is the same as the one pointed to by `ch`.
* \sa `operator==( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
* \sa `Triangulation_segment_cell_iterator_3::operator!=( const Cell_handle& ch )`.
* \param t the traverser.
* \return `false` iff the cell currently traversed by `t` is the same as the one pointed to by `ch`.
* \sa `operator==( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
* \sa `Triangulation_segment_cell_iterator_3::operator!=( const Cell_handle& ch )`.
*/
template < class Tr, class Inc >
inline bool operator!=( typename Tr::Cell_handle ch, Triangulation_segment_cell_iterator_3<Tr,Inc> tci ) { return tci != ch; }
@ -622,7 +622,7 @@ private:
case Locate_type::EDGE:
_curr_simplex = Edge(cell, li, lj);
break;
case Locate_type::FACET:
case Locate_type::FACET:
_curr_simplex = Facet(cell, li);
break;
//the 3 cases below correspond to the case when _cell_iterator
@ -885,7 +885,7 @@ public:
}
// provides a dereference operator.
/* \return a pointer to the current cell.
/* \return a pointer to the current cell.
*/
const Simplex_3* operator->() { return &_curr_simplex; }

10
Triangulation_3/include/CGAL/internal/Triangulation_segment_traverser_3_impl.h
View File

@ -37,7 +37,7 @@ Triangulation_segment_cell_iterator_3( const Tr* tr, Vertex_handle s, Vertex_han
_target = t->point();
_s_vertex = s;
_t_vertex = t;
Cell_handle c = s->cell();
// If a vertex of an infinite cell, we start inside the convex hull.
int inf;
@ -246,7 +246,7 @@ template < class Tr, class Inc >
void Triangulation_segment_cell_iterator_3<Tr,Inc>::
walk_to_next() {
CGAL_triangulation_precondition( has_next() );
// Check if the target is in the current cell.
int ti;
if( cell()->has_vertex( _t_vertex, ti ) ) {
@ -620,7 +620,7 @@ Triangulation_segment_cell_iterator_3<Tr,Inc>::walk_to_next_3(const Simplex& pre
CGAL_triangulation_assertion( pos == 6 );
prev_after_walk = Simplex( std::get<0>(cur), Tr::CELL, -1, -1 );
CGAL_triangulation_assertion( (! regular_case) || inside );
break;
break;
case 3:
prev_after_walk = Simplex( std::get<0>(cur), Tr::FACET, 6-pos, -1 );
@ -687,7 +687,7 @@ walk_to_next_3_inf( int inf )
o[li] = COPLANAR;
continue;
}
// Skip the previous cell.
Cell_handle next = cell()->neighbor(li);
if( next == prev_cell() ) {
@ -954,7 +954,7 @@ walk_to_next_2()
}
case Tr::FACET: {
int li = 0;
Orientation o[3];
bool calc[3] = { false, false, false };

6
Triangulation_3/test/Triangulation_3/test_segment_cell_traverser_3.cpp
View File

@ -19,7 +19,7 @@ typedef DT::Segment_cell_iterator Segment_cell_iterator;
int main(int argc, char* argv[])
{
const std::vector<Point_3> points = { { -2, 0, 0 },
{ 2, 0, 0 },
{ 2, 0, 0 },
{ 0, 1, -1 },
{ 0, -1, -1 },
{ 0, 0, 1 },
@ -35,10 +35,10 @@ int main(int argc, char* argv[])
std::vector<DT::Vertex_handle> vertices;
vertices.reserve(points.size());
DT dt;
for(auto p: points) vertices.push_back(dt.insert(p));
Cell_handle c;
assert( dt.is_valid() );
assert( dt.is_cell(vertices[0], vertices[2], vertices[3], vertices[4], c));

4
Triangulation_3/test/Triangulation_3/test_segment_simplex_traverser_3.cpp
View File

@ -28,7 +28,7 @@ bool test(const DT& dt, const Big_tuple& tuple);
int main(int, char* [])
{
const std::vector<Point_3> points = { { -2, 0, 0 },
{ 2, 0, 0 },
{ 2, 0, 0 },
{ 0, 1, -1 },
{ 0, -1, -1 },
{ 0, 0, 1 },
@ -83,7 +83,7 @@ bool test(const DT& dt, const Big_tuple& tuple)
<< p2 << " )\n#\n";
Segment_simplex_iterator st = dt.segment_traverser_simplices_begin(p1, p2);
Segment_simplex_iterator stend = dt.segment_traverser_simplices_end();
unsigned int nb_cells = 0, nb_facets = 0, nb_edges = 0, nb_vertex = 0;
unsigned int nb_collinear = 0;

2
Triangulation_3/test/Triangulation_3/test_simplex_iterator_3.cpp
View File

@ -14,7 +14,7 @@
//
// $URL$
// $Id$
//
//
//
// Author(s) : Jane Tournois