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 // SPDX-License-Identifier: BSL-1.0
// //
// NOTE: this file have been taken from boost 1.46.1 for using // 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). // non-documented mutable_queue).
// original file is <boost/graph/detail/array_binary_tree.hpp> // 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$ // $URL$
// $Id$ // $Id$
// //
// //
#include <CGAL/Exact_predicates_exact_constructions_kernel.h> #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 \cgalPkgSummaryEnd
\cgalPkgShortInfoBegin \cgalPkgShortInfoBegin
\cgalPkgSince{2.1} \cgalPkgSince{2.1}
\cgalPkgDependsOn{\ref PkgTDS3} \cgalPkgDependsOn{\ref PkgTDS3}
\cgalPkgBib{cgal:pt-t3} \cgalPkgBib{cgal:pt-t3}
\cgalPkgLicense{\ref licensesGPL "GPL" } \cgalPkgLicense{\ref licensesGPL "GPL" }
\cgalPkgDemo{3D Triangulations,triangulation_3.zip} \cgalPkgDemo{3D Triangulations,triangulation_3.zip}

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

@ -1,7 +1,7 @@
namespace CGAL { namespace CGAL {
/*! /*!
\mainpage User Manual \mainpage User Manual
\anchor Chapter_3D_Triangulations \anchor Chapter_3D_Triangulations
\anchor chapterTriangulation3 \anchor chapterTriangulation3
\cgalAutoToc \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 either do not intersect or share a common facet (\f$ 2\f$-face), edge
(\f$ 1\f$-face) or vertex (\f$ 0\f$-face). (\f$ 1\f$-face) or vertex (\f$ 0\f$-face).
\section Triangulation3secintro Representation \section Triangulation3secintro Representation
In order to deal In order to deal
only with tetrahedra, which is convenient for many applications, the only with tetrahedra, which is convenient for many applications, the
@ -53,9 +53,9 @@ Orientation of a cell (3-dimensional case).
\cgalFigureEnd \cgalFigureEnd
As in the underlying combinatorial triangulation (see 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) 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 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 `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 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. the convex hull of the points.
<UL> <UL>
<LI> <I>dimension 2:</I> when a triangulation only contains <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. 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 points (which is the case when there are only two points), it consists
of edges. of edges.
<LI> <I>dimension 0:</I> the triangulation contains only one <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 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 <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") (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 <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 method `Triangulation_3::is_valid()` checks
the local validity of a given triangulation. This does not always 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. sufficient for practical cases.
\section Triangulation_3Delaunay Delaunay Triangulation \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 This implementation is fully dynamic: it supports insertions of points, vertex removals
and displacements of points. and displacements of points.
\section Triangulation3secclassRegulartriangulation Regular Triangulation \section Triangulation3secclassRegulartriangulation Regular Triangulation
The class `Regular_triangulation_3` implements incremental regular The class `Regular_triangulation_3` implements incremental regular
triangulations, also known as weighted Delaunay triangulations. 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 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. \f$ {z}^{(w)}=(z,w_z), z\in\mathbb{R}^3, w_z\in\mathbb{R}\f$ be two weighted points.
A weighted point A weighted point
\f$ {p}^{(w)}=(p,w_p)\f$ can also be seen as a sphere of center \f$ p\f$ and \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 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] \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$. 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. 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 A sphere \f$ {z}^{(w)}\f$ is said to be
<I>regular</I> if \f$ \forall {p}^{(w)}\in{S}^{(w)}, <I>regular</I> if \f$ \forall {p}^{(w)}\in{S}^{(w)},
\Pi{({p}^{(w)},{z}^{(w)})}\geq 0\f$. \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. of all simplices are regular.
The regular triangulation of 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 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 Note that all points of \f$ {S}^{(w)}\f$ do not
necessarily appear as vertices of the regular necessarily appear as vertices of the regular
triangulation. To know more about regular triangulations, see for 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. 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 The main classes `Triangulation_3`, `Delaunay_triangulation_3` and
`Regular_triangulation_3` are connected to each other by the `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. triangulation class, described in Section \ref Triangulation3seclocpol.
</UL> </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. support multi-core shared-memory architectures to take advantage of available parallelism.
For this purpose, a model of the concept `SurjectiveLockDataStructure` can be For this purpose, a model of the concept `SurjectiveLockDataStructure` can be
given as fourth template parameter; it defaults to given as fourth template parameter; it defaults to
`Spatial_lock_grid_3`. This data structure `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 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) 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. 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 The first template parameter of the triangulation class
`Triangulation_3<TriangulationTraits_3, TriangulationDataStructure_3>` `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 In addition to the requirements described before, the geometric traits
class of `Regular_triangulation_3` must define predicates to test for the 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 It is described by the concept
`RegularTriangulationTraits_3`, which refines `TriangulationTraits_3`. `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. 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`, The second template parameter of the main classes (`Triangulation_3`,
`Delaunay_triangulation_3` and `Regular_triangulation_3`) is a `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 he wants to use a different triangulation data structure or a different vertex
or cell base class. 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 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 The fast location policy should be used when the user inserts points in a random
order or needs to do many unrelated queries. order or needs to do many unrelated queries.
If the user is able to give a good hint to help the point location of 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 its queries (and its newly inserted points), then it should prefer the default
policy. In such a case where good hints are provided, policy. In such a case where good hints are provided,
the default policy save some memory (few percents), and is faster. 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. automatically computed using spatial sort.
Reading Section \ref Triangulation3seccomplexity on complexity and 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 \subsection Triangulation_3ParallelAlgorithms Parallel Algorithms
Parallel algorithms of `Delaunay_triangulation_3` and Parallel algorithms of `Delaunay_triangulation_3` and
`Regular_triangulation_3` are enabled `Regular_triangulation_3` are enabled
if the `TriangulationDataStructure_3::Concurrency_tag` type is `Parallel_tag` and a 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 by using `Triangulation_3::set_lock_data_structure`. This data structure
must be a model of the concept `SurjectiveLockDataStructure` and can be must be a model of the concept `SurjectiveLockDataStructure` and can be
optionally given as a template parameter of the triangulation; optionally given as a template parameter of the triangulation;
it defaults to `Spatial_lock_grid_3`. it defaults to `Spatial_lock_grid_3`.
Note that the parallel Delaunay Note that the parallel Delaunay
triangulation must use the default compact location policy (and not the fast triangulation must use the default compact location policy (and not the fast
one). If those conditions are fulfilled, the insertion/removal of a one). If those conditions are fulfilled, the insertion/removal of a
range of points will be performed in parallel, and the individual range of points will be performed in parallel, and the individual
insert/remove operations will be optionally thread-safe. 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>. 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. 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. for more details.
\section Triangulation3secexamples Examples \section Triangulation3secexamples Examples
\subsection Triangulation_3BasicExample Basic Example \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 The following two examples show how the user can plug his own vertex base in a
triangulation. Changing the cell base is similar. 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 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 `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 Delaunay (or regular) triangulation is to provide an iterator
range over (weighted) points to the insert function. However, an iterator range of 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. (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` is a model of the concept `TriangulationVertexBaseWithInfo_3`
(such as `Triangulation_vertex_base_with_info_3`), we provide three examples (such as `Triangulation_vertex_base_with_info_3`), we provide three examples
doing the same operation: set an unsigned integer as the information 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 each vertex. The value of this unsigned integer is the initial order
of the corresponding point given in the range. 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} \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 The triangulation defines a `Triangulation_3::Simplex` class that represents a
simplex (vertex, edge, facet or cell). This example demonstrates how 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} \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} \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 \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, 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} \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 \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 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 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 There are several algorithms provided in this package. We will focus here on
the following ones and give practical numbers on their efficiency : the following ones and give practical numbers on their efficiency :
<UL> <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>location of a point (using the `locate` function),
<LI>removal of a vertex (using the `remove` function). <LI>removal of a vertex (using the `remove` function).
</UL> </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=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B> <B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B> <B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Regular</B> <B>Regular</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Regular</B> <B>Regular</B>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT 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>
<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 COLSPAN=5><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^2\f$ points Construction from \f$ 10^2\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.00054 0.00054
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.000576 0.000576
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.000948 0.000948
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.000955 0.000955
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^3\f$ points Construction from \f$ 10^3\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.00724 0.00724
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.00748 0.00748
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.0114 0.0114
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.0111 0.0111
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^4\f$ points Construction from \f$ 10^4\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.0785 0.0785
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.0838 0.0838
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.122 0.122
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.117 0.117
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^5\f$ points Construction from \f$ 10^5\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.827 0.827
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.878 0.878
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.25 1.25
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.19 1.19
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^6\f$ points Construction from \f$ 10^6\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
8.5 8.5
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
9.07 9.07
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
12.6 12.6
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
12.2 12.2
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Construction from \f$ 10^7\f$ points Construction from \f$ 10^7\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
87.4 87.4
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
92.5 92.5
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
129 129
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
125 125
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^2\f$ points Point location in \f$ 10^2\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
9.93e-07 9.93e-07
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.06e-06 1.06e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
7.19e-06 7.19e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
6.99e-06 6.99e-06
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^3\f$ points Point location in \f$ 10^3\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
2.25e-06 2.25e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.93e-06 1.93e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.73e-05 1.73e-05
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.76e-05 1.76e-05
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^4\f$ points Point location in \f$ 10^4\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
4.79e-06 4.79e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
3.09e-06 3.09e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
3.96e-05 3.96e-05
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
3.76e-05 3.76e-05
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^5\f$ points Point location in \f$ 10^5\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
2.98e-05 2.98e-05
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
6.12e-06 6.12e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.06e-04 1.06e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.06e-04 1.06e-04
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^6\f$ points Point location in \f$ 10^6\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1e-04 1e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
9.65e-06 9.65e-06
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
2.7e-04 2.7e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
2.67e-04 2.67e-04
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Point location in \f$ 10^7\f$ points Point location in \f$ 10^7\f$ points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
2.59e-04 2.59e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.33e-05 1.33e-05
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
6.25e-04 6.25e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
6.25e-04 6.25e-04
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Vertex removal Vertex removal
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1e-04 1e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.03e-04 1.03e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.42e-04 1.42e-04
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.38e-04 1.38e-04
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
</TABLE> </TABLE>
</CENTER> </CENTER>
@ -809,16 +809,16 @@ in \cgalCite{msri52:liu-snoeyink-05}.
\subsection Triangulation_3ParallelPerformance Parallel Performance \subsection Triangulation_3ParallelPerformance Parallel Performance
Figure \cgalFigureRef{Triangulation3figparallelspeedup} shows insertion Figure \cgalFigureRef{Triangulation3figparallelspeedup} shows insertion
and removal speed-ups obtained using the parallel version of the and removal speed-ups obtained using the parallel version of the
triangulation algorithms of \cgal 4.5. The machine used is a PC running triangulation algorithms of \cgal 4.5. The machine used is a PC running
Windows 7 64-bits with two 6-core Windows 7 64-bits with two 6-core
Intel Xeon CPU X5660 clocked at 2.80 GHz 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. Microsoft Visual C++ 2012 in Release mode.
\cgalFigureBegin{Triangulation3figparallelspeedup,DT3_parallel_benchmark.png} \cgalFigureBegin{Triangulation3figparallelspeedup,DT3_parallel_benchmark.png}
Speed-up obtained for the insertion of 1M points randomly generated inside 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. to the sequential version of the algorithm.
\cgalFigureEnd \cgalFigureEnd
@ -856,48 +856,48 @@ points, as measured empirically using `Memory_sizer` for large triangulations
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B> <B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Delaunay</B> <B>Delaunay</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Regular</B> <B>Regular</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Regular</B> <B>Regular</B>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT 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>
<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 COLSPAN=5><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
32bit 32bit
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
274 274
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
291 291
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
336 336
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
282 282
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
64bit 64bit
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
519 519
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
553 553
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
635 635
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
527 527
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=5><HR>
</TABLE> </TABLE>
</CENTER> </CENTER>
@ -960,15 +960,15 @@ also be found in \cgalCite{cgal:dp-eegpd-03}.
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Random</B> <B>Random</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Ellipsoid</B> <B>Ellipsoid</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Buddha</B> <B>Buddha</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Molecule</B> <B>Molecule</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>Dryer</B> <B>Dryer</B>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <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>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>%Handle</B> <B>%Handle</B>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
Number of points Number of points
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>100000</B> <B>100000</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>100000</B> <B>100000</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>542548</B> <B>542548</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>525296</B> <B>525296</B>
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
<B>49787</B> <B>49787</B>
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
`Simple_cartesian<double>` `Simple_cartesian<double>`
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.69 0.69
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.627 0.627
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
4.21 4.21
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
3.8 3.8
<TD ALIGN=RIGHT NOWRAP> <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 COLSPAN=6><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
`Exact_predicates_inexact_constructions_kernel` `Exact_predicates_inexact_constructions_kernel`
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.824 0.824
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
0.749 0.749
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
4.99 4.99
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
4.64 4.64
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1.68 1.68
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
`Exact_predicates_exact_constructions_kernel` `Exact_predicates_exact_constructions_kernel`
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
4.59 4.59
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
3.85 3.85
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
30.1 30.1
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
26.4 26.4
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
4.57 4.57
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
<TR> <TR>
<TD ALIGN=LEFT NOWRAP> <TD ALIGN=LEFT NOWRAP>
`Simple_cartesian<Gmpq>` `Simple_cartesian<Gmpq>`
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
492 492
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
534 534
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1120 1120
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
1030 1030
<TD ALIGN=RIGHT NOWRAP> <TD ALIGN=RIGHT NOWRAP>
75.2 75.2
<TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR> <TR><TD ALIGN=LEFT NOWRAP COLSPAN=6><HR>
</TABLE> </TABLE>
</CENTER> </CENTER>
@ -1058,7 +1058,7 @@ Number of points
Running times (seconds) for various kernels and data sets. Running times (seconds) for various kernels and data sets.
\cgalFigureCaptionEnd \cgalFigureCaptionEnd
\cgalFigureBegin{Triangulation3figdatasets,api1_01.png,b35-1.png,HD.png} \cgalFigureBegin{Triangulation3figdatasets,api1_01.png,b35-1.png,HD.png}
Data sets used in the benchmark of \cgalFigureRef{Triangulation3figkernelsanddatasets}. Data sets used in the benchmark of \cgalFigureRef{Triangulation3figkernelsanddatasets}.
\cgalFigureEnd \cgalFigureEnd
@ -1105,7 +1105,7 @@ in \cgalCite{cgal:dt-pvrdr-06}, which allowed to release this
functionality in \cgal 3.2. functionality in \cgal 3.2.
In 2006, Nico Kruithof wrote the `Triangulation_simplex_3` class 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. organization of the code.
As of March 2007, Christophe Delage made the iterator range insert methods and 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 the design of \cgal. Jean-Daniel Boissonnat is also acknowledged
\cgalCite{bdty-tcgal-00}. \cgalCite{bdty-tcgal-00}.
*/ */
} /* namespace CGAL */ } /* namespace CGAL */

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

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

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

