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

Merge remote-tracking branch 'cgal/releases/CGAL-4.13-branch' into HEAD

This commit is contained in:
Sébastien Loriot 2019-01-31 11:25:26 +01:00
parent 1ca9dbc514 99d842401a
commit e4cbae525c
25 changed files with 632 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Nef_2/include/CGAL/Nef_2/HDS_items.h
View File

@ -389,7 +389,9 @@ public:
hit->reset_fcit();
for (Isolated_vertex_iterator vit = iv_begin(); vit!=iv_end(); ++vit)
vit->reset_ivit();
FC.clear(); IV.clear(); }
FC.clear(); IV.clear();
_e=Halfedge_handle();
}
/*{\Mtext There are the same iterator ranges defined for the const
iterators |Hole_const_iterator|, |Isolated_vertex_const_iterator|.

2
Nef_2/include/CGAL/Nef_2/PM_const_decorator.h
View File

@ -473,7 +473,7 @@ check_integrity_and_topological_planarity(bool faces) const
int fc_num(0),iv_num(0);
Face_const_iterator fit;
for (fit = faces_begin(); fit != faces_end(); ++fit) {
if (!first) {
if (!first && halfedge(fit)!=Halfedge_const_handle()) {
CGAL_assertion( face(halfedge(fit))==fit ); ++fc_num;
}
Hole_const_iterator fcit;

19
Periodic_3_triangulation_3/demo/Periodic_3_triangulation_3/CMakeLists.txt
View File

@ -26,7 +26,13 @@ if(Qt5_FOUND)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
endif(Qt5_FOUND)
if (CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND TARGET Qt5::qcollectiongenerator)
if( Qt5Help_VERSION VERSION_LESS 5.12 )
set(CGAL_QCOLLECTIONGENERATOR_TARGET Qt5::qcollectiongenerator)
else()
set(CGAL_QCOLLECTIONGENERATOR_TARGET Qt5::qhelpgenerator)
endif()
if (CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND TARGET ${CGAL_QCOLLECTIONGENERATOR_TARGET})
# UI files (Qt Designer files)
qt5_wrap_ui ( UI_FILES MainWindow.ui )
@ -39,15 +45,10 @@ if (CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND TARGET Qt5::qcollectiongener
qt5_generate_moc( "MainWindow.h" "${CMAKE_CURRENT_BINARY_DIR}/moc_MainWindow.cpp" )
qt5_generate_moc( "Viewer.h" "${CMAKE_CURRENT_BINARY_DIR}/moc_Viewer.cpp" )
if(DEFINED QT_QCOLLECTIONGENERATOR_EXECUTABLE)
else()
set(QT_QCOLLECTIONGENERATOR_EXECUTABLE qcollectiongenerator)
endif()
# generate QtAssistant collection file
add_custom_command ( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Periodic_3_triangulation_3.qhc
DEPENDS Periodic_3_triangulation_3.qhp Periodic_3_triangulation_3.qhcp
COMMAND Qt5::qcollectiongenerator
COMMAND ${CGAL_QCOLLECTIONGENERATOR_TARGET}
${CMAKE_CURRENT_SOURCE_DIR}/Periodic_3_triangulation_3.qhcp
-o ${CMAKE_CURRENT_BINARY_DIR}/Periodic_3_triangulation_3.qhc
)
@ -83,8 +84,8 @@ else ()
set(PERIODIC_TRIANGULATION_MISSING_DEPS "Qt5, ${PERIODIC_TRIANGULATION_MISSING_DEPS}")
endif()
if (NOT TARGET Qt5::qcollectiongenerator)
set(PERIODIC_TRIANGULATION_MISSING_DEPS "qcollectiongenerator, ${PERIODIC_TRIANGULATION_MISSING_DEPS}")
if (NOT TARGET ${CGAL_QCOLLECTIONGENERATOR_TARGET})
set(PERIODIC_TRIANGULATION_MISSING_DEPS "${CGAL_QCOLLECTIONGENERATOR_TARGET}, ${PERIODIC_TRIANGULATION_MISSING_DEPS}")
endif()
message(STATUS "NOTICE: This demo requires ${PERIODIC_TRIANGULATION_MISSING_DEPS}and will not be compiled.")

11
Periodic_3_triangulation_3/demo/Periodic_Lloyd_3/CMakeLists.txt
View File

@ -21,8 +21,13 @@ find_package(CGAL COMPONENTS Qt5)
find_package(Qt5 QUIET COMPONENTS Xml Script Help OpenGL Svg)
if( Qt5Help_VERSION VERSION_LESS 5.12 )
set(CGAL_QCOLLECTIONGENERATOR_TARGET Qt5::qcollectiongenerator)
else()
set(CGAL_QCOLLECTIONGENERATOR_TARGET Qt5::qhelpgenerator)
endif()
if ( CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND TARGET Qt5::qcollectiongenerator )
if ( CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND TARGET ${CGAL_QCOLLECTIONGENERATOR_TARGET} )
include_directories (BEFORE ./ )
@ -41,7 +46,7 @@ if ( CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND TARGET Qt5::qcollectiongene
# generate QtAssistant collection file
add_custom_command ( OUTPUT Periodic_Lloyd_3.qhc
DEPENDS Periodic_Lloyd_3.qhp Periodic_Lloyd_3.qhcp
COMMAND Qt5::qcollectiongenerator
COMMAND ${CGAL_QCOLLECTIONGENERATOR_TARGET}
${CMAKE_CURRENT_SOURCE_DIR}/Periodic_Lloyd_3.qhcp
-o ${CMAKE_CURRENT_BINARY_DIR}/Periodic_Lloyd_3.qhc
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
@ -69,7 +74,7 @@ else( CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND AND QT_QCOLLECTIONGENERATOR_EX
endif()
if(NOT QT_QCOLLECTIONGENERATOR_EXECUTABLE)
set(PERIODIC_LLOYD_MISSING_DEPS "qcollectiongenerator, ${PERIODIC_LLOYD_MISSING_DEPS}")
set(PERIODIC_LLOYD_MISSING_DEPS "${CGAL_QCOLLECTIONGENERATOR_TARGET}, ${PERIODIC_LLOYD_MISSING_DEPS}")
endif()

2
Polyhedron/demo/Polyhedron/Plugins/Point_set/Point_set_normal_estimation_plugin.cpp
View File

@ -254,7 +254,7 @@ void Polyhedron_demo_point_set_normal_estimation_plugin::on_actionNormalEstimati
std::cerr << "Estimates normal direction by Jet Fitting (k=" << dialog.jet_neighbors() <<")...\n";
// Estimates normals direction.
Jet_estimate_normals_functor functor (points, dialog.pca_neighbors());
Jet_estimate_normals_functor functor (points, dialog.jet_neighbors());
run_with_qprogressdialog (functor, "Estimating normals by jet fitting...", mw);
std::size_t memory = CGAL::Memory_sizer().virtual_size();

4
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--PolynomialSubresultants.h
View File

@ -3,8 +3,6 @@
\ingroup PkgPolynomialConcepts
\cgalConcept
<B>Note:</B> This functor is optional!
Computes the polynomial subresultant of two polynomials \f$ p\f$ and \f$ q\f$ of
type `PolynomialTraits_d::Polynomial_d` with respect to outermost variable.
Let
@ -23,6 +21,8 @@ The result is written in an output range, starting with the \f$ 0\f$-th subresul
\f$ \mathrm{Sres}_0(p,q)\f$
(aka as the resultant of \f$ p\f$ and \f$ q\f$).
\note This functor is optional.
\cgalRefines `AdaptableBinaryFunction`
\cgalRefines `CopyConstructible`
\cgalRefines `DefaultConstructible`

4
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--PolynomialSubresultantsWithCofactors.h
View File

@ -3,8 +3,6 @@
\ingroup PkgPolynomialConcepts
\cgalConcept
<B>Note:</B> This functor is optional!
Computes the polynomial subresultant of two polynomials \f$ p\f$ and \f$ q\f$ of degree
\f$ n\f$ and \f$ m\f$, respectively,
as defined in the documentation of `PolynomialTraits_d::PolynomialSubresultants`.
@ -16,6 +14,8 @@ the <I>cofactors</I> of \f$ \mathrm{Sres}_i(p,q)\f$.
The result is written in three output ranges, each of length \f$ \min\{n,m\}+1\f$,
starting with the \f$ 0\f$-th subresultant and the corresponding cofactors.
\note This functor is optional.
\cgalRefines `AdaptableBinaryFunction`
\cgalRefines `CopyConstructible`
\cgalRefines `DefaultConstructible`

4
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--PrincipalSturmHabichtSequence.h
View File

@ -3,8 +3,6 @@
\ingroup PkgPolynomialConcepts
\cgalConcept
<B>Note:</B> This functor is optional!
Computes the principal leading coefficients of the Sturm-Habicht sequence
of a polynomials \f$ f\f$ of type `PolynomialTraits_d::Polynomial_d`
with respect a certain variable \f$ x_i\f$.
@ -19,6 +17,8 @@ In case that `PolynomialTraits_d::Coefficient_type` is `RealEmbeddable`, the fun
on the resulting sequence to count the number of distinct real roots of
the polynomial \f$ f\f$.
\note This functor is optional.
\cgalRefines `AdaptableBinaryFunction`
\cgalRefines `CopyConstructible`
\cgalRefines `DefaultConstructible`

4
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--PrincipalSubresultants.h
View File

@ -3,8 +3,6 @@
\ingroup PkgPolynomialConcepts
\cgalConcept
<B>Note:</B> This functor is optional!
Computes the principal subresultant of two polynomials \f$ p\f$ and \f$ q\f$ of
type `PolynomialTraits_d::Coefficient_type`
with respect to the outermost variable.
@ -19,6 +17,8 @@ principal subresultant \f$ \mathrm{sres}_0(p,q)\f$
,aka as the resultant of \f$ p\f$ and \f$ q\f$.
(Note that \f$ \mathrm{sres}_0(p,q)=\mathrm{Sres}_0(p,q)\f$ by definition)
\note This functor is optional.
\cgalRefines `AdaptableBinaryFunction`
\cgalRefines `CopyConstructible`
\cgalRefines `DefaultConstructible`

4
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--SturmHabichtSequence.h
View File

@ -3,8 +3,6 @@
\ingroup PkgPolynomialConcepts
\cgalConcept
<B>Note:</B> This functor is optional!
Computes the Sturm-Habicht sequence
(aka the signed subresultant sequence)
of a polynomial \f$ f\f$ of type
@ -27,6 +25,8 @@ The result is written in an output range,
starting with the \f$ 0\f$-th Sturm-Habicht polynomial (which is equal to
the discriminant of \f$ f\f$ up to a multiple of the leading coefficient).
\note This functor is optional.
\cgalRefines `AdaptableBinaryFunction`
\cgalRefines `CopyConstructible`
\cgalRefines `DefaultConstructible`

4
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--SturmHabichtSequenceWithCofactors.h
View File

@ -3,8 +3,6 @@
\ingroup PkgPolynomialConcepts
\cgalConcept
<B>Note:</B> This functor is optional!
Computes the Sturm-Habicht polynomials of a polynomial \f$ f\f$ of degree \f$ n\f$,
as defined in the documentation of `PolynomialTraits_d::SturmHabichtSequence`.
Moreover, for \f$ \mathrm{Stha}_i(f)\f$, polynomials \f$ u_i\f$ and \f$ v_i\f$
@ -16,6 +14,8 @@ The result is written in three output ranges, each of length \f$ \min\{n,m\}+1\f
starting with the \f$ 0\f$-th Sturm-Habicht polynomial \f$ \mathrm{Stha_0(f)}\f$
and the corresponding cofactors.
\note This functor is optional.
\cgalRefines `AdaptableBinaryFunction`
\cgalRefines `CopyConstructible`
\cgalRefines `DefaultConstructible`

1
Scripts/developer_scripts/cgal_create_release_with_cmake.cmake
View File

@ -266,6 +266,7 @@ if (TESTSUITE)
endif() #TESTSUITE
# removal of extra directories and files
file(REMOVE_RECURSE ${release_dir}/applications)
file(REMOVE_RECURSE ${release_dir}/benchmark)
file(REMOVE_RECURSE ${release_dir}/archive)
file(REMOVE ${release_dir}/include/CGAL/license/generate_files.cmake)

2
Segment_Delaunay_graph_Linf_2/include/CGAL/Segment_Delaunay_graph_Linf_filtered_traits_2.h
View File

@ -221,7 +221,7 @@ template<class CK,
#ifdef CGAL_USE_GMP
class EK = Simple_cartesian< Gmpq >,
#else
class EK = Simple_cartesian< MP_Float >,
class EK = Simple_cartesian< CGAL::Quotient<MP_Float> >,
#endif
class EK_MTag = Integral_domain_without_division_tag,
class FK = Simple_cartesian< Interval_nt<false> >,

8
Segment_Delaunay_graph_Linf_2/include/CGAL/Side_of_bounded_square_2.h
View File

@ -70,7 +70,7 @@ namespace CGAL {
bool samepq = false;
bool samepr = false;
bool sameqr = false;
const Comparison_result cmppq = compare(p, q);
const Comparison_result cmppq = CGAL::compare(p, q);
switch(cmppq) {
case SMALLER:
min_p = &p;
@ -86,7 +86,7 @@ namespace CGAL {
samepq = true;
break;
}
const Comparison_result cmppr = compare(p, r);
const Comparison_result cmppr = CGAL::compare(p, r);
Comparison_result cmpqr;
if (samepq) {
cmpqr = cmppr;
@ -105,7 +105,7 @@ namespace CGAL {
if (min_p == &p) {
switch(cmppr) {
case SMALLER:
cmpqr = compare(q, r);
cmpqr = CGAL::compare(q, r);
switch(cmpqr) {
case SMALLER:
max_p = &r;
@ -135,7 +135,7 @@ namespace CGAL {
max_p = &r;
break;
case LARGER:
cmpqr = compare(q, r);
cmpqr = CGAL::compare(q, r);
switch(cmpqr) {
case SMALLER:
break;

24
Segment_Delaunay_graph_Linf_2/test/Segment_Delaunay_graph_Linf_2/test_sdg_linf_2_et.cpp
View File

@ -10,28 +10,18 @@
#include <fstream>
#include <cassert>
// choose number type
#ifdef CGAL_USE_GMP
#include <CGAL/Exact_rational.h>
# include <CGAL/Gmpq.h>
typedef CGAL::Gmpq exact_ring_t;
typedef CGAL::Gmpq exact_field_t;
// choose number type
typedef CGAL::Exact_rational exact_ring_t;
typedef CGAL::Exact_rational exact_field_t;
namespace CGAL {
// needed for the drawing methods
Gmpq sqrt(const Gmpq& x) {
return Gmpq( CGAL::sqrt( CGAL::to_double(x) ) );
exact_ring_t sqrt(const exact_ring_t& x) {
return exact_ring_t( sqrt( to_double(x) ) );
}
}
} //namespace CGAL
#else
# include <CGAL/MP_Float.h>
# include <CGAL/Quotient.h>
typedef CGAL::MP_Float exact_ring_t;
typedef CGAL::Quotient<exact_ring_t> exact_field_t;
#endif
typedef exact_ring_t ring_number_t;
typedef exact_field_t field_number_t;

14
Segment_Delaunay_graph_Linf_2/test/Segment_Delaunay_graph_Linf_2/test_sdg_linf_2_ft.cpp
View File

@ -10,17 +10,11 @@
#include <fstream>
#include <cassert>
#include <CGAL/Exact_rational.h>
// choose number type
#ifdef CGAL_USE_GMP
# include <CGAL/Gmpq.h>
typedef CGAL::Gmpq exact_ring_t;
typedef CGAL::Gmpq exact_field_t;
#else
# include <CGAL/MP_Float.h>
# include <CGAL/Quotient.h>
typedef CGAL::MP_Float exact_ring_t;
typedef CGAL::Quotient<exact_ring_t> exact_field_t;
#endif
typedef CGAL::Exact_rational exact_ring_t;
typedef CGAL::Exact_rational exact_field_t;
#include <CGAL/Simple_cartesian.h>

24
Segment_Delaunay_graph_Linf_2/test/Segment_Delaunay_graph_Linf_2/test_sdg_linf_hierarchy_2_et.cpp
View File

@ -10,28 +10,18 @@
#include <fstream>
#include <cassert>
// choose number type
#ifdef CGAL_USE_GMP
#include <CGAL/Exact_rational.h>
# include <CGAL/Gmpq.h>
typedef CGAL::Gmpq exact_ring_t;
typedef CGAL::Gmpq exact_field_t;
// choose number type
typedef CGAL::Exact_rational exact_ring_t;
typedef CGAL::Exact_rational exact_field_t;
namespace CGAL {
// needed for the drawing methods
Gmpq sqrt(const Gmpq& x) {
return Gmpq( sqrt( to_double(x) ) );
exact_ring_t sqrt(const exact_ring_t& x) {
return exact_ring_t( sqrt( to_double(x) ) );
}
}
} //namespace CGAL
#else
# include <CGAL/MP_Float.h>
# include <CGAL/Quotient.h>
typedef CGAL::MP_Float exact_ring_t;
typedef CGAL::Quotient<exact_ring_t> exact_field_t;
#endif
typedef exact_ring_t ring_number_t;
typedef exact_field_t field_number_t;

14
Segment_Delaunay_graph_Linf_2/test/Segment_Delaunay_graph_Linf_2/test_sdg_linf_hierarchy_2_ft.cpp
View File

@ -10,17 +10,11 @@
#include <fstream>
#include <cassert>
#include <CGAL/Exact_rational.h>
// choose number type
#ifdef CGAL_USE_GMP
# include <CGAL/Gmpq.h>
typedef CGAL::Gmpq exact_ring_t;
typedef CGAL::Gmpq exact_field_t;
#else
# include <CGAL/MP_Float.h>
# include <CGAL/Quotient.h>
typedef CGAL::MP_Float exact_ring_t;
typedef CGAL::Quotient<exact_ring_t> exact_field_t;
#endif
typedef CGAL::Exact_rational exact_ring_t;
typedef CGAL::Exact_rational exact_field_t;
#include <CGAL/Simple_cartesian.h>

6
Segment_Delaunay_graph_Linf_2/test/Segment_Delaunay_graph_Linf_2/test_sdg_linf_new_range_api.cpp
View File

@ -7,12 +7,14 @@
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Segment_Delaunay_graph_Linf_filtered_traits_2.h>
#include <CGAL/Segment_Delaunay_graph_Linf_2.h>
#include <CGAL/Gmpq.h>
#include <CGAL/Exact_rational.h>
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef CGAL::Field_with_sqrt_tag MTag;
typedef CGAL::Integral_domain_without_division_tag EMTag;
typedef CGAL::Simple_cartesian<CGAL::Gmpq> EK;
typedef CGAL::Exact_rational Number_type;
typedef CGAL::Simple_cartesian<Number_type> EK;
typedef CGAL::Segment_Delaunay_graph_Linf_filtered_traits_without_intersections_2<K, MTag, EK, EMTag> Gt;
typedef CGAL::Segment_Delaunay_graph_Linf_2<Gt> SDG;

4
Solver_interface/doc/Solver_interface/Concepts/DiagonalizeTraits.h
View File

@ -4,7 +4,9 @@
Concept providing functions to extract eigenvectors and eigenvalues
from covariance matrices represented by an array `a`, using symmetric
diagonalization. For example, a matrix of dimension 3 is defined as
diagonalization.
For example, a matrix of dimension 3 is defined as
follows:
<center>
\f$ \begin{bmatrix}

2
Straight_skeleton_2/doc/Straight_skeleton_2/Concepts/VertexContainer_2.h
View File

@ -2,8 +2,6 @@
\ingroup PkgStraightSkeleton2Concepts
\cgalConcept
\cgalHeading{Introduction}
A model for the `VertexContainer_2` concept defines the requirements for a resizable container of 2D points. It is used to output the offset polygons generated by the `Polygon_offset_builder_2<Ssds,Gt,Container>` class.
\cgalHasModel CGAL::Polygon_2

4
Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_masks_3.h
View File

@ -215,13 +215,13 @@ public:
/// computes the Catmull-Clark vertex-point `pt` of the vertex `vertex`.
void vertex_node(vertex_descriptor vertex, Point& pt) {
Halfedge_around_target_circulator<Mesh> vcir(vertex, *(this->pmesh));
typename boost::graph_traits<Mesh>::degree_size_type n = degree(vertex, *(this->pmesh));
int n = static_cast<int>(degree(vertex, *(this->pmesh)));
FT Q[] = {0.0, 0.0, 0.0}, R[] = {0.0, 0.0, 0.0};
Point_ref S = get(this->vpmap,vertex);
Point q;
for (typename boost::graph_traits<Mesh>::degree_size_type i = 0; i < n; i++, ++vcir) {
for (int i = 0; i < n; i++, ++vcir) {
Point_ref p2 = get(this->vpmap, target(opposite(*vcir, *(this->pmesh)), *(this->pmesh)));
R[0] += (S[0] + p2[0]) / 2;
R[1] += (S[1] + p2[1]) / 2;

5
Triangulation_2/include/CGAL/Delaunay_triangulation_2.h
View File

@ -504,8 +504,11 @@ private:
} else {
*(pit.first)++ = fn;
int j = fn->index(fh);
stack.push(std::make_pair(fn,ccw(j)));
// In the non-recursive version, we walk via 'ccw(j)' first. Here, we are filling the stack
// and the order is thus the opposite (we want the top element of the stack to be 'ccw(j)')
stack.push(std::make_pair(fn,cw(j)));
stack.push(std::make_pair(fn,ccw(j)));
}
}
return pit;

502
Triangulation_2/test/Triangulation_2/data/layers.xy Normal file
View File

@ -0,0 +1,502 @@
10 0
10 0.01
10 0.02
10 0.029999999999999999
10 0.040000000000000001
10 0.050000000000000003
10 0.059999999999999998
10 0.070000000000000007
10 0.080000000000000002
10 0.089999999999999997
10 0.10000000000000001
10 0.11
10 0.12
10 0.13
10 0.14000000000000001
10 0.14999999999999999
10 0.16
10 0.17000000000000001
10 0.17999999999999999
10 0.19
10 0.20000000000000001
10 0.20999999999999999
10 0.22
10 0.23000000000000001
10 0.23999999999999999
10 0.25
10 0.26000000000000001
10 0.27000000000000002
10 0.28000000000000003
10 0.28999999999999998
10 0.29999999999999999
10 0.31
10 0.32000000000000001
10 0.33000000000000002
10 0.34000000000000002
10 0.34999999999999998
10 0.35999999999999999
10 0.37
10 0.38
10 0.39000000000000001
10 0.40000000000000002
10 0.40999999999999998
10 0.41999999999999998
10 0.42999999999999999
10 0.44
10 0.45000000000000001
10 0.46000000000000002
10 0.46999999999999997
10 0.47999999999999998
10 0.48999999999999999
10 0.5
10 0.51000000000000001
10 0.52000000000000002
10 0.53000000000000003
10 0.54000000000000004
10 0.55000000000000004
10 0.56000000000000005
10 0.56999999999999995
10 0.57999999999999996
10 0.58999999999999997
10 0.59999999999999998
10 0.60999999999999999
10 0.62
10 0.63
10 0.64000000000000001
10 0.65000000000000002
10 0.66000000000000003
10 0.67000000000000004
10 0.68000000000000005
10 0.68999999999999995
10 0.69999999999999996
10 0.70999999999999996
10 0.71999999999999997
10 0.72999999999999998
10 0.73999999999999999
10 0.75
10 0.76000000000000001
10 0.77000000000000002
10 0.78000000000000003
10 0.79000000000000004
10 0.80000000000000004
10 0.81000000000000005
10 0.81999999999999995
10 0.82999999999999996
10 0.83999999999999997
10 0.84999999999999998
10 0.85999999999999999
10 0.87
10 0.88
10 0.89000000000000001
10 0.90000000000000002
10 0.91000000000000003
10 0.92000000000000004
10 0.93000000000000005
10 0.93999999999999995
10 0.94999999999999996
10 0.95999999999999996
10 0.96999999999999997
10 0.97999999999999998
10 0.98999999999999999
10 1
10 1.01
10 1.02
10 1.03
10 1.04
10 1.05
10 1.0600000000000001
10 1.0700000000000001
10 1.0800000000000001
10 1.0900000000000001
10 1.1000000000000001
10 1.1100000000000001
10 1.1200000000000001
10 1.1299999999999999
10 1.1399999999999999
10 1.1499999999999999
10 1.1599999999999999
10 1.1699999999999999
10 1.1799999999999999
10 1.1899999999999999
10 1.2
10 1.21
10 1.22
10 1.23
10 1.24
10 1.25
10 1.26
10 1.27
10 1.28
10 1.29
10 1.3
10 1.3100000000000001
10 1.3200000000000001
10 1.3300000000000001
10 1.3400000000000001
10 1.3500000000000001
10 1.3600000000000001
10 1.3700000000000001
10 1.3799999999999999
10 1.3899999999999999
10 1.3999999999999999
10 1.4099999999999999
10 1.4199999999999999
10 1.4299999999999999
10 1.4399999999999999
10 1.45
10 1.46
10 1.47
10 1.48
10 1.49
10 1.5
10 1.51
10 1.52
10 1.53
10 1.54
10 1.55
10 1.5600000000000001
10 1.5700000000000001
10 1.5800000000000001
10 1.5900000000000001
10 1.6000000000000001
10 1.6100000000000001
10 1.6200000000000001
10 1.6299999999999999
10 1.6399999999999999
10 1.6499999999999999
10 1.6599999999999999
10 1.6699999999999999
10 1.6799999999999999
10 1.6899999999999999
10 1.7
10 1.71
10 1.72
10 1.73
10 1.74
10 1.75
10 1.76
10 1.77
10 1.78
10 1.79
10 1.8
10 1.8100000000000001
10 1.8200000000000001
10 1.8300000000000001
10 1.8400000000000001
10 1.8500000000000001
10 1.8600000000000001
10 1.8700000000000001
10 1.8799999999999999
10 1.8899999999999999
10 1.8999999999999999
10 1.9099999999999999
10 1.9199999999999999
10 1.9299999999999999
10 1.9399999999999999
10 1.95
10 1.96
10 1.97
10 1.98
10 1.99
10 2
10 2.0099999999999998
10 2.02
10 2.0299999999999998
10 2.04
10 2.0499999999999998
10 2.0600000000000001
10 2.0699999999999998
10 2.0800000000000001
10 2.0899999999999999
10 2.1000000000000001
10 2.1099999999999999
10 2.1200000000000001
10 2.1299999999999999
10 2.1400000000000001
10 2.1499999999999999
10 2.1600000000000001
10 2.1699999999999999
10 2.1800000000000002
10 2.1899999999999999
10 2.2000000000000002
10 2.21
10 2.2200000000000002
10 2.23
10 2.2400000000000002
10 2.25
10 2.2599999999999998
10 2.27
10 2.2799999999999998
10 2.29
10 2.2999999999999998
10 2.3100000000000001
10 2.3199999999999998
10 2.3300000000000001
10 2.3399999999999999
10 2.3500000000000001
10 2.3599999999999999
10 2.3700000000000001
10 2.3799999999999999
10 2.3900000000000001
10 2.3999999999999999
10 2.4100000000000001
10 2.4199999999999999
10 2.4300000000000002
10 2.4399999999999999
10 2.4500000000000002
10 2.46
10 2.4700000000000002
10 2.48
10 2.4900000000000002
10 2.5
20 0
20 0.01
20 0.02
20 0.029999999999999999
20 0.040000000000000001
20 0.050000000000000003
20 0.059999999999999998
20 0.070000000000000007
20 0.080000000000000002
20 0.089999999999999997
20 0.10000000000000001
20 0.11
20 0.12
20 0.13
20 0.14000000000000001
20 0.14999999999999999
20 0.16
20 0.17000000000000001
20 0.17999999999999999
20 0.19
20 0.20000000000000001
20 0.20999999999999999
20 0.22
20 0.23000000000000001
20 0.23999999999999999
20 0.25
20 0.26000000000000001
20 0.27000000000000002
20 0.28000000000000003
20 0.28999999999999998
20 0.29999999999999999
20 0.31
20 0.32000000000000001
20 0.33000000000000002
20 0.34000000000000002
20 0.34999999999999998
20 0.35999999999999999
20 0.37
20 0.38
20 0.39000000000000001
20 0.40000000000000002
20 0.40999999999999998
20 0.41999999999999998
20 0.42999999999999999
20 0.44
20 0.45000000000000001
20 0.46000000000000002
20 0.46999999999999997
20 0.47999999999999998
20 0.48999999999999999
20 0.5
20 0.51000000000000001
20 0.52000000000000002
20 0.53000000000000003
20 0.54000000000000004
20 0.55000000000000004
20 0.56000000000000005
20 0.56999999999999995
20 0.57999999999999996
20 0.58999999999999997
20 0.59999999999999998
20 0.60999999999999999
20 0.62
20 0.63
20 0.64000000000000001
20 0.65000000000000002
20 0.66000000000000003
20 0.67000000000000004
20 0.68000000000000005
20 0.68999999999999995
20 0.69999999999999996
20 0.70999999999999996
20 0.71999999999999997
20 0.72999999999999998
20 0.73999999999999999
20 0.75
20 0.76000000000000001
20 0.77000000000000002
20 0.78000000000000003
20 0.79000000000000004
20 0.80000000000000004
20 0.81000000000000005
20 0.81999999999999995
20 0.82999999999999996
20 0.83999999999999997
20 0.84999999999999998
20 0.85999999999999999
20 0.87
20 0.88
20 0.89000000000000001
20 0.90000000000000002
20 0.91000000000000003
20 0.92000000000000004
20 0.93000000000000005
20 0.93999999999999995
20 0.94999999999999996
20 0.95999999999999996
20 0.96999999999999997
20 0.97999999999999998
20 0.98999999999999999
20 1
20 1.01
20 1.02
20 1.03
20 1.04
20 1.05
20 1.0600000000000001
20 1.0700000000000001
20 1.0800000000000001
20 1.0900000000000001
20 1.1000000000000001
20 1.1100000000000001
20 1.1200000000000001
20 1.1299999999999999
20 1.1399999999999999
20 1.1499999999999999
20 1.1599999999999999
20 1.1699999999999999
20 1.1799999999999999
20 1.1899999999999999
20 1.2
20 1.21
20 1.22
20 1.23
20 1.24
20 1.25
20 1.26
20 1.27
20 1.28
20 1.29
20 1.3
20 1.3100000000000001
20 1.3200000000000001
20 1.3300000000000001
20 1.3400000000000001
20 1.3500000000000001
20 1.3600000000000001
20 1.3700000000000001
20 1.3799999999999999
20 1.3899999999999999
20 1.3999999999999999
20 1.4099999999999999
20 1.4199999999999999
20 1.4299999999999999
20 1.4399999999999999
20 1.45
20 1.46
20 1.47
20 1.48
20 1.49
20 1.5
20 1.51
20 1.52
20 1.53
20 1.54
20 1.55
20 1.5600000000000001
20 1.5700000000000001
20 1.5800000000000001
20 1.5900000000000001
20 1.6000000000000001
20 1.6100000000000001
20 1.6200000000000001
20 1.6299999999999999
20 1.6399999999999999
20 1.6499999999999999
20 1.6599999999999999
20 1.6699999999999999
20 1.6799999999999999
20 1.6899999999999999
20 1.7
20 1.71
20 1.72
20 1.73
20 1.74
20 1.75
20 1.76
20 1.77
20 1.78
20 1.79
20 1.8
20 1.8100000000000001
20 1.8200000000000001
20 1.8300000000000001
20 1.8400000000000001
20 1.8500000000000001
20 1.8600000000000001
20 1.8700000000000001
20 1.8799999999999999
20 1.8899999999999999
20 1.8999999999999999
20 1.9099999999999999
20 1.9199999999999999
20 1.9299999999999999
20 1.9399999999999999
20 1.95
20 1.96
20 1.97
20 1.98
20 1.99
20 2
20 2.0099999999999998
20 2.02
20 2.0299999999999998
20 2.04
20 2.0499999999999998
20 2.0600000000000001
20 2.0699999999999998
20 2.0800000000000001
20 2.0899999999999999
20 2.1000000000000001
20 2.1099999999999999
20 2.1200000000000001
20 2.1299999999999999
20 2.1400000000000001
20 2.1499999999999999
20 2.1600000000000001
20 2.1699999999999999
20 2.1800000000000002
20 2.1899999999999999
20 2.2000000000000002
20 2.21
20 2.2200000000000002
20 2.23
20 2.2400000000000002
20 2.25
20 2.2599999999999998
20 2.27
20 2.2799999999999998
20 2.29
20 2.2999999999999998
20 2.3100000000000001
20 2.3199999999999998
20 2.3300000000000001
20 2.3399999999999999
20 2.3500000000000001
20 2.3599999999999999
20 2.3700000000000001
20 2.3799999999999999
20 2.3900000000000001
20 2.3999999999999999
20 2.4100000000000001
20 2.4199999999999999
20 2.4300000000000002
20 2.4399999999999999
20 2.4500000000000002
20 2.46
20 2.4700000000000002
20 2.48
20 2.4900000000000002
20 2.5

63
Triangulation_2/test/Triangulation_2/include/CGAL/_test_cls_delaunay_triangulation_2.h
View File

@ -20,20 +20,21 @@
// coordinator : INRIA Sophia-Antipolis <Mariette Yvinec@sophia.inria.fr>
// ============================================================================
#include <iostream>
#include <iterator>
//#include <vector>
#include <CGAL/_test_cls_triangulation_short_2.h>
#include <cassert>
#include <iostream>
#include <iterator>
#include <fstream>
#include <vector>
#include <cstdlib>
using std::rand;
using std::rand;
template <class Del>
void
_test_delaunay_duality( const Del &T );
template <class Del>
void
_test_cls_delaunay_triangulation_2( const Del & )
@ -136,14 +137,58 @@ _test_cls_delaunay_triangulation_2( const Del & )
// test insertion through get_conflicts + star_hole
conflicts.clear();
hole_bd.clear();
T2.get_conflicts_and_boundary(Point(1,1,2),
std::back_inserter(conflicts),
std::back_inserter(hole_bd));
Point query(1,1,2);
T2.get_conflicts_and_boundary(query,
std::back_inserter(conflicts),
std::back_inserter(hole_bd));
// check the sanity of the boundary (faces are not in conflict && edges are ccw ordered)
typename std::list<Edge>::iterator curr = hole_bd.begin(), last = --(hole_bd.end());
Vertex_handle prev_vh = last->first->vertex(T2.ccw(last->second));
do
{
assert(curr->first->vertex(T2.cw(curr->second)) == prev_vh);
assert(!T2.test_conflict(query, curr->first));
prev_vh = curr->first->vertex(T2.ccw(curr->second));
++curr;
}
while(curr != hole_bd.end());
T2.star_hole (Point(1,1,2), hole_bd.begin(), hole_bd.end(),
conflicts.begin(), conflicts.end() );
assert(T2.is_valid());
// check get_conflict for a large enough point set (to use the non-recursive function)
double x, y;
std::vector<Point> layer_pts;
std::ifstream in("data/layers.xy");
assert(in);
while(in >> x >> y)
layer_pts.push_back(Point(x, y));
Del T2b(layer_pts.begin(), layer_pts.end());
conflicts.clear();
hole_bd.clear();
query = Point(12.25, 0.031250);
T2b.get_conflicts_and_boundary(query,
std::back_inserter(conflicts),
std::back_inserter(hole_bd));
// check the sanity of the boundary (faces are not in conflict && edges are ccw ordered)
curr = hole_bd.begin(), last = --(hole_bd.end());
prev_vh = last->first->vertex(T2b.ccw(last->second));
do
{
assert(curr->first->vertex(T2b.cw(curr->second)) == prev_vh);
assert(!T2b.test_conflict(query, curr->first));
prev_vh = curr->first->vertex(T2b.ccw(curr->second));
++curr;
}
while(curr != hole_bd.end());
/********************/
/***** Duality ******/