@ -59,46 +59,46 @@ struct Incrementer {
Incrementer() {} Incrementer() {}
void increment( SCI& sci ) { sci.walk_to_next(); } void increment( SCI& sci ) { sci.walk_to_next(); }
}; // struct Incrementer }; // struct Incrementer
} // namespace internal } // namespace internal
// provides an iterator over the cells intersected by a line segment. // provides an iterator over the cells intersected by a line segment.
/* /*
* The `Triangulation_segment_traverser_3` iterates over the cells * The `Triangulation_segment_traverser_3` iterates over the cells
* of a `Triangulation_3` by following a straight line segment \f$ st \f$. * of a `Triangulation_3` by following a straight line segment \f$ st \f$.
* *
* This class is closely related to `Triangulation_3::locate(...)`. * This class is closely related to `Triangulation_3::locate(...)`.
* However, unlike this `locate(...)` method, all the cells traversed * However, unlike this `locate(...)` method, all the cells traversed
* by the `Triangulation_segment_traverser_3` intersect the interior of the line * by the `Triangulation_segment_traverser_3` intersect the interior of the line
* segment \f$ st \f$. * segment \f$ st \f$.
* *
* Traversal starts from a cell containing \f$ s \f$ and it ends in a cell containing * Traversal starts from a cell containing \f$ s \f$ and it ends in a cell containing
* \f$ t \f$. * \f$ t \f$.
* If \f$ st \f$ is coplanar with a facet or collinear with an edge, at most one of the * If \f$ st \f$ is coplanar with a facet or collinear with an edge, at most one of the
* incident cells is traversed. * incident cells is traversed.
* If \f$ st \f$ intersects an edge or vertex, at most two incident cells are 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. * 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 * 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 * the convex hull. Similarly, if \f$ t \f$ lies on the convex hull, traversal ends in
* an adjacent cell inside the convex hull. * an adjacent cell inside the convex hull.
* *
* Both \f$ s \f$ and \f$ t \f$ may lie outside the convex hull of the triangulation, * 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 * 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$. * finite facet of any infinite cells traversed must intersect \f$ st \f$.
* *
* The traverser may be applied to any triangulation of dimension > 0. * The traverser may be applied to any triangulation of dimension > 0.
* However, for triangulations of dimension 1, the functionality is somewhat trivial. * 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} * \cgalModels{ForwardIterator}
* *
* \sa `Triangulation_3` * \sa `Triangulation_3`
* \sa `Forward_circulator_base` * \sa `Forward_circulator_base`
*/ */
template < class Tr_, class Inc = internal::Incrementer<Tr_> > template < class Tr_, class Inc = internal::Incrementer<Tr_> >
class Triangulation_segment_cell_iterator_3 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::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. typedef std::forward_iterator_tag iterator_category; //< defines the iterator category.
// \} // \}
// describes the iterator type when applied to another type of triangulation or incrementer. // describes the iterator type when applied to another type of triangulation or incrementer.
template < class Tr2, class Inc2 > template < class Tr2, class Inc2 >
struct Rebind { typedef Triangulation_segment_cell_iterator_3<Tr2,Inc2> Other; }; struct Rebind { typedef Triangulation_segment_cell_iterator_3<Tr2,Inc2> Other; };
@ -172,44 +172,44 @@ public:
// \{ // \{
// constructs an iterator. // constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0. /* \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 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. * \param t the target vertex. This vertex must be initialized and cannot be the infinite vertex.
* It cannot equal `s`. * 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. // constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0. /* \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 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`. * \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`. * 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. // constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0. /* \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 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. * \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`. * If `tr` has dimension < 3, `s` must lie inside the affine hull of `tr`.
* \param hint the starting point to search for `s`. * \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. // constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0. /* \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 * \param s the source point. This point must be initialized. If `tr` has dimension < 3, `s` must lie inside
* the affine hull of `tr`. * 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`. * \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`. * If `tr` has dimension < 3, `t` must lie inside the affine hull of `tr`.
* \param hint the starting point to search for `s`. * \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() ); Triangulation_segment_cell_iterator_3( const Tr* tr, const Point& s, const Point& t, Cell_handle hint = Cell_handle() );
// constructs an iterator. // constructs an iterator.
/* \param tr the triangulation to iterate though. This triangulation must have dimension > 0. /* \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 * \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. * 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 hint the starting point to search for `S`.
*/ */
Triangulation_segment_cell_iterator_3( const Tr* tr, const Segment& S, Cell_handle hint = Cell_handle() ); Triangulation_segment_cell_iterator_3( const Tr* tr, const Segment& S, Cell_handle hint = Cell_handle() );
// \} // \}
@ -224,7 +224,7 @@ public:
virtual virtual
#endif #endif
~Triangulation_segment_cell_iterator_3() {} ~Triangulation_segment_cell_iterator_3() {}
public: public:
// \name Accessors // \name Accessors
@ -239,15 +239,15 @@ public:
// gives the target point of the segment follwoed. // gives the target point of the segment follwoed.
/* \return the target point. /* \return the target point.
*/ */
const Point& target() const { return _target; } const Point& target() const { return _target; }
// gives a handle to the current cell. // gives a handle to the current cell.
/* By invariance, this cell is intersected by the segment /* By invariance, this cell is intersected by the segment
* between `source()` and `target()`. * between `source()` and `target()`.
* \return a handle to the current cell. * \return a handle to the current cell.
* \sa `cell()`. * \sa `cell()`.
*/ */
Cell_handle handle() Cell_handle handle()
{ {
return std::get<0>(_cur); return std::get<0>(_cur);
@ -255,20 +255,20 @@ public:
// gives the previous cell. // gives the previous cell.
/* This cell is uninitialized until the iterator leaves the initial /* This cell is uninitialized until the iterator leaves the initial
* cell. * cell.
* By invariance, once initialized, this cell must be intersected by the segment * By invariance, once initialized, this cell must be intersected by the segment
* between `source()` and `target()`. * between `source()` and `target()`.
* \return the previous cell. * \return the previous cell.
* \sa `handle()`. * \sa `handle()`.
*/ */
Cell_handle previous() const Cell_handle previous() const
{ {
return prev_cell(); return prev_cell();
} }
// provides a dereference operator. // provides a dereference operator.
/* \return a pointer to the current cell. /* \return a pointer to the current cell.
*/ */
Cell* operator->() Cell* operator->()
{ {
return &*std::get<0>(_cur); return &*std::get<0>(_cur);
@ -276,46 +276,46 @@ public:
// provides an indirection operator. // provides an indirection operator.
/* \return the current cell. /* \return the current cell.
*/ */
Cell& operator*() Cell& operator*()
{ {
return *std::get<0>(_cur); return *std::get<0>(_cur);
} }
// provides a conversion operator. // provides a conversion operator.
/* \return a handle to the current cell. /* \return a handle to the current cell.
*/ */
operator const Cell_handle() const operator const Cell_handle() const
{ {
return std::get<0>(_cur); return std::get<0>(_cur);
} }
// provides a conversion operator. // 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; } operator const Simplex() const { return _cur; }
// checks whether the iterator has reached the final cell, which contains the `target()`. // 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 /* 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()`. * the interior of the segment between `source()` and `target()`.
* \return true iff the current cell contains the `target()`. * \return true iff the current cell contains the `target()`.
*/ */
bool has_next() const bool has_next() const
{ {
return this->cell() != Cell_handle(); return this->cell() != Cell_handle();
} }
// gives the simplex through which the current cell was entered. // 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. * this indicates the location of \f$ s \f$ in this cell.
*/ */
void entry( Locate_type& lt, int& li, int& lj ) const void entry( Locate_type& lt, int& li, int& lj ) const
{ {
lt = this->lt(); li = this->li(); lj = this->lj(); lt = this->lt(); li = this->li(); lj = this->lj();
} }
// gives the simplex through which the previous cell was exited. // 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 void exit( Locate_type& lt, int& li, int& lj ) const
{ {
lt = prev_lt(); li = prev_li(); lj = prev_lj(); lt = prev_lt(); li = prev_li(); lj = prev_lj();
@ -329,63 +329,63 @@ public:
// \name Mutators // \name Mutators
// \{ // \{
// provides the increment postfix operator. // provides the increment postfix operator.
/* After incrementing the iterator, the current cell intersects the segment /* After incrementing the iterator, the current cell intersects the segment
* between `source()` and `target()` closer to the `target()` than the previous cell. * between `source()` and `target()` closer to the `target()` than the previous cell.
* \sa `operator++(int)`. * \sa `operator++(int)`.
* \pre The current cell does not contain the `target()`. * \pre The current cell does not contain the `target()`.
*/ */
SCI& operator++(); SCI& operator++();
// provides the increment prefix operator. // provides the increment prefix operator.
/* After incrementing the iterator, the current cell intersects the segment /* After incrementing the iterator, the current cell intersects the segment
* between `source()` and `target()` closer to the `target()` than the previous cell. * between `source()` and `target()` closer to the `target()` than the previous cell.
* than the previous cell. * than the previous cell.
* \sa `operator++()`. * \sa `operator++()`.
* \pre The current cell does not contain the `target()`. * \pre The current cell does not contain the `target()`.
*/ */
SCI operator++( int ); SCI operator++( int );
// iterates to the final cell, which contains the `target()`. // iterates to the final cell, which contains the `target()`.
/* \return the final cell. /* \return the final cell.
*/ */
Cell_handle complete(); Cell_handle complete();
// \} // \}
public: public:
// \name Comparison // \name Comparison
// \{ // \{
// compares this iterator with `sci`. // compares this iterator with `sci`.
/* \param sci the other iterator. /* \param sci the other iterator.
* \return true iff the other iterator iterates the same triangulation along the same line segment * \return true iff the other iterator iterates the same triangulation along the same line segment
* and has the same current cell. * and has the same current cell.
* \sa `operator!=( const SCI& t )`. * \sa `operator!=( const SCI& t )`.
*/ */
bool operator==( const SCI& sci ) const; bool operator==( const SCI& sci ) const;
// compares this iterator with `sci`. // compares this iterator with `sci`.
/* \param sci the other iterator. /* \param sci the other iterator.
* \return `false` iff the other iterator iterates the same triangulation along the same line segment * \return `false` iff the other iterator iterates the same triangulation along the same line segment
* and has the same current cell. * and has the same current cell.
* \sa `operator==( const SCI& t ) const`. * \sa `operator==( const SCI& t ) const`.
*/ */
bool operator!=( const SCI& sci ) const; bool operator!=( const SCI& sci ) const;
// compares the current cell with `ch`. // compares the current cell with `ch`.
/* \param ch a handle to the other cell. /* \param ch a handle to the other cell.
* \return true iff the current cell is the same as the one pointed to by `ch`. * \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!=( const Cell_handle& ch ) const`.
* \sa `operator==( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`. * \sa `operator==( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
*/ */
bool operator==( const Cell_handle& ch ) const bool operator==( const Cell_handle& ch ) const
{ {
return ch == std::get<0>(_cur); return ch == std::get<0>(_cur);
} }
// compares the current cell with `ch`. // compares the current cell with `ch`.
/* \param ch a handle to the other cell. /* \param ch a handle to the other cell.
* \return `false` iff the current cell is the same as the one pointed to by `ch`. * \return `false` iff the current cell is the same as the one pointed to by `ch`.
* \sa `operator==( const Cell_handle& ch )`. * \sa `operator==( const Cell_handle& ch )`.
* \sa `operator!=( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`. * \sa `operator!=( typename TriangulationTraits_3::Cell_handle ch, Triangulation_segment_cell_iterator_3<TriangulationTraits_3> t )`.
*/ */
bool operator!=( const Cell_handle& ch ) const 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 CGAL_triangulation_assertion_code(n) ) const;
bool operator!=( Nullptr_t n ) const; bool operator!=( Nullptr_t n ) const;
protected: protected:
// \internal \name Protected Member Functions // \internal \name Protected Member Functions
// \{ // \{
// walks to the next cell. // walks to the next cell.
/* \sa `complete()`. /* \sa `complete()`.
*/ */
void walk_to_next(); void walk_to_next();
// increments the iterator. // increments the iterator.
/* This method may perform more actions based on the superclass. /* This method may perform more actions based on the superclass.
* \sa `complete()`. * \sa `complete()`.
*/ */
void increment() { void increment() {
typedef typename Incrementer::SCI Expected; typedef typename Incrementer::SCI Expected;
#ifdef CGAL_TST_ASSUME_CORRECT_TYPES #ifdef CGAL_TST_ASSUME_CORRECT_TYPES
@ -429,7 +429,7 @@ private:
std::pair<Simplex, Simplex> walk_to_next_3(const Simplex& prev, std::pair<Simplex, Simplex> walk_to_next_3(const Simplex& prev,
const Simplex& cur) const; const Simplex& cur) const;
void walk_to_next_3_inf( int inf ); void walk_to_next_3_inf( int inf );
// walk_to_next(), if the triangulation is 2D. // walk_to_next(), if the triangulation is 2D.
void walk_to_next_2(); void walk_to_next_2();
void walk_to_next_2_inf( int inf ); void walk_to_next_2_inf( int inf );
@ -481,23 +481,23 @@ private:
int const& prev_lj() const { return std::get<3>(_prev); } int const& prev_lj() const { return std::get<3>(_prev); }
}; // class Triangulation_segment_cell_iterator_3 }; // class Triangulation_segment_cell_iterator_3
// compares a handle to a cell to a traverser. // compares a handle to a cell to a traverser.
/* \param ch the handle to a cell. /* \param ch the handle to a cell.
* \param t the traverser. * \param t the traverser.
* \return true iff the cell currently traversed by `t` is the same as the one pointed to by `ch`. * \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 `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 )`. * \sa `Triangulation_segment_cell_iterator_3::operator==( const Cell_handle& ch )`.
*/ */
template < class Tr, class Inc > template < class Tr, class Inc >
inline bool operator==( typename Tr::Cell_handle ch, Triangulation_segment_cell_iterator_3<Tr,Inc> tci ) { return tci == ch; } 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. // compares a handle to a cell to a traverser.
/* \param ch the handle to a cell. /* \param ch the handle to a cell.
* \param t the traverser. * \param t the traverser.
* \return `false` iff the cell currently traversed by `t` is the same as the one pointed to by `ch`. * \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 `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 )`. * \sa `Triangulation_segment_cell_iterator_3::operator!=( const Cell_handle& ch )`.
*/ */
template < class Tr, class Inc > template < class Tr, class Inc >
inline bool operator!=( typename Tr::Cell_handle ch, Triangulation_segment_cell_iterator_3<Tr,Inc> tci ) { return tci != ch; } 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: case Locate_type::EDGE:
_curr_simplex = Edge(cell, li, lj); _curr_simplex = Edge(cell, li, lj);
break; break;
case Locate_type::FACET: case Locate_type::FACET:
_curr_simplex = Facet(cell, li); _curr_simplex = Facet(cell, li);
break; break;
//the 3 cases below correspond to the case when _cell_iterator //the 3 cases below correspond to the case when _cell_iterator
@ -885,7 +885,7 @@ public:
} }
// provides a dereference operator. // 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; } 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(); _target = t->point();
_s_vertex = s; _s_vertex = s;
_t_vertex = t; _t_vertex = t;
Cell_handle c = s->cell(); Cell_handle c = s->cell();
// If a vertex of an infinite cell, we start inside the convex hull. // If a vertex of an infinite cell, we start inside the convex hull.
int inf; int inf;
@ -246,7 +246,7 @@ template < class Tr, class Inc >
void Triangulation_segment_cell_iterator_3<Tr,Inc>:: void Triangulation_segment_cell_iterator_3<Tr,Inc>::
walk_to_next() { walk_to_next() {
CGAL_triangulation_precondition( has_next() ); CGAL_triangulation_precondition( has_next() );
// Check if the target is in the current cell. // Check if the target is in the current cell.
int ti; int ti;
if( cell()->has_vertex( _t_vertex, 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 ); CGAL_triangulation_assertion( pos == 6 );
prev_after_walk = Simplex( std::get<0>(cur), Tr::CELL, -1, -1 ); prev_after_walk = Simplex( std::get<0>(cur), Tr::CELL, -1, -1 );
CGAL_triangulation_assertion( (! regular_case) || inside ); CGAL_triangulation_assertion( (! regular_case) || inside );
break; break;
case 3: case 3:
prev_after_walk = Simplex( std::get<0>(cur), Tr::FACET, 6-pos, -1 ); 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; o[li] = COPLANAR;
continue; continue;
} }
// Skip the previous cell. // Skip the previous cell.
Cell_handle next = cell()->neighbor(li); Cell_handle next = cell()->neighbor(li);
if( next == prev_cell() ) { if( next == prev_cell() ) {
@ -954,7 +954,7 @@ walk_to_next_2()
} }
case Tr::FACET: { case Tr::FACET: {
int li = 0; int li = 0;
Orientation o[3]; Orientation o[3];
bool calc[3] = { false, false, false }; 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[]) int main(int argc, char* argv[])
{ {
const std::vector<Point_3> points = { { -2, 0, 0 }, const std::vector<Point_3> points = { { -2, 0, 0 },
{ 2, 0, 0 }, { 2, 0, 0 },
{ 0, 1, -1 }, { 0, 1, -1 },
{ 0, -1, -1 }, { 0, -1, -1 },
{ 0, 0, 1 }, { 0, 0, 1 },
@ -35,10 +35,10 @@ int main(int argc, char* argv[])
std::vector<DT::Vertex_handle> vertices; std::vector<DT::Vertex_handle> vertices;
vertices.reserve(points.size()); vertices.reserve(points.size());
DT dt; DT dt;
for(auto p: points) vertices.push_back(dt.insert(p)); for(auto p: points) vertices.push_back(dt.insert(p));
Cell_handle c; Cell_handle c;
assert( dt.is_valid() ); assert( dt.is_valid() );
assert( dt.is_cell(vertices[0], vertices[2], vertices[3], vertices[4], c)); 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* []) int main(int, char* [])
{ {
const std::vector<Point_3> points = { { -2, 0, 0 }, const std::vector<Point_3> points = { { -2, 0, 0 },
{ 2, 0, 0 }, { 2, 0, 0 },
{ 0, 1, -1 }, { 0, 1, -1 },
{ 0, -1, -1 }, { 0, -1, -1 },
{ 0, 0, 1 }, { 0, 0, 1 },
@ -83,7 +83,7 @@ bool test(const DT& dt, const Big_tuple& tuple)
<< p2 << " )\n#\n"; << p2 << " )\n#\n";
Segment_simplex_iterator st = dt.segment_traverser_simplices_begin(p1, p2); Segment_simplex_iterator st = dt.segment_traverser_simplices_begin(p1, p2);
Segment_simplex_iterator stend = dt.segment_traverser_simplices_end(); 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_cells = 0, nb_facets = 0, nb_edges = 0, nb_vertex = 0;
unsigned int nb_collinear = 0; unsigned int nb_collinear = 0;

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

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