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

Merge remote-tracking branch 'origin/master' into Barycentric_coordinates_2-danston

This commit is contained in:
Dmitry Anisimov 2021-08-13 11:34:58 +02:00
parent d03c669cd3 89aec88abc
commit 650fc04303
61 changed files with 589 additions and 1104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BGL/include/CGAL/boost/graph/parameters_interface.h
View File

@ -179,6 +179,7 @@ CGAL_add_named_parameter(pointmatcher_config_t, pointmatcher_config, pointmatche
CGAL_add_named_parameter(adjacencies_t, adjacencies, adjacencies) CGAL_add_named_parameter(adjacencies_t, adjacencies, adjacencies)
CGAL_add_named_parameter(scan_angle_t, scan_angle_map, scan_angle_map) CGAL_add_named_parameter(scan_angle_t, scan_angle_map, scan_angle_map)
CGAL_add_named_parameter(scanline_id_t, scanline_id_map, scanline_id_map) CGAL_add_named_parameter(scanline_id_t, scanline_id_map, scanline_id_map)
CGAL_add_named_parameter(scalar_t, scalar_map, scalar_map)
// List of named parameters used in Surface_mesh_approximation package // List of named parameters used in Surface_mesh_approximation package
CGAL_add_named_parameter(verbose_level_t, verbose_level, verbose_level) CGAL_add_named_parameter(verbose_level_t, verbose_level, verbose_level)

4
BGL/test/BGL/data/colored_tetra.ply
View File

@ -18,8 +18,8 @@ property uchar green
property uchar blue property uchar blue
property int label property int label
element edge 6 element edge 6
property int v0 property int vertex1
property int v1 property int vertex2
property float confidence property float confidence
end_header end_header
0 0 0 -0.5 -0.5 -0.5 255 255 0 0 0 0 0 -0.5 -0.5 -0.5 255 255 0 0

4
BGL/test/BGL/data/invalid_cut.ply
View File

@ -18,8 +18,8 @@ property uchar green
property uchar blue property uchar blue
property int label property int label
element edge 6 element edge 6
property int v0 property int vertex1
property int v1 property int vertex2
property float confidence property float confidence
end_header end_header
0 0 0 -0.5 -0.5 -0.5 255 255 0 0 0 0 0 -0.5 -0.5 -0.5 255 255 0 0

4
BGL/test/BGL/data/invalid_nv.ply
View File

@ -18,8 +18,8 @@ property uchar green
property uchar blue property uchar blue
property int label property int label
element edge 6 element edge 6
property int v0 property int vertex1
property int v1 property int vertex2
property float confidence property float confidence
end_header end_header
0 0 0 -0.5 -0.5 -0.5 0 0 0 0 -0.5 -0.5 -0.5 0

3
BGL/test/BGL/test_split.cpp
View File

@ -24,7 +24,8 @@ typedef std::vector<Point_2> Polyline_2;
// inserts a polyline into a graph // inserts a polyline into a graph
void insert(const std::vector<Point_2>& poly, Graph& graph, Point_vertex_map& pvmap) void insert(const std::vector<Point_2>& poly, Graph& graph, Point_vertex_map& pvmap)
{ {
vertex_descriptor u, v; vertex_descriptor u = boost::graph_traits<Graph>::null_vertex();
vertex_descriptor v;
for (std::size_t i = 0; i < poly.size(); i++) { for (std::size_t i = 0; i < poly.size(); i++) {
// check if the point is not yet in the graph // check if the point is not yet in the graph
if (pvmap.find(poly[i]) == pvmap.end()) { if (pvmap.find(poly[i]) == pvmap.end()) {

10
Cartesian_kernel/include/CGAL/Cartesian/function_objects.h
View File

@ -606,6 +606,7 @@ namespace CartesianKernelFunctors {
template <typename K> template <typename K>
class Compare_slope_2 class Compare_slope_2
{ {
typedef typename K::Point_2 Point_2;
typedef typename K::Line_2 Line_2; typedef typename K::Line_2 Line_2;
typedef typename K::Segment_2 Segment_2; typedef typename K::Segment_2 Segment_2;
public: public:
@ -625,6 +626,15 @@ namespace CartesianKernelFunctors {
s2.source().x(), s2.source().y(), s2.source().x(), s2.source().y(),
s2.target().x(), s2.target().y()); s2.target().x(), s2.target().y());
} }
result_type
operator()(const Point_2& s1s, const Point_2& s1t, const Point_2& s2s, const Point_2& s2t) const
{
return compare_slopesC2(s1s.x(), s1s.y(),
s1t.x(), s1t.y(),
s2s.x(), s2s.y(),
s2t.x(), s2t.y());
}
}; };
template <typename K> template <typename K>

132
Circular_kernel_2/benchmark/DxfArrayBenchmarks/benchmarks_arrangement.cpp
View File

@ -1,11 +1,7 @@
#define CGAL_CAST_INT #define CGAL_CAST_INT
#define CIRCULAR_KERNEL_2 #define CIRCULAR_KERNEL_2
#define LAZY_CURVED_KERNEL_2
//#define CIRCULAR_KERNEL_2_FILTERED_HEXAGON
//#define LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON
// #define CIRCULAR_KERNEL_2_FILTERED_BBOX // #define CIRCULAR_KERNEL_2_FILTERED_BBOX
//#define LAZY_CURVED_KERNEL_2_FILTERED_BBOX
#define CGAL_CAST_INT #define CGAL_CAST_INT
#include <CGAL/Cartesian.h> #include <CGAL/Cartesian.h>
@ -22,9 +18,7 @@
#include <CGAL/Circular_arc_traits.h> #include <CGAL/Circular_arc_traits.h>
#include <CGAL/Circular_arc_traits_tracer.h> #include <CGAL/Circular_arc_traits_tracer.h>
#include <CGAL/Lazy_circular_kernel_2.h>
#include <CGAL/Filtered_hexagon_circular_kernel_2.h>
#include <CGAL/Filtered_bbox_circular_kernel_2.h> #include <CGAL/Filtered_bbox_circular_kernel_2.h>
@ -88,80 +82,7 @@ for(i=1;i<6;i++){
//bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]); //bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]);
#endif #endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef LAZY_CURVED_KERNEL_2
// typedef CGAL::Quotient<CGAL::MP_Float> NT2;
typedef CGAL::Gmpq NT2;
typedef CGAL::Cartesian<NT2> Linear_k2;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT2> Algebraic_k2;
typedef CGAL::Circular_kernel_2 <Linear_k2, Algebraic_k2> CK2_;
typedef CGAL::Interval_nt_advanced NT3;
typedef CGAL::Cartesian<NT3> Linear_k3;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT3> Algebraic_k3;
typedef CGAL::Circular_kernel_2 <Linear_k3,Algebraic_k3> CK3_;
typedef CGAL::Lazy_circular_kernel_2<CK2_,CK3_> LazyCurvedK;
typedef LazyCurvedK::Circular_arc_2 Circular_arc_3;
typedef LazyCurvedK::Line_arc_2 Line_arc_3;
typedef boost::variant<Circular_arc_3,Line_arc_3 > LazyVarArc;
typedef std::vector<LazyVarArc> LazyVarContainer;
typedef CGAL::Variant_traits<LazyCurvedK,Line_arc_3,Circular_arc_3> LazyCurvedK_Variant_Traits;
bench.kernel("LazyK. VarTraits");
bench.ComputeArrayDxf<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(dxffilenames);
//bench.Compute_dxf<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
#endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef CIRCULAR_KERNEL_2_FILTERED_HEXAGON
typedef CGAL::Filtered_hexagon_circular_kernel_2<CircularKernel> CircularKernelHexagon;
typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4;
typedef CircularKernelHexagon::Line_arc_2 Line_arc_4;
typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc;
typedef std::vector<CircularKernHexVarArc> CircularKernHexVarArcContainer;
typedef CGAL::Variant_traits<CircularKernelHexagon,Circular_arc_4,Line_arc_4> CircularKernHex_Variant_Traits;
bench.kernel("CK Hex VarTraits");
// bench.Compute<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>(Dxffilename[i]);
bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>();
#endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON
typedef CGAL::Filtered_hexagon_curved_kernel<LazyCurvedK> LazyKernelHexagon;
typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5;
typedef LazyKernelHexagon::Line_arc_2 Line_arc_5;
typedef boost::variant<Circular_arc_5,Line_arc_5 > HxLazyVarArc;
typedef std::vector<HxLazyVarArc> HxLazyVarContainer;
typedef CGAL::Variant_traits<LazyKernelHexagon,Line_arc_5,Circular_arc_5> HxLazyVariantTraits;
bench.kernel("LazyK Hex VarTraits") ;
//bench.Compute<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>();
#endif
/*------------------------------------------------------------------------------------------------------------------------- /*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!! !!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!!
@ -182,58 +103,7 @@ bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>()
// bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(); // bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>();
#endif #endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef LAZY_CURVED_KERNEL_2_FILTERED_BBOX
typedef CGAL::Filtered_bbox_curved_kernel<LazyCurvedK> BBLazyCurvedK;
typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7;
typedef BBLazyCurvedK::Line_arc_2 Line_arc_7;
typedef boost::variant<Circular_arc_7,Line_arc_7 > BBLazyVarArc;
typedef std::vector< BBLazyVarArc> BBLazyVarContainer;
typedef CGAL::Variant_traits<BBLazyCurvedK,Line_arc_7,Circular_arc_7> BBLazyVariantTraits;
bench.kernel("LLazyK BBox VarTraits") ;
bench.Compute<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>(Dxffilename[i]);
//bench.Compute_no_dxf<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>();
#endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<CircularKernelHexagon> BBCircKHexagon ;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBCircKHexagon> BBCircKHexagonCATraits;
#else
typedef CGAL::Circular_arc_traits<BBCircKHexagon> Traits0_7;
typedef CGAL::Circular_arc_traits_tracer<Traits0_7> BBCircKHexagonCATraits;
#endif
typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc;
typedef std::vector<BBCircKHexagon> BBCircKHexagonArcCont;
bench.kernel("BBox Circular kernel filtered Hexagon CircArcTraits");
bench.Compute_no_dxf<BBCircKHexagon,BBCircKHexagonCATraits, BBCircKHexagonArcCont>();
typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8;
typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8;
typedef boost::variant<Circular_arc_8,Line_arc_8 > BBCircularKernelHexagonVarArc;
typedef std::vector<BBCircularKernelHexagonVarArc> BBCircularKernelHexagonVarContainer;
typedef CGAL::Variant_traits<BBCircularKernelHexagon,Line_arc_8,Circular_arc_8> BBCircularKernelHexagonVariantTraits;
bench.kernel("BBox Circular kernel filtered Hexagon VarTraits") ;
//bench.Compute<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBCircularKernelHexagon,BBCircularKernelHexagonVariantTraits,BBCircularKernelHexagonVarContainer>();*/
/*--------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------*/
dxffilenames.erase(dxffilenames.begin(),dxffilenames.end()); dxffilenames.erase(dxffilenames.begin(),dxffilenames.end());
if (i<5){ if (i<5){
for(int n = 3*(i+1)-3; n < 3*(i+1); n++){ for(int n = 3*(i+1)-3; n < 3*(i+1); n++){
@ -245,5 +115,3 @@ for(int n = 3*(i+1)-3; n < 3*(i+1); n++){
return 0; return 0;
}; };

6
Circular_kernel_2/benchmark/README_benchmark_CK2.txt
View File

@ -3,13 +3,9 @@ The usage is:
where alpha: where alpha:
1: means to bench the BBox(CK) with Vartraits 1: means to bench the BBox(CK) with Vartraits
2: means to bench the Lazy(CK) with Vartraits
3: means to bench the CK with Vartraits 3: means to bench the CK with Vartraits
4: means to bench the Bbox(Lazy(CK)) with Vartraits
5: means to bench the BBox(CK) with Circulartraits 5: means to bench the BBox(CK) with Circulartraits
6: means to bench the Lazy(CK) with Circulartraits
7: means to bench the CK(CK) with Circulartraits 7: means to bench the CK(CK) with Circulartraits
8: means to bench the Bbox(Lazy(CK)) Circulartraits
(le 0 est interne) (le 0 est interne)
beta: beta:
@ -74,5 +70,3 @@ with 5 <= a <= 8 and 0 <= b <= 8, we cannot use the Circulartraits to handle th
Compile with -DCGAL_INTERSECTION_MAP_FOR_SUPPORTING_CIRCLES if you want to benchmark with Compile with -DCGAL_INTERSECTION_MAP_FOR_SUPPORTING_CIRCLES if you want to benchmark with
the same kernel, but with an additional map for supporting circles. the same kernel, but with an additional map for supporting circles.

269
Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrangement.cpp
View File

@ -15,10 +15,6 @@
#include <CGAL/Circular_arc_traits.h> #include <CGAL/Circular_arc_traits.h>
#include <CGAL/Circular_arc_traits_tracer.h> #include <CGAL/Circular_arc_traits_tracer.h>
#include <CGAL/Lazy_circular_kernel_2.h>
#include <CGAL/Filtered_hexagon_circular_kernel_2.h>
#include <CGAL/Filtered_bbox_circular_kernel_2.h> #include <CGAL/Filtered_bbox_circular_kernel_2.h>
#include <CGAL/Arrangement_2.h> #include <CGAL/Arrangement_2.h>
@ -141,75 +137,13 @@ Bench bench(Htmlfilename,Texfilename,Dxffilename[i]);
} }
fin.close(); fin.close();
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Place for tests!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
// typedef CGAL::Lazy_exact_nt<CGAL::Quotient<CGAL::MP_Float> > NT4;
// typedef CGAL::Cartesian<NT4> Linear_k4;
// typedef CGAL::Algebraic_kernel_2_2<NT4> Algebraic_k4;
// typedef CGAL::Curved_kernel<Linear_k4,Algebraic_k4> CK4;
//
// #ifndef CGAL_CURVED_KERNEL_DEBUG
// typedef CGAL::Circular_arc_traits<CK4> CircularK_CA_Traits;
// #else
// typedef CGAL::Circular_arc_traits<CK4> Traits0;
// typedef CGAL::Circular_arc_traits_tracer<Traits0> CircularK_CA_Traits;
// #endif
//
// typedef CK4::Circular_arc_2 CircularKArc;
// typedef std::vector<CircularKArc> CircularKArcContainer;
// bench.kernel("Circular kernel Circular arc traits");
//
// typedef CircularK_CA_Traits::Curve_2 Conic_arc_2;
// typedef CGAL::Arrangement_2<CircularK_CA_Traits> Pmwx;
// typedef CGAL::Arr_naive_point_location<Pmwx> Point_location;
//
// typedef CircularK_CA_Traits::X_monotone_curve_2 X_monotone_curve_2;
// typedef CK4::Point_2 Point_2;
// typedef CK4::Circle_2 Circle_2;
// typedef CK4::Circular_arc_2 Circular_arc_2;
//
//
// CGAL::Random generatorOfgenerator;
// int random_seed = generatorOfgenerator.get_int(0, 123456);
// std::cout << "random_seed = " << random_seed << std::endl;
// CGAL::Random theRandom(random_seed);
// int random_max = 128;
// int random_min = -128;
// CircularKArcContainer ac;
// int x;
// int y;
// int r;
// for(int i = 0; i < 20; i++){
// x = theRandom.get_int(random_min,random_max);
// y = theRandom.get_int(random_min,random_max);
// r = theRandom.get_int(1,random_max);
// ac.push_back( Circle_2( Point_2(x,y), r*r));
// }
//
// // Pmwx _pm;
// // Point_location _pl(_pm);
// // try{
// // bench.start();
// // for (typename ArcContainer::const_iterator it=ac.begin();
// // it != ac.end(); ++it) {
// // //insert(_pm,_pl,*it);
// // insert(_pm,*it,_pl);
// // };
// // bench.stop();
// // bench.summarize(_pm.number_of_vertices(),_pm.number_of_halfedges());
// // }
// // catch (...) {
// // bench.fail();
// // }
/*------------------------------------------------------------------------------------------------------------------------- /*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Circular_Kernel!!!!!!!!!!!!!!!!!! !!!!!!!!!!!Circular_Kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/ -------------------------------------------------------------------------------------------------------------------------*/
typedef CGAL::Quotient<CGAL::MP_Float> NT1; typedef CGAL::Quotient<CGAL::MP_Float> NT1;
//typedef CGAL::Lazy_exact_nt<CGAL::Quotient<CGAL::MP_Float> > NT1;
typedef CGAL::Cartesian<NT1> Linear_k1; typedef CGAL::Cartesian<NT1> Linear_k1;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT1> Algebraic_k1; typedef CGAL::Algebraic_kernel_for_circles_2_2<NT1> Algebraic_k1;
typedef CGAL::Circular_kernel_2<Linear_k1, Algebraic_k1> CircularKernel; typedef CGAL::Circular_kernel_2<Linear_k1, Algebraic_k1> CircularKernel;
@ -240,208 +174,6 @@ Bench bench(Htmlfilename,Texfilename,Dxffilename[i]);
bench.Compute<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]); bench.Compute<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]);
// bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]); // bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]);
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Quotient<CGAL::MP_Float> NT2;
// typedef CGAL::Lazy_exact_nt<CGAL::Quotient<CGAL::MP_Float> > NT2;
typedef CGAL::Cartesian<NT2> Linear_k2;
typedef CGAL::Algebraic_kernel_2_2<NT2> Algebraic_k2;
typedef CGAL::Curved_kernel<Linear_k2, Algebraic_k2> CK2_;
//typedef CGAL::Interval_nt<> NT2;
typedef CGAL::Interval_nt_advanced NT3;
typedef CGAL::Cartesian<NT3> Linear_k3;
typedef CGAL::Algebraic_kernel_2_2<NT3> Algebraic_k3;
typedef CGAL::Curved_kernel<Linear_k3,Algebraic_k3> CK3_;
typedef CGAL::Lazy_curved_kernel<CK2_,CK3_> LazyCurvedK;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<LazyCurvedK> LazyCurvedK_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<LazyCurved_k> Traits0_2;
typedef CGAL::Circular_arc_traits_tracer<Traits0_2> LazyCurved_kTraits;
#endif
typedef LazyCurvedK::Circular_arc_2 LazyArc;
typedef std::vector<LazyArc> LazyArcContainer;
bench.kernel("Lazy curved kernel Circular arc traits") ;
bench.Compute_no_dxf<LazyCurvedK,LazyCurvedK_CA_Traits,LazyArcContainer>();
typedef LazyCurvedK::Circular_arc_2 Circular_arc_3;
typedef LazyCurvedK::Line_arc_2 Line_arc_3;
typedef boost::variant<Circular_arc_3,Line_arc_3 > LazyVarArc;
typedef std::vector<LazyVarArc> LazyVarContainer;
typedef CGAL::Variant_traits<LazyCurvedK,Line_arc_3,Circular_arc_3> LazyCurvedK_Variant_Traits;
bench.kernel("Lazy curved kernel Variant traits");
bench.Compute<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
//bench.Compute_dxf<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_hexagon_curved_kernel<CircularKernel> CircularKernelHexagon;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<CircularKernelHexagon> CircularKernHex_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<CircularKernelHexagon> Traits0_3;
typedef CGAL::Circular_arc_traits_tracer<Traits0_3> CircularKernHex_CA_Traits;
#endif
typedef CircularKernelHexagon::Circular_arc_2 CircularKernHexArc;
typedef std::vector<CircularKernHexArc> CircularKernHexArcContainer;
bench.kernel("Circular kernel filtered hexagon Circular arc traits");
bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_CA_Traits,CircularKernHexArcContainer>();
typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4;
typedef CircularKernelHexagon::Line_arc_2 Line_arc_4;
typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc;
typedef std::vector<CircularKernHexVarArc> CircularKernHexVarArcContainer;
typedef CGAL::Variant_traits<CircularKernelHexagon,Circular_arc_4,Line_arc_4> CircularKernHex_Variant_Traits;
bench.kernel("Circular kernel filtered hexagon Variants traits");
//bench.Compute<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>(Dxffilename[i]);
bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>();
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_hexagon_curved_kernel<LazyCurvedK> LazyKernelHexagon;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<LazyKernelHexagon> LazyKernelHexagon_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<LazyKernelHexagon> Traits0_4;
typedef CGAL::Circular_arc_traits_tracer<Traits0_4> LazyKernelHexagon_CA_Traits;
#endif
typedef LazyKernelHexagon::Circular_arc_2 LazyKernelHexagonArc;
typedef std::vector<LazyKernelHexagonArc> LazyKernelHexagonArcContainer;
bench.kernel("Lazy curved kernel filtered hexagon Circular arc traits");
bench.Compute_no_dxf<LazyKernelHexagon,LazyKernelHexagon_CA_Traits, LazyKernelHexagonArcContainer>();
typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5;
typedef LazyKernelHexagon::Line_arc_2 Line_arc_5;
typedef boost::variant<Circular_arc_5,Line_arc_5 > HxLazyVarArc;
typedef std::vector<HxLazyVarArc> HxLazyVarContainer;
typedef CGAL::Variant_traits<LazyKernelHexagon,Line_arc_5,Circular_arc_5> HxLazyVariantTraits;
bench.kernel("Lazy curved kernel filtered hexagon Variants traits") ;
//bench.Compute<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>();
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<CircularKernel> BBCircularKernel ;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBCircularKernel> BBCircularKernel_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<BBCircularKernel> Traits0_5;
typedef CGAL::Circular_arc_traits_tracer<Traits0_5> BBCircularKernel_CA_Traits;
#endif
typedef BBCircularKernel::Circular_arc_2 BBCircularKernelArc;
typedef std::vector<BBCircularKernelArc> BBCircularKernelArcContainer;
bench.kernel("Circular kernel filtered bbox Circular arc traits");
bench.Compute_no_dxf<BBCircularKernel,BBCircularKernel_CA_Traits, BBCircularKernelArcContainer>();
typedef BBCircularKernel::Circular_arc_2 Circular_arc_6;
typedef BBCircularKernel::Line_arc_2 Line_arc_6;
typedef boost::variant<Circular_arc_6,Line_arc_6 > BBCircVarArc;
typedef std::vector<BBCircVarArc> BBCircVarContainer;
typedef CGAL::Variant_traits<BBCircularKernel,Line_arc_6,Circular_arc_6> BBCircVariantTraits;
bench.kernel("Circular kernel filtered bbox Variants traits") ;
// bench.Compute<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>();
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<LazyCurvedK> BBLazyCurvedK;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBLazyCurvedK> BBLazyCurvedK_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<BBLazyCurvedK> Traits0_6;
typedef CGAL::Circular_arc_traits_tracer<Traits0_6> BBLazyCurvedK_CA_Traits;
#endif
typedef BBLazyCurvedK::Circular_arc_2 BBLazyCurvedKArc;
typedef std::vector<BBLazyCurvedKArc> BBLazyCurvedKArcContainer;
bench.kernel("Lazy curved kernel filtered bbox Circular arc traits");
bench.Compute_no_dxf<BBLazyCurvedK,BBLazyCurvedK_CA_Traits,BBLazyCurvedKArcContainer>();
typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7;
typedef BBLazyCurvedK::Line_arc_2 Line_arc_7;
typedef boost::variant<Circular_arc_7,Line_arc_7 > BBLazyVarArc;
typedef std::vector< BBLazyVarArc> BBLazyVarContainer;
typedef CGAL::Variant_traits<BBLazyCurvedK,Line_arc_7,Circular_arc_7> BBLazyVariantTraits;
bench.kernel("Lazy curved kernel filtered bbox Variants traits") ;
//bench.Compute<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>();
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<CircularKernelHexagon> BBCircKHexagon ;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBCircKHexagon> BBCircKHexagonCATraits;
#else
typedef CGAL::Circular_arc_traits<BBCircKHexagon> Traits0_7;
typedef CGAL::Circular_arc_traits_tracer<Traits0_7> BBCircKHexagonCATraits;
#endif
typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc;
typedef std::vector<BBCircKHexagon> BBCircKHexagonArcCont;
bench.kernel("BBox Circular kernel filtered bbox Circular arc traits");
bench.Compute_no_dxf<BBCircKHexagon,BBCircKHexagonCATraits, BBCircKHexagonArcCont>();
typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8;
typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8;
typedef boost::variant<Circular_arc_8,Line_arc_8 > BBCircularKernelHexagonVarArc;
typedef std::vector<BBCircularKernelHexagonVarArc> BBCircularKernelHexagonVarContainer;
typedef CGAL::Variant_traits<BBCircularKernelHexagon,Line_arc_8,Circular_arc_8> BBCircularKernelHexagonVariantTraits;
bench.kernel("BBox Circular kernel filtered bbox Variants traits") ;
//bench.Compute<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBCircularKernelHexagon,BBCircularKernelHexagonVariantTraits,BBCircularKernelHexagonVarContainer>();*/
/*--------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------*/
if (i+1<15) if (i+1<15)
{ {
if (strcmp(Dxffilename[i+1],"")) if (strcmp(Dxffilename[i+1],""))
@ -460,4 +192,3 @@ bench.infotable();
return 0; return 0;
} }

40
Circular_kernel_2/benchmark/benchmark_CK2.cpp
View File

@ -11,7 +11,6 @@
#include <CGAL/intersections.h> #include <CGAL/intersections.h>
#include <CGAL/Circular_kernel_2.h> #include <CGAL/Circular_kernel_2.h>
#include <CGAL/Arr_circular_arc_traits_2.h> #include <CGAL/Arr_circular_arc_traits_2.h>
#include <CGAL/Lazy_circular_kernel_2.h>
#include <CGAL/Filtered_bbox_circular_kernel_2.h> #include <CGAL/Filtered_bbox_circular_kernel_2.h>
#include <CGAL/Arrangement_2.h> #include <CGAL/Arrangement_2.h>
#include <CGAL/Arr_naive_point_location.h> #include <CGAL/Arr_naive_point_location.h>
@ -42,21 +41,6 @@ typedef CGAL::Arr_circular_line_arc_traits_2<CircularKernel> CircularK_Variant
typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc;
typedef std::vector<CircularKVarArc> CircularKVarArcContainer; typedef std::vector<CircularKVarArc> CircularKVarArcContainer;
// LAZY KERNEL TYPEDEFS
typedef CGAL::Interval_nt_advanced NT3;
typedef CGAL::Cartesian<NT3> Linear_k3;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT3> Algebraic_k3;
typedef CGAL::Circular_kernel_2 <Linear_k3,Algebraic_k3> CK3_;
typedef CGAL::Lazy_circular_kernel_2<CircularKernel,CK3_> LazyCurvedK;
typedef CGAL::Arr_circular_arc_traits_2<LazyCurvedK> LazyCurvedK_CA_Traits;
typedef LazyCurvedK::Circular_arc_2 LazyArc;
typedef std::vector<LazyArc> LazyArcContainer;
typedef LazyCurvedK::Circular_arc_2 Circular_arc_3;
typedef LazyCurvedK::Line_arc_2 Line_arc_3;
typedef boost::variant<Circular_arc_3,Line_arc_3 > LazyVarArc;
typedef std::vector<LazyVarArc> LazyVarContainer;
//~ typedef CGAL::Arr_circular_line_arc_traits_2<LazyCurvedK,Line_arc_3,Circular_arc_3> LazyCurvedK_Variant_Traits;
typedef CGAL::Arr_circular_line_arc_traits_2<LazyCurvedK> LazyCurvedK_Variant_Traits;
// BBOX TYPEDEFS // BBOX TYPEDEFS
typedef CGAL::Filtered_bbox_circular_kernel_2<CircularKernel> typedef CGAL::Filtered_bbox_circular_kernel_2<CircularKernel>
@ -77,24 +61,6 @@ typedef std::vector<BBCircVarArc>
BBCircVarContainer; BBCircVarContainer;
typedef CGAL::Arr_circular_line_arc_traits_2<BBCircularKernel> BBCircVariantTraits; typedef CGAL::Arr_circular_line_arc_traits_2<BBCircularKernel> BBCircVariantTraits;
// BBOX(LAZY)
typedef CGAL::Filtered_bbox_circular_kernel_2<LazyCurvedK>
BBLazyKernel ;
typedef CGAL::Arr_circular_arc_traits_2<BBLazyKernel>
BBLazyKernel_CA_Traits;
typedef BBLazyKernel::Circular_arc_2
BBLazyKernelArc;
typedef std::vector<BBLazyKernelArc>
BBLazyKernelArcContainer;
typedef BBLazyKernel::Circular_arc_2
Circular_arc_lazybb;
typedef BBLazyKernel::Line_arc_2
Line_arc_lazybb;
typedef boost::variant<Circular_arc_lazybb,Line_arc_lazybb >
BBLazyVarArc;
typedef std::vector<BBLazyVarArc>
BBLazyVarContainer;
typedef CGAL::Arr_circular_line_arc_traits_2<BBLazyKernel> BBLazyVariantTraits;
template <class CK,class Traits,class ArcContainer> template <class CK,class Traits,class ArcContainer>
void do_main(const char *s) { void do_main(const char *s) {
@ -243,9 +209,7 @@ int main(int argc, char* argv[]){
int j = argv[2][0]-'0'; int j = argv[2][0]-'0';
if((j >= 0 && j < 9)) { if((j >= 0 && j < 9)) {
if(i == 1) do_main<BBCircularKernel,BBCircVariantTraits, BBCircVarContainer>(dxf_filename[j]); if(i == 1) do_main<BBCircularKernel,BBCircVariantTraits, BBCircVarContainer>(dxf_filename[j]);
if(i == 2) do_main<LazyCurvedK,LazyCurvedK_Variant_Traits, LazyVarContainer>(dxf_filename[j]);
if(i == 3) do_main<CircularKernel,CircularK_Variant_Traits, CircularKVarArcContainer>(dxf_filename[j]); if(i == 3) do_main<CircularKernel,CircularK_Variant_Traits, CircularKVarArcContainer>(dxf_filename[j]);
if(i == 4) do_main<BBLazyKernel,BBLazyVariantTraits, BBLazyVarContainer>(dxf_filename[j]);
if((i >= 5) || (i <= 0)) std::cout << "INVALID PARAMETERS" << std::endl; if((i >= 5) || (i <= 0)) std::cout << "INVALID PARAMETERS" << std::endl;
} else { } else {
int k = -1; int k = -1;
@ -255,13 +219,9 @@ int main(int argc, char* argv[]){
if(j == ('c'-'0')) k = 3; if(j == ('c'-'0')) k = 3;
if(j == ('d'-'0')) k = 4; if(j == ('d'-'0')) k = 4;
if(i == 1) do_main<BBCircularKernel,BBCircVariantTraits, BBCircVarContainer>(k); if(i == 1) do_main<BBCircularKernel,BBCircVariantTraits, BBCircVarContainer>(k);
if(i == 2) do_main<LazyCurvedK,LazyCurvedK_Variant_Traits, LazyVarContainer>(k);
if(i == 3) do_main<CircularKernel,CircularK_Variant_Traits, CircularKVarArcContainer>(k); if(i == 3) do_main<CircularKernel,CircularK_Variant_Traits, CircularKVarArcContainer>(k);
if(i == 4) do_main<BBLazyKernel,BBLazyVariantTraits, BBLazyVarContainer>(k);
if(i == 5) do_main<BBCircularKernel,BBCircularKernel_CA_Traits, BBCircularKernelArcContainer>(k); if(i == 5) do_main<BBCircularKernel,BBCircularKernel_CA_Traits, BBCircularKernelArcContainer>(k);
if(i == 6) do_main<LazyCurvedK,LazyCurvedK_CA_Traits, LazyArcContainer>(k);
if(i == 7) do_main<CircularKernel,CircularK_CA_Traits, CircularKArcContainer>(k); if(i == 7) do_main<CircularKernel,CircularK_CA_Traits, CircularKArcContainer>(k);
if(i == 8) do_main<BBLazyKernel,BBLazyKernel_CA_Traits, BBLazyKernelArcContainer>(k);
} }
} else std::cout << "INVALID PARAMETERS" << std::endl; } else std::cout << "INVALID PARAMETERS" << std::endl;

225
Circular_kernel_2/benchmark/benchmarks_arrangement.cpp
View File

@ -1,18 +1,13 @@
#define CGAL_CAST_INT #define CGAL_CAST_INT
#define CIRCULAR_KERNEL_2 #define CIRCULAR_KERNEL_2
#define LAZY_CURVED_KERNEL_2
#define CIRCULAR_KERNEL_2_FILTERED_HEXAGON #define CIRCULAR_KERNEL_2_FILTERED_HEXAGON
#define LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON
#define CIRCULAR_KERNEL_2_FILTERED_BBOX #define CIRCULAR_KERNEL_2_FILTERED_BBOX
#define LAZY_CURVED_KERNEL_2_FILTERED_BBOX
#include <CGAL/Cartesian.h> #include <CGAL/Cartesian.h>
#include <CGAL/Handle_for.h> #include <CGAL/Handle_for.h>
#include <CGAL/point_generators_2.h> #include <CGAL/point_generators_2.h>
#include <CGAL/MP_Float.h>
#include <CGAL/Algebraic_kernel_for_circles_2_2.h> #include <CGAL/Algebraic_kernel_for_circles_2_2.h>
#include <CGAL/intersections.h> #include <CGAL/intersections.h>
@ -21,11 +16,6 @@
#include <CGAL/Arr_circular_arc_traits_2.h> #include <CGAL/Arr_circular_arc_traits_2.h>
//#include <CGAL/Circular_arc_traits_tracer.h> //#include <CGAL/Circular_arc_traits_tracer.h>
#include <CGAL/Lazy_circular_kernel_2.h>
#ifdef CIRCULAR_KERNEL_2_FILTERED_HEXAGON
#include <CGAL/Filtered_hexagon_circular_kernel_2.h>
#endif
#include <CGAL/Filtered_bbox_circular_kernel_2.h> #include <CGAL/Filtered_bbox_circular_kernel_2.h>
@ -184,123 +174,7 @@ Bench bench; //If you want create table with all datasets
bench.Compute_no_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(); bench.Compute_no_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>();
#endif #endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef LAZY_CURVED_KERNEL_2
typedef CGAL::Quotient<CGAL::MP_Float> NT2;
typedef CGAL::Cartesian<NT2> Linear_k2;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT2> Algebraic_k2;
typedef CGAL::Circular_kernel_2 <Linear_k2, Algebraic_k2> CK2_;
typedef CGAL::Interval_nt_advanced NT3;
typedef CGAL::Cartesian<NT3> Linear_k3;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT3> Algebraic_k3;
typedef CGAL::Circular_kernel_2 <Linear_k3,Algebraic_k3> CK3_;
typedef CGAL::Lazy_circular_kernel_2<CK2_,CK3_> LazyCurvedK;
// #ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Arr_circular_arc_traits_2<LazyCurvedK> LazyCurvedK_CA_Traits;
// #else
// typedef CGAL::Circular_arc_traits<LazyCurved_k> Traits0_2;
// typedef CGAL::Circular_arc_traits_tracer<Traits0_2> LazyCurved_kTraits;
// #endif
typedef LazyCurvedK::Circular_arc_2 LazyArc;
typedef std::vector<LazyArc> LazyArcContainer;
bench.kernel("LazyCircArc") ;
bench.Compute_no_dxf<LazyCurvedK,LazyCurvedK_CA_Traits,LazyArcContainer>();
typedef LazyCurvedK::Circular_arc_2 Circular_arc_3;
typedef LazyCurvedK::Line_arc_2 Line_arc_3;
typedef boost::variant<Circular_arc_3,Line_arc_3 > LazyVarArc;
typedef std::vector<LazyVarArc> LazyVarContainer;
typedef CGAL::Arr_circular_line_arc_traits_2<LazyCurvedK> LazyCurvedK_Variant_Traits;
bench.kernel("LazyKVar");
//bench.Compute<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
//bench.Compute_dxf<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>();
#endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef CIRCULAR_KERNEL_2_FILTERED_HEXAGON
typedef CGAL::Filtered_hexagon_circular_kernel_2<CircularKernel> CircularKernelHexagon;
// #ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Arr_circular_arc_traits_2<CircularKernelHexagon> CircularKernHex_CA_Traits;
// #else
// typedef CGAL::Circular_arc_traits<CircularKernelHexagon> Traits0_3;
// typedef CGAL::Circular_arc_traits_tracer<Traits0_3> CircularKernHex_CA_Traits;
// #endif
typedef CircularKernelHexagon::Circular_arc_2 CircularKernHexArc;
typedef std::vector<CircularKernHexArc> CircularKernHexArcContainer;
bench.kernel("CK Hex CircArcTraits");
bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_CA_Traits,CircularKernHexArcContainer>();
typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4;
typedef CircularKernelHexagon::Line_arc_2 Line_arc_4;
typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc;
typedef std::vector<CircularKernHexVarArc> CircularKernHexVarArcContainer;
typedef CGAL::Arr_circular_line_arc_traits_2<CircularKernelHexagon> CircularKernHex_Variant_Traits;
bench.kernel("CK Hex VarTraits");
// bench.Compute<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>(Dxffilename[i]);
bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>();
#endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON
typedef CGAL::Filtered_hexagon_circular_kernel_2<LazyCurvedK> LazyKernelHexagon;
// #ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Arr_circular_arc_traits_2<LazyKernelHexagon> LazyKernelHexagon_CA_Traits;
// #else
// typedef CGAL::Circular_arc_traits<LazyKernelHexagon> Traits0_4;
// typedef CGAL::Circular_arc_traits_tracer<Traits0_4> LazyKernelHexagon_CA_Traits;
// #endif
typedef LazyKernelHexagon::Circular_arc_2 LazyKernelHexagonArc;
typedef std::vector<LazyKernelHexagonArc> LazyKernelHexagonArcContainer;
bench.kernel("LazyK Hex CircArcTraits");
bench.Compute_no_dxf<LazyKernelHexagon,LazyKernelHexagon_CA_Traits, LazyKernelHexagonArcContainer>();
typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5;
typedef LazyKernelHexagon::Line_arc_2 Line_arc_5;
typedef boost::variant<Circular_arc_5,Line_arc_5 > HxLazyVarArc;
typedef std::vector<HxLazyVarArc> HxLazyVarContainer;
typedef CGAL::Arr_circular_line_arc_traits_2<LazyKernelHexagon> HxLazyVariantTraits;
bench.kernel("LazyK Hex VarTraits") ;
//bench.Compute<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>();
#endif
/*------------------------------------------------------------------------------------------------------------------------- /*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!! !!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!!
@ -333,105 +207,6 @@ bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>()
bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(); bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>();
#endif #endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
#ifdef LAZY_CURVED_KERNEL_2_FILTERED_BBOX
typedef CGAL::Filtered_bbox_circular_kernel_2<LazyCurvedK> BBLazyCurvedK;
// #ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Arr_circular_arc_traits_2<BBLazyCurvedK> BBLazyCurvedK_CA_Traits;
// #else
// typedef CGAL::Circular_arc_traits<BBLazyCurvedK> Traits0_6;
// typedef CGAL::Circular_arc_traits_tracer<Traits0_6> BBLazyCurvedK_CA_Traits;
// #endif
typedef BBLazyCurvedK::Circular_arc_2 BBLazyCurvedKArc;
typedef std::vector<BBLazyCurvedKArc> BBLazyCurvedKArcContainer;
bench.kernel("LLazyK BBox CircArcTraits");
bench.Compute_no_dxf<BBLazyCurvedK,BBLazyCurvedK_CA_Traits,BBLazyCurvedKArcContainer>();
typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7;
typedef BBLazyCurvedK::Line_arc_2 Line_arc_7;
typedef boost::variant<Circular_arc_7,Line_arc_7 > BBLazyVarArc;
typedef std::vector< BBLazyVarArc> BBLazyVarContainer;
typedef CGAL::Arr_circular_line_arc_traits_2<BBLazyCurvedK> BBLazyVariantTraits;
bench.kernel("LLazyK BBox VarTraits") ;
//bench.Compute<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>();
#endif
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<CircularKernelHexagon> BBCircKHexagon ;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBCircKHexagon> BBCircKHexagonCATraits;
#else
typedef CGAL::Circular_arc_traits<BBCircKHexagon> Traits0_7;
typedef CGAL::Circular_arc_traits_tracer<Traits0_7> BBCircKHexagonCATraits;
#endif
typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc;
typedef std::vector<BBCircKHexagon> BBCircKHexagonArcCont;
bench.kernel("BBox Circular kernel filtered Hexagon CircArcTraits");
bench.Compute_no_dxf<BBCircKHexagon,BBCircKHexagonCATraits, BBCircKHexagonArcCont>();
typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8;
typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8;
typedef boost::variant<Circular_arc_8,Line_arc_8 > BBCircularKernelHexagonVarArc;
typedef std::vector<BBCircularKernelHexagonVarArc> BBCircularKernelHexagonVarContainer;
typedef CGAL::Variant_traits<BBCircularKernelHexagon,Line_arc_8,Circular_arc_8> BBCircularKernelHexagonVariantTraits;
bench.kernel("BBox Circular kernel filtered Hexagon VarTraits") ;
//bench.Compute<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBCircularKernelHexagon,BBCircularKernelHexagonVariantTraits,BBCircularKernelHexagonVarContainer>();*/
/*--------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------*/
// if (i+1<2)
// {
// try{
// if (strcmp(Dxffilename[i+1],""))
// {
// try{
// fin.open (Dxffilename[i]);
// }
// catch(...){
// std::cout<<"error"<<std::endl;
// }
// if (!fin.is_open())
// {
// std::cout<<"file "<< Dxffilename[i] << " is not found"<<std::endl;
// std::cout << "that's all" << std::endl;
// fin.close();
// break;
// }
// else
// {
// bench.newDxfFilename(Dxffilename[i+1]);
// }
// fin.close();
// }
// else
// {
// std::cout << "that's all" << std::endl;
// break;
// }
// }
// catch(...){std::cout << "error" << std::endl;}
// }
// }
return 0; return 0;
} }

5
Circular_kernel_2/benchmark/bff_reader/Breader.cpp
View File

@ -14,10 +14,6 @@
#include <CGAL/Circular_arc_traits.h> #include <CGAL/Circular_arc_traits.h>
#include <CGAL/Circular_arc_traits_tracer.h> #include <CGAL/Circular_arc_traits_tracer.h>
#include <CGAL/Lazy_circular_kernel_2.h>
#include <CGAL/Filtered_hexagon_circular_kernel_2.h>
#include <CGAL/Filtered_bbox_circular_kernel_2.h> #include <CGAL/Filtered_bbox_circular_kernel_2.h>
#include <CGAL/Arrangement_2.h> #include <CGAL/Arrangement_2.h>
@ -225,4 +221,3 @@ int exit_status = 0;
return exit_status; return exit_status;
} }

205
Circular_kernel_2/benchmark/incremental_insertion/benchmarks_arrangement.cpp
View File

@ -13,10 +13,6 @@
#include <CGAL/Circular_arc_traits.h> #include <CGAL/Circular_arc_traits.h>
#include <CGAL/Circular_arc_traits_tracer.h> #include <CGAL/Circular_arc_traits_tracer.h>
#include <CGAL/Lazy_circular_kernel_2.h>
#include <CGAL/Filtered_hexagon_circular_kernel_2.h>
#include <CGAL/Filtered_bbox_circular_kernel_2.h> #include <CGAL/Filtered_bbox_circular_kernel_2.h>
#include <CGAL/Arrangement_2.h> #include <CGAL/Arrangement_2.h>
@ -169,207 +165,7 @@ Bench bench(Htmlfilename,Texfilename,Dxffilename[i],true);
// bench.Compute<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]); // bench.Compute<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]);
bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]); bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]);
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
typedef CGAL::Quotient<CGAL::MP_Float> NT2;
typedef CGAL::Cartesian<NT2> Linear_k2;
typedef CGAL::Algebraic_kernel_for_circles_2_2<NT2> Algebraic_k2;
typedef CGAL::Circular_kernel_2<Linear_k2, Algebraic_k2> CK2_;
//typedef CGAL::Interval_nt<> NT2;
typedef CGAL::Interval_nt_advanced NT3;
typedef CGAL::Cartesian<NT3> Linear_k3;
typedef CGAL::Algebraic_kernel_2_2<NT3> Algebraic_k3;
typedef CGAL::Curved_kernel<Linear_k3,Algebraic_k3> CK3_;
typedef CGAL::Lazy_circular_kernel_2<CK2_,CK3_> LazyCurvedK;
// #ifndef CGAL_CURVED_KERNEL_DEBUG
// typedef CGAL::Circular_arc_traits<LazyCurvedK> LazyCurvedK_CA_Traits;
// #else
// typedef CGAL::Circular_arc_traits<LazyCurved_k> Traits0_2;
// typedef CGAL::Circular_arc_traits_tracer<Traits0_2> LazyCurved_kTraits;
// #endif
//
// typedef LazyCurvedK::Circular_arc_2 LazyArc;
// typedef std::vector<LazyArc> LazyArcContainer;
//
// bench.kernel("Lazy curved kernel Circular arc traits") ;
//
// bench.Compute_no_dxf<LazyCurvedK,LazyCurvedK_CA_Traits,LazyArcContainer>();
typedef LazyCurvedK::Circular_arc_2 Circular_arc_3;
typedef LazyCurvedK::Line_arc_2 Line_arc_3;
typedef boost::variant<Circular_arc_3,Line_arc_3 > LazyVarArc;
typedef std::vector<LazyVarArc> LazyVarContainer;
typedef CGAL::Variant_traits<LazyCurvedK,Line_arc_3,Circular_arc_3> LazyCurvedK_Variant_Traits;
bench.kernel("Lazy curved kernel Variant traits");
// bench.Compute<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
// bench.Compute_dxf<LazyCurvedK,LazyCurvedK_Variant_Traits,LazyVarContainer>(Dxffilename[i]);
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
asdashhhhhhhhhhhhfhjhdghdf
typedef CGAL::Filtered_hexagon_curved_kernel<CircularKernel> CircularKernelHexagon;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<CircularKernelHexagon> CircularKernHex_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<CircularKernelHexagon> Traits0_3;
typedef CGAL::Circular_arc_traits_tracer<Traits0_3> CircularKernHex_CA_Traits;
#endif
typedef CircularKernelHexagon::Circular_arc_2 CircularKernHexArc;
typedef std::vector<CircularKernHexArc> CircularKernHexArcContainer;
bench.kernel("Circular kernel filtered hexagon Circular arc traits");
bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_CA_Traits,CircularKernHexArcContainer>();
typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4;
typedef CircularKernelHexagon::Line_arc_2 Line_arc_4;
typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc;
typedef std::vector<CircularKernHexVarArc> CircularKernHexVarArcContainer;
typedef CGAL::Variant_traits<CircularKernelHexagon,Circular_arc_4,Line_arc_4> CircularKernHex_Variant_Traits;
bench.kernel("Circular kernel filtered hexagon Variants traits");
bench.Compute<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>(Dxffilename[i]);
// bench.Compute_no_dxf<CircularKernelHexagon,CircularKernHex_Variant_Traits,CircularKernHexVarArcContainer>();
*/
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_hexagon_curved_kernel<LazyCurvedK> LazyKernelHexagon;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<LazyKernelHexagon> LazyKernelHexagon_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<LazyKernelHexagon> Traits0_4;
typedef CGAL::Circular_arc_traits_tracer<Traits0_4> LazyKernelHexagon_CA_Traits;
#endif
typedef LazyKernelHexagon::Circular_arc_2 LazyKernelHexagonArc;
typedef std::vector<LazyKernelHexagonArc> LazyKernelHexagonArcContainer;
bench.kernel("Lazy curved kernel filtered hexagon Circular arc traits");
bench.Compute_no_dxf<LazyKernelHexagon,LazyKernelHexagon_CA_Traits, LazyKernelHexagonArcContainer>();
typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5;
typedef LazyKernelHexagon::Line_arc_2 Line_arc_5;
typedef boost::variant<Circular_arc_5,Line_arc_5 > HxLazyVarArc;
typedef std::vector<HxLazyVarArc> HxLazyVarContainer;
typedef CGAL::Variant_traits<LazyKernelHexagon,Line_arc_5,Circular_arc_5> HxLazyVariantTraits;
bench.kernel("Lazy curved kernel filtered hexagon Variants traits") ;
bench.Compute<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>(Dxffilename[i]);
//bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>();
*/
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<CircularKernel> BBCircularKernel ;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBCircularKernel> BBCircularKernel_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<BBCircularKernel> Traits0_5;
typedef CGAL::Circular_arc_traits_tracer<Traits0_5> BBCircularKernel_CA_Traits;
#endif
typedef BBCircularKernel::Circular_arc_2 BBCircularKernelArc;
typedef std::vector<BBCircularKernelArc> BBCircularKernelArcContainer;
bench.kernel("Circular kernel filtered bbox Circular arc traits");
bench.Compute_no_dxf<BBCircularKernel,BBCircularKernel_CA_Traits, BBCircularKernelArcContainer>();
typedef BBCircularKernel::Circular_arc_2 Circular_arc_6;
typedef BBCircularKernel::Line_arc_2 Line_arc_6;
typedef boost::variant<Circular_arc_6,Line_arc_6 > BBCircVarArc;
typedef std::vector<BBCircVarArc> BBCircVarContainer;
typedef CGAL::Variant_traits<BBCircularKernel,Line_arc_6,Circular_arc_6> BBCircVariantTraits;
bench.kernel("Circular kernel filtered bbox Variants traits") ;
bench.Compute<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(Dxffilename[i]);
// bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>();
*/
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<LazyCurvedK> BBLazyCurvedK;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBLazyCurvedK> BBLazyCurvedK_CA_Traits;
#else
typedef CGAL::Circular_arc_traits<BBLazyCurvedK> Traits0_6;
typedef CGAL::Circular_arc_traits_tracer<Traits0_6> BBLazyCurvedK_CA_Traits;
#endif
typedef BBLazyCurvedK::Circular_arc_2 BBLazyCurvedKArc;
typedef std::vector<BBLazyCurvedKArc> BBLazyCurvedKArcContainer;
bench.kernel("Lazy curved kernel filtered bbox Circular arc traits");
bench.Compute_no_dxf<BBLazyCurvedK,BBLazyCurvedK_CA_Traits,BBLazyCurvedKArcContainer>();
typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7;
typedef BBLazyCurvedK::Line_arc_2 Line_arc_7;
typedef boost::variant<Circular_arc_7,Line_arc_7 > BBLazyVarArc;
typedef std::vector< BBLazyVarArc> BBLazyVarContainer;
typedef CGAL::Variant_traits<BBLazyCurvedK,Line_arc_7,Circular_arc_7> BBLazyVariantTraits;
bench.kernel("Lazy curved kernel filtered bbox Variants traits") ;
bench.Compute<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>(Dxffilename[i]);
//bench.Compute_no_dxf<BBLazyCurvedK, BBLazyVariantTraits, BBLazyVarContainer>();
*/
/*-------------------------------------------------------------------------------------------------------------------------
!!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
/*
typedef CGAL::Filtered_bbox_curved_kernel<CircularKernelHexagon> BBCircKHexagon ;
#ifndef CGAL_CURVED_KERNEL_DEBUG
typedef CGAL::Circular_arc_traits<BBCircKHexagon> BBCircKHexagonCATraits;
#else
typedef CGAL::Circular_arc_traits<BBCircKHexagon> Traits0_7;
typedef CGAL::Circular_arc_traits_tracer<Traits0_7> BBCircKHexagonCATraits;
#endif
typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc;
typedef std::vector<BBCircKHexagon> BBCircKHexagonArcCont;
bench.kernel("BBox Circular kernel filtered bbox Circular arc traits");
bench.Compute_no_dxf<BBCircKHexagon,BBCircKHexagonCATraits, BBCircKHexagonArcCont>();
typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8;
typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8;
typedef boost::variant<Circular_arc_8,Line_arc_8 > BBCircularKernelHexagonVarArc;
typedef std::vector<BBCircularKernelHexagonVarArc> BBCircularKernelHexagonVarContainer;
typedef CGAL::Variant_traits<BBCircularKernelHexagon,Line_arc_8,Circular_arc_8> BBCircularKernelHexagonVariantTraits;
bench.kernel("BBox Circular kernel filtered bbox Variants traits") ;
//bench.Compute<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>(Dxffilename[i]);
bench.Compute_no_dxf<BBCircularKernelHexagon,BBCircularKernelHexagonVariantTraits,BBCircularKernelHexagonVarContainer>();*/
/*--------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------*/
if (i+1<15) if (i+1<15)
{ {
if (strcmp(Dxffilename[i+1],"")) if (strcmp(Dxffilename[i+1],""))
@ -388,4 +184,3 @@ bench.infotable();
return 0; return 0;
} }

20
Circular_kernel_2/include/CGAL/Exact_circular_kernel_2.h
View File

@ -44,28 +44,20 @@ namespace CGAL {
namespace internal { namespace internal {
#ifdef CGAL_USE_GMP #ifdef CGAL_USE_GMP
typedef CGAL::Gmpq NT1; typedef CGAL::Gmpq NT;
#else #else
typedef Quotient<MP_Float> NT1; typedef Quotient<MP_Float> NT;
#endif #endif
typedef Cartesian<NT1> Linear_k1; typedef Cartesian<NT> Linear_k;
typedef Algebraic_kernel_for_circles_2_2<NT1> Algebraic_k1; typedef Algebraic_kernel_for_circles_2_2<NT> Algebraic_k;
typedef Circular_kernel_2<Linear_k1, Algebraic_k1> CK1; typedef Circular_kernel_2<Linear_k, Algebraic_k> CK;
// typedef CGAL::Interval_nt_advanced NT2;
// typedef CGAL::Cartesian<NT2> Linear_k2;
// typedef CGAL::Algebraic_kernel_for_circles_2_2<NT2> Algebraic_k2;
// typedef CGAL::Circular_kernel_2<Linear_k2,Algebraic_k2> CK2;
// typedef CGAL::Lazy_circular_kernel_2<CK1,CK2>
// Exact_circular_kernel_2;
} // namespace internal } // namespace internal
typedef Filtered_bbox_circular_kernel_2<internal::CK1> Exact_circular_kernel_2; typedef Filtered_bbox_circular_kernel_2<internal::CK> Exact_circular_kernel_2;
} //namespace CGAL } //namespace CGAL

1
Circular_kernel_2/test/Circular_kernel_2/CMakeLists.txt
View File

@ -16,7 +16,6 @@ include_directories(BEFORE ../../../Kernel_23/test/Kernel_23/include)
include_directories(BEFORE ../Kernel_23/include) include_directories(BEFORE ../Kernel_23/include)
create_single_source_cgal_program("test_Circular_kernel.cpp") create_single_source_cgal_program("test_Circular_kernel.cpp")
create_single_source_cgal_program("test_Lazy_circular_kernel.cpp")
create_single_source_cgal_program("test_Exact_circular_kernel.cpp") create_single_source_cgal_program("test_Exact_circular_kernel.cpp")
create_single_source_cgal_program("test_Filtered_bbox_circular_kernel.cpp") create_single_source_cgal_program("test_Filtered_bbox_circular_kernel.cpp")
create_single_source_cgal_program("test_Line_arc.cpp") create_single_source_cgal_program("test_Line_arc.cpp")

46
Circular_kernel_2/test/Circular_kernel_2/test_Lazy_circular_kernel.cpp
View File

@ -1,46 +0,0 @@
// Copyright (c) 2003-2008 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
// Author(s) : Monique Teillaud, Sylvain Pion, Pedro Machado
// Partially supported by the IST Programme of the EU as a Shared-cost
// RTD (FET Open) Project under Contract No IST-2000-26473
// (ECG - Effective Computational Geometry for Curves and Surfaces)
// and a STREP (FET Open) Project under Contract No IST-006413
// (ACS -- Algorithms for Complex Shapes)
#include <CGAL/internal/disable_deprecation_warnings_and_errors.h>
#include <CGAL/Exact_circular_kernel_2.h>
#include <CGAL/Circular_kernel_intersections.h>
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Algebraic_kernel_for_circles_2_2.h>
#include <CGAL/Circular_kernel_2.h>
typedef CGAL::Exact_predicates_exact_constructions_kernel Linear_k1;
typedef CGAL::Algebraic_kernel_for_circles_2_2<Linear_k1::FT> Algebraic_k1;
typedef CGAL::Circular_kernel_2<Linear_k1, Algebraic_k1> CK;
CK ck;
#include <CGAL/_test_circles_predicates.h>
#include <CGAL/_test_circles_constructions.h>
#include <CGAL/_test_circles_extention.h>
int main() {
_test_circle_predicat(ck);
_test_circle_construct(ck);
_test_circle_bbox(ck);
_test_circular_arc_bbox(ck);
_test_has_on(ck);
return 0;
}

0
Classification/package_info/Classification/copyright.txt → Classification/package_info/Classification/copyright
View File

0
Cone_spanners_2/package_info/Cone_spanners_2/copyright.txt → Cone_spanners_2/package_info/Cone_spanners_2/copyright
View File

1
Documentation/doc/Documentation/packages.txt
View File

@ -153,6 +153,7 @@
\package_listing{BGL} \package_listing{BGL}
\package_listing{Solver_interface} \package_listing{Solver_interface}
\package_listing{Property_map} \package_listing{Property_map}
\package_listing{Weights}
\package_listing{Cone_spanners_2} \package_listing{Cone_spanners_2}
\package_listing{Circulator} \package_listing{Circulator}
\package_listing{Generator} \package_listing{Generator}

2
Documentation/doc/scripts/compare_testsuites.sh
View File

@ -28,7 +28,7 @@ FAILURES=()
for dir in $PATH_TO_DOC/* for dir in $PATH_TO_DOC/*
do do
OUTPUT=$(basename $dir) OUTPUT=$(basename $dir)
python ../documentation_parser.py $dir/xml > ./"$OUTPUT.txt" python3 ../documentation_parser.py $dir/xml > ./"$OUTPUT.txt"
if [ $? -eq 0 ]; then if [ $? -eq 0 ]; then
echo "$dir OK" echo "$dir OK"
else else

38
Documentation/doc/scripts/documentation_parser.py
View File

@ -1,3 +1,5 @@
#/usr/bin/env python3
from pyquery import PyQuery as pq from pyquery import PyQuery as pq
from collections import defaultdict from collections import defaultdict
from sys import argv from sys import argv
@ -12,17 +14,17 @@ def check_type(_in, args):
root_path=argv[1] root_path=argv[1]
d = pq(filename=op.join(op.sep, root_path,'index.xml'), parser="xml") d = pq(filename=op.join(op.sep, root_path,'index.xml'), parser="xml")
compounds=[p.text() for p in d('compound').items()] compounds=[p.text() for p in list(d('compound').items())]
types=[p.attr('kind') for p in d('compound').items()] types=[p.attr('kind') for p in list(d('compound').items())]
type_map = defaultdict(list) #map <type, name> type_map = defaultdict(list) #map <type, name>
dict_map = defaultdict(dict)#map <name, map<member type, member name>> dict_map = defaultdict(dict)#map <name, map<member type, member name>>
#FOREACH compounds : fill maps #FOREACH compounds : fill maps
for i in xrange(0,len(compounds)): for i in range(0,len(compounds)):
if check_type(types[i], "typedef"): if check_type(types[i], "typedef"):
types[i]="type" types[i]="type"
name=d('compound').children("name").eq(i).text() name=d('compound').children("name").eq(i).text()
members=[p.text() for p in d('compound').eq(i).children("member").items()] members=[p.text() for p in list(d('compound').eq(i).children("member").items())]
m_types=[p.attr('kind') for p in d('compound').eq(i).children("member").items()] m_types=[p.attr('kind') for p in list(d('compound').eq(i).children("member").items())]
if (not check_type(types[i], ['example', 'file', 'dir', 'page', 'group']) and if (not check_type(types[i], ['example', 'file', 'dir', 'page', 'group']) and
not (types[i] == "namespace" and len(members) == 0) and not (types[i] == "namespace" and len(members) == 0) and
not (types[i] == "enum" and len(members) == 0) ): not (types[i] == "enum" and len(members) == 0) ):
@ -32,7 +34,7 @@ for i in xrange(0,len(compounds)):
total_path=op.join(op.sep, root_path,filepath) total_path=op.join(op.sep, root_path,filepath)
if(op.isfile(total_path)): if(op.isfile(total_path)):
e = pq(filename=total_path, parser="xml") e = pq(filename=total_path, parser="xml")
compoundnames=[p.text() for p in e('includes').items()] compoundnames=[p.text() for p in list(e('includes').items())]
if(len(compoundnames) > 1 and compoundnames[0].find("Concept") != -1): if(len(compoundnames) > 1 and compoundnames[0].find("Concept") != -1):
types[i] = 'Concept '+types[i].lower() types[i] = 'Concept '+types[i].lower()
@ -41,7 +43,7 @@ for i in xrange(0,len(compounds)):
mtype_map = defaultdict(list)# map<member type, member name> mtype_map = defaultdict(list)# map<member type, member name>
#FOREACH member : #FOREACH member :
for j in xrange(0,len(members)): for j in range(0,len(members)):
if(check_type(types[i], ['class', 'Concept class']) if(check_type(types[i], ['class', 'Concept class'])
and m_types[j] == "function"): and m_types[j] == "function"):
m_types[j]="method" m_types[j]="method"
@ -62,7 +64,7 @@ for btype in type_map:
out=btype out=btype
if btype.endswith('s'): if btype.endswith('s'):
out+='e' out+='e'
print out.title()+'s' print(out.title()+'s')
indent+=" " indent+=" "
#FOREACH name #FOREACH name
for name in type_map[btype]: for name in type_map[btype]:
@ -74,7 +76,7 @@ for btype in type_map:
templates=[] templates=[]
if op.isfile(op.join(op.sep, root_path,filepath)): if op.isfile(op.join(op.sep, root_path,filepath)):
f=pq(filename=op.join(op.sep, root_path,filepath), parser="xml") f=pq(filename=op.join(op.sep, root_path,filepath), parser="xml")
templateparams=f("compounddef").children("templateparamlist").eq(0).children("param").items() templateparams=list(f("compounddef").children("templateparamlist").eq(0).children("param").items())
for param in templateparams: for param in templateparams:
template_type="" template_type=""
template_name="" template_name=""
@ -91,7 +93,7 @@ for btype in type_map:
complete_template+=' = '+template_defval complete_template+=' = '+template_defval
templates.append(complete_template) templates.append(complete_template)
if templates==[]:#if no child was found, just take param.text() if templates==[]:#if no child was found, just take param.text()
templates=[t.text() for t in param.items()] templates=[t.text() for t in list(param.items())]
suffix="<" suffix="<"
#as template got type, defname and declname, name is twice in template. keep only one of them. #as template got type, defname and declname, name is twice in template. keep only one of them.
to_remove=[""] to_remove=[""]
@ -101,7 +103,7 @@ for btype in type_map:
suffix="" suffix=""
if suffix.endswith(', '): if suffix.endswith(', '):
suffix = suffix[:-2]+'>' suffix = suffix[:-2]+'>'
print indent+name+suffix print(indent+name+suffix)
indent+=" " indent+=" "
#FOREACH mtype #FOREACH mtype
@ -109,7 +111,7 @@ for btype in type_map:
out=mtype out=mtype
if mtype.endswith('s'): if mtype.endswith('s'):
out+='e' out+='e'
print indent+out.title()+'s' print(indent+out.title()+'s')
indent+=" " indent+=" "
#FOREACH member #FOREACH member
overload_map = defaultdict(int) #contains the number of times a member has appeared (to manage the overloads) overload_map = defaultdict(int) #contains the number of times a member has appeared (to manage the overloads)
@ -123,16 +125,16 @@ for btype in type_map:
if op.isfile(op.join(op.sep, root_path,filepath)): if op.isfile(op.join(op.sep, root_path,filepath)):
f=pq(filename=op.join(op.sep, root_path,filepath), parser="xml") f=pq(filename=op.join(op.sep, root_path,filepath), parser="xml")
index=0 index=0
memberdefs=[m.text() for m in f("memberdef").items()] memberdefs=[m.text() for m in list(f("memberdef").items())]
for i in xrange(0,len(memberdefs)): for i in range(0,len(memberdefs)):
member_names=[member_name.text() for member_name in f('memberdef').eq(i).children("name").items()] member_names=[member_name.text() for member_name in list(f('memberdef').eq(i).children("name").items())]
if f('memberdef').eq(i).children("name").text() == member: if f('memberdef').eq(i).children("name").text() == member:
if (index < overload_map[member]): if (index < overload_map[member]):
index+=1 index+=1
elif (index == overload_map[member]): elif (index == overload_map[member]):
if check_type(mtype, ['function', 'method']): if check_type(mtype, ['function', 'method']):
args=[f('memberdef').eq(i).children("argsstring").text()] args=[f('memberdef').eq(i).children("argsstring").text()]
templateparams=f('memberdef').eq(i).children("templateparamlist").children("param").items() templateparams=list(f('memberdef').eq(i).children("templateparamlist").children("param").items())
if check_type(mtype, ['function', 'method', 'type', 'variable']): if check_type(mtype, ['function', 'method', 'type', 'variable']):
return_type=[f('memberdef').eq(i).children("type").text()] return_type=[f('memberdef').eq(i).children("type").text()]
break; break;
@ -158,7 +160,7 @@ for btype in type_map:
complete_template+=' = '+template_defval complete_template+=' = '+template_defval
templates.append(complete_template) templates.append(complete_template)
if templates==[]:#if no child was found, just take param.text() if templates==[]:#if no child was found, just take param.text()
templates=[t.text() for t in param.items()] templates=[t.text() for t in list(param.items())]
prefix="template <" prefix="template <"
for template in templates: for template in templates:
@ -171,7 +173,7 @@ for btype in type_map:
prefix+=definition prefix+=definition
if(prefix != ""): if(prefix != ""):
prefix+=" " prefix+=" "
print indent+prefix+member+arguments print(indent+prefix+member+arguments)
overload_map[member]+=1 overload_map[member]+=1
#END foreach member #END foreach member
indent=indent[:-2] indent=indent[:-2]

2
Documentation/doc/scripts/testsuite.py
View File

@ -150,7 +150,7 @@ body {color: black; background-color: #C0C0D0; font-family: sans-serif;}
for index in range(0, len(results1)): for index in range(0, len(results1)):
result = [('./build_logs', './build_logs', (0,1))] result = [('./build_logs', './build_logs', (0,1))]
results_master.extend(result) results_master.extend(result)
for index in range(0, len(results1)-1): for index in range(0, len(results1)):
status='class="package-good"' status='class="package-good"'
no_errors = True no_errors = True
no_warn = True no_warn = True

0
Heat_method_3/package_info/Heat_method_3/copyright.txt → Heat_method_3/package_info/Heat_method_3/copyright
View File

52
Homogeneous_kernel/include/CGAL/Homogeneous/function_objects.h
View File

@ -810,6 +810,7 @@ namespace HomogeneousKernelFunctors {
template <typename K> template <typename K>
class Compare_slope_2 class Compare_slope_2
{ {
typedef typename K::Point_2 Point_2;
typedef typename K::Line_2 Line_2; typedef typename K::Line_2 Line_2;
typedef typename K::Segment_2 Segment_2; typedef typename K::Segment_2 Segment_2;
public: public:
@ -842,48 +843,55 @@ namespace HomogeneousKernelFunctors {
result_type result_type
operator()(const Segment_2& s1, const Segment_2& s2) const operator()(const Segment_2& s1, const Segment_2& s2) const
{
return (*this)(s1.source(), s1.target(),
s2.source(), s2.target());
}
result_type
operator()(const Point_2& s1s, const Point_2& s1t, const Point_2& s2s, const Point_2& s2t) const
{ {
typedef typename K::FT FT; typedef typename K::FT FT;
typename K::Comparison_result cmp_y1 = compare_y(s1.source(), s1.target()); typename K::Comparison_result cmp_y1 = compare_y(s1s, s1t);
if (cmp_y1 == EQUAL) // horizontal if (cmp_y1 == EQUAL) // horizontal
{ {
typename K::Comparison_result cmp_x2 = compare_x(s2.source(), s2.target()); typename K::Comparison_result cmp_x2 = compare_x(s2s, s2t);
if (cmp_x2 == EQUAL) return SMALLER; if (cmp_x2 == EQUAL) return SMALLER;
FT s_hw = s2.source().hw(); FT s_hw = s2s.hw();
FT t_hw = s2.target().hw(); FT t_hw = s2t.hw();
return - CGAL_NTS sign(s2.source().hy()*t_hw - s2.target().hy()*s_hw) * return - CGAL_NTS sign(s2s.hy()*t_hw - s2t.hy()*s_hw) *
CGAL_NTS sign(s2.source().hx()*t_hw - s2.target().hx()*s_hw); CGAL_NTS sign(s2s.hx()*t_hw - s2t.hx()*s_hw);
} }
typename K::Comparison_result cmp_y2 = compare_y(s2.source(), s2.target()); typename K::Comparison_result cmp_y2 = compare_y(s2s, s2t);
if (cmp_y2 == EQUAL) if (cmp_y2 == EQUAL)
{ {
typename K::Comparison_result cmp_x1 = compare_x(s1.source(), s1.target()); typename K::Comparison_result cmp_x1 = compare_x(s1s, s1t);
if (cmp_x1 == EQUAL) return LARGER; if (cmp_x1 == EQUAL) return LARGER;
FT s_hw = s1.source().hw(); FT s_hw = s1s.hw();
FT t_hw = s1.target().hw(); FT t_hw = s1t.hw();
return CGAL_NTS sign(s1.source().hy()*t_hw - s1.target().hy()*s_hw) * return CGAL_NTS sign(s1s.hy()*t_hw - s1t.hy()*s_hw) *
CGAL_NTS sign(s1.source().hx()*t_hw - s1.target().hx()*s_hw); CGAL_NTS sign(s1s.hx()*t_hw - s1t.hx()*s_hw);
} }
typename K::Comparison_result cmp_x1 = compare_x(s1.source(), s1.target()); typename K::Comparison_result cmp_x1 = compare_x(s1s, s1t);
typename K::Comparison_result cmp_x2 = compare_x(s2.source(), s2.target()); typename K::Comparison_result cmp_x2 = compare_x(s2s, s2t);
if (cmp_x1 == EQUAL) if (cmp_x1 == EQUAL)
return cmp_x2 == EQUAL ? EQUAL : LARGER; return cmp_x2 == EQUAL ? EQUAL : LARGER;
if (cmp_x2 == EQUAL) return SMALLER; if (cmp_x2 == EQUAL) return SMALLER;
FT s1_s_hw = s1.source().hw(); FT s1_s_hw = s1s.hw();
FT s1_t_hw = s1.target().hw(); FT s1_t_hw = s1t.hw();
FT s2_s_hw = s2.source().hw(); FT s2_s_hw = s2s.hw();
FT s2_t_hw = s2.target().hw(); FT s2_t_hw = s2t.hw();
FT s1_xdiff = s1.source().hx()*s1_t_hw - s1.target().hx()*s1_s_hw; FT s1_xdiff = s1s.hx()*s1_t_hw - s1t.hx()*s1_s_hw;
FT s1_ydiff = s1.source().hy()*s1_t_hw - s1.target().hy()*s1_s_hw; FT s1_ydiff = s1s.hy()*s1_t_hw - s1t.hy()*s1_s_hw;
FT s2_xdiff = s2.source().hx()*s2_t_hw - s2.target().hx()*s2_s_hw; FT s2_xdiff = s2s.hx()*s2_t_hw - s2t.hx()*s2_s_hw;
FT s2_ydiff = s2.source().hy()*s2_t_hw - s2.target().hy()*s2_s_hw; FT s2_ydiff = s2s.hy()*s2_t_hw - s2t.hy()*s2_s_hw;
typename K::Sign s1_sign = CGAL_NTS sign(s1_ydiff * s1_xdiff); typename K::Sign s1_sign = CGAL_NTS sign(s1_ydiff * s1_xdiff);
typename K::Sign s2_sign = CGAL_NTS sign(s2_ydiff * s2_xdiff); typename K::Sign s2_sign = CGAL_NTS sign(s2_ydiff * s2_xdiff);

6
Installation/CHANGES.md
View File

@ -58,6 +58,12 @@ Release date: December 2021
- Added the [OSQP solver](https://osqp.org/) support. This solver enables to efficiently compute the convex Quadratic Programming (QP) problems arising in the context of several packages. - Added the [OSQP solver](https://osqp.org/) support. This solver enables to efficiently compute the convex Quadratic Programming (QP) problems arising in the context of several packages.
### [Point Set Processing](https://doc.cgal.org/5.4/Manual/packages.html#PkgPointSetProcessing3)
- Added support for `libpointmatcher::GenericDescriptorOutlierFilter`
that enables to provide a map from a point to a weight associated with this point.
[Release 5.3](https://github.com/CGAL/cgal/releases/tag/v5.3) [Release 5.3](https://github.com/CGAL/cgal/releases/tag/v5.3)
----------- -----------

13
Kernel_23/doc/Kernel_23/CGAL/Kernel/global_functions.h
View File

@ -852,7 +852,7 @@ const CGAL::Point_3<Kernel>& t);
/// \defgroup compare_slopes_grp CGAL::compare_slopes() /// \defgroup compare_slopes_grp CGAL::compare_slope()
/// \ingroup kernel_global_function /// \ingroup kernel_global_function
/// @{ /// @{
@ -873,6 +873,17 @@ Comparison_result compare_slope(const CGAL::Segment_2<Kernel> &s1,
const CGAL::Segment_2<Kernel> &s2); const CGAL::Segment_2<Kernel> &s2);
/*! /*!
compares the slopes of the segments `(s1s,s1t)` and `(s2s,s2t)`,
where the slope is the variation of the `y`-coordinate
from the left to the right endpoint of the segments.
*/
template <typename Kernel>
Comparison_result compare_slope(const CGAL::Point_2<Kernel> &s1s,
const CGAL::Point_2<Kernel> &s1t,
const CGAL::Point_2<Kernel> &s2s,
const CGAL::Point_2<Kernel> &s2t);
/*!
compares the slopes of the segments `(p,q)` and `(r,s)`, compares the slopes of the segments `(p,q)` and `(r,s)`,
where the slope is the variation of the `z`-coordinate from the first where the slope is the variation of the `z`-coordinate from the first
to the second point of the segment divided by the length of the segment. to the second point of the segment divided by the length of the segment.

11
Kernel_23/doc/Kernel_23/Concepts/FunctionObjectConcepts.h
View File

@ -1041,6 +1041,16 @@ public:
Comparison_result operator()(const Kernel::Segment_2& s1, Comparison_result operator()(const Kernel::Segment_2& s1,
const Kernel::Segment_2& s2); const Kernel::Segment_2& s2);
/*!
compares the slopes of the segments `(s1s,s1t)` and `(s2s,s2t)`,
where the slope is the variation of the `y`-coordinate
from the left to the right endpoint of the segments.
*/
Comparison_result operator()(const Kernel::Point_2& s1s,
const Kernel::Point_2& s1t,
const Kernel::Point_2& s2s,
const Kernel::Point_2& s2t));
/// @} /// @}
}; /* end Kernel::CompareSlope_2 */ }; /* end Kernel::CompareSlope_2 */
@ -9712,7 +9722,6 @@ public:
const Kernel::Point_3&s, const Kernel::Point_3&s,
const Kernel::Point_3&t); const Kernel::Point_3&t);
/// @} /// @}
}; /* end Kernel::SideOfOrientedSphere_3 */ }; /* end Kernel::SideOfOrientedSphere_3 */

9
Kernel_23/include/CGAL/Kernel/global_functions_2.h
View File

@ -347,6 +347,15 @@ compare_slope(const Segment_2<K> &s1, const Segment_2<K> &s2)
return internal::compare_slope(s1, s2, K()); return internal::compare_slope(s1, s2, K());
} }
template < class K >
inline
typename K::Comparison_result
compare_slope(const Point_2<K> &s1s, const Point_2<K> &s1t,
const Point_2<K> &s2s, const Point_2<K> &s2t)
{
return internal::compare_slope(s1s, s1t, s2s, s2t, K());
}
#ifndef CGAL_NO_DEPRECATED_CODE #ifndef CGAL_NO_DEPRECATED_CODE
// kept for backward compatibility // kept for backward compatibility

11
Kernel_23/include/CGAL/Kernel/global_functions_internal_2.h
View File

@ -373,6 +373,17 @@ compare_slope(const typename K::Segment_2 &s1,
return k.compare_slope_2_object()(s1, s2); return k.compare_slope_2_object()(s1, s2);
} }
template < class K >
inline
typename K::Comparison_result
compare_slope(const typename K::Point_2 &s1s,
const typename K::Point_2 &s1t,
const typename K::Point_2 &s2s,
const typename K::Point_2 &s2t,const K& k)
{
return k.compare_slope_2_object()(s1s, s1t, s2s, s2t);
}
template < class K > template < class K >
inline inline
typename K::Comparison_result typename K::Comparison_result

3
Kernel_23/test/Kernel_23/include/CGAL/_test_new_2.h
View File

@ -477,6 +477,7 @@ test_new_2(const R& rep)
= rep.compare_slope_2_object(); = rep.compare_slope_2_object();
Comparison_result tmp34ee = compare_slope(l1, l2); Comparison_result tmp34ee = compare_slope(l1, l2);
Comparison_result tmp34ff = compare_slope(s1, s2); Comparison_result tmp34ff = compare_slope(s1, s2);
Comparison_result tmp34gg = compare_slope(p3, p5, p2, p3);
typename R::Less_distance_to_point_2 less_distance_to_point typename R::Less_distance_to_point_2 less_distance_to_point
= rep.less_distance_to_point_2_object(); = rep.less_distance_to_point_2_object();
@ -680,7 +681,7 @@ test_new_2(const R& rep)
use(tmp32a); use(tmp31d); use(tmp31c); use(tmp31b); use(tmp31a); use(tmp30); use(tmp32a); use(tmp31d); use(tmp31c); use(tmp31b); use(tmp31a); use(tmp30);
use(tmp26); use(tmp25); use(tmp24); use(tmp26); use(tmp25); use(tmp24);
use(tmp29); use(tmp28); use(tmp33a); use(tmp33b); use(tmp34ab); use(tmp34ac); use(tmp29); use(tmp28); use(tmp33a); use(tmp33b); use(tmp34ab); use(tmp34ac);
use(tmp34ff); use(tmp34ee); use(tmp34dd); use(tmp34cc); use(tmp34bb); use(tmp34ff); use(tmp34gg); use(tmp34ee); use(tmp34dd); use(tmp34cc); use(tmp34bb);
use(tmp34aa); use(tmp34aa);
use(tmp39a); use(tmp36a); use(tmp48c); use(tmp49c); use(tmp50c); use(tmp39a); use(tmp36a); use(tmp48c); use(tmp49c); use(tmp50c);
use(tmp24a); use(tmp24b); use(tmp24c); use(tmp24d); use(tmp24e); use(tmp24f); use(tmp24a); use(tmp24b); use(tmp24c); use(tmp24d); use(tmp24e); use(tmp24f);

8
Mesh_2/include/CGAL/Delaunay_mesh_vertex_base_2.h
View File

@ -60,7 +60,15 @@ public:
sizing_info_ = s; sizing_info_ = s;
} }
const FT& sizing_info() const { return sizing_info_; } const FT& sizing_info() const { return sizing_info_; }
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
typedef Tag_true Has_timestamp;
std::size_t time_stamp() const { return time_stamp_; }
void set_time_stamp(const std::size_t& ts) { time_stamp_ = ts; }
std::size_t time_stamp_;
#endif // CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
}; };
} // namespace CGAL } // namespace CGAL

8
Mesh_2/include/CGAL/Mesh_2/Refine_edges.h
View File

@ -504,6 +504,14 @@ public:
va = edge.first->vertex(tr.cw (edge.second)); va = edge.first->vertex(tr.cw (edge.second));
vb = edge.first->vertex(tr.ccw(edge.second)); vb = edge.first->vertex(tr.ccw(edge.second));
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
std::cerr << "refinement_point_impl("
<< "#" << va->time_stamp() << ": " << va->point() << ", "
<< "#" << vb->time_stamp() << ": " << vb->point() << ") = ";
auto p = midpoint(va->point(), vb->point());
std::cerr << p << '\n';
return p;
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
return midpoint(va->point(), vb->point()); return midpoint(va->point(), vb->point());
} }

27
Mesh_2/include/CGAL/Mesh_2/Refine_edges_with_clusters.h
View File

@ -71,9 +71,9 @@ class Refine_edges_base_with_clusters :
Cluster ca, cb; Cluster ca, cb;
clusters_iterator ca_it, cb_it; clusters_iterator ca_it, cb_it;
public:
using Super::triangulation_ref_impl; using Super::triangulation_ref_impl;
public:
/** \name CONSTRUCTORS */ /** \name CONSTRUCTORS */
Refine_edges_base_with_clusters(Tr& tr_, Clusters<Tr>& c_) Refine_edges_base_with_clusters(Tr& tr_, Clusters<Tr>& c_)
@ -91,6 +91,11 @@ public:
this->va = edge.first->vertex(Tr::cw (edge.second)); this->va = edge.first->vertex(Tr::cw (edge.second));
this->vb = edge.first->vertex(Tr::ccw(edge.second)); this->vb = edge.first->vertex(Tr::ccw(edge.second));
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
std::cerr << "refinement_point_impl("
<< "#" << this->va->time_stamp() << ": " << this->va->point() << ", "
<< "#" << this->vb->time_stamp() << ": " << this->vb->point() << ") = ";
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
// std::cerr << "refinement_point_impl\n" << this->va->point() << " / " // std::cerr << "refinement_point_impl\n" << this->va->point() << " / "
// << this->vb->point() << std::endl; // << this->vb->point() << std::endl;
@ -110,17 +115,32 @@ public:
std::cerr << "midpoint(" << this->va->point() std::cerr << "midpoint(" << this->va->point()
<< " , " << this->vb->point() << ")\n"; << " , " << this->vb->point() << ")\n";
#endif // CGAL_MESH_2_DEBUG_CLUSTERS #endif // CGAL_MESH_2_DEBUG_CLUSTERS
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
auto p = midpoint(this->va->point(), this->vb->point());
std::cerr << p << '\n';
return p;
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
return midpoint(this->va->point(), this->vb->point()); return midpoint(this->va->point(), this->vb->point());
} }
else { else {
// va only is a cluster // va only is a cluster
va_has_a_cluster = true; va_has_a_cluster = true;
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
auto p = split_cluster_point(this->va,this->vb,ca);
std::cerr << p << '\n';
return p;
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
return split_cluster_point(this->va,this->vb,ca); return split_cluster_point(this->va,this->vb,ca);
} }
} else } else
if( clusters.get_cluster(this->vb,this->va,cb,cb_it) ){ if( clusters.get_cluster(this->vb,this->va,cb,cb_it) ){
// vb only is a cluster // vb only is a cluster
vb_has_a_cluster = true; vb_has_a_cluster = true;
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
auto p = split_cluster_point(this->vb,this->va,cb);
std::cerr << p << '\n';
return p;
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
return split_cluster_point(this->vb,this->va,cb); return split_cluster_point(this->vb,this->va,cb);
}else{ }else{
// no cluster // no cluster
@ -128,6 +148,11 @@ public:
std::cerr << "midpoint(" << this->va->point() std::cerr << "midpoint(" << this->va->point()
<< " , " << this->vb->point() << ")\n"; << " , " << this->vb->point() << ")\n";
#endif // CGAL_MESH_2_DEBUG_CLUSTERS #endif // CGAL_MESH_2_DEBUG_CLUSTERS
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
auto p = midpoint(this->va->point(), this->vb->point());
std::cerr << p << '\n';
return p;
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
return midpoint(this->va->point(), this->vb->point()); return midpoint(this->va->point(), this->vb->point());
} }
}; };

13
Mesh_2/include/CGAL/Mesh_2/Refine_faces.h
View File

@ -15,7 +15,7 @@
#include <CGAL/license/Mesh_2.h> #include <CGAL/license/Mesh_2.h>
#include <CGAL/Meshes/Triangulation_mesher_level_traits_2.h>
#include <CGAL/Mesh_2/Face_badness.h> #include <CGAL/Mesh_2/Face_badness.h>
#include <CGAL/Double_map.h> #include <CGAL/Double_map.h>
#include <CGAL/boost/iterator/transform_iterator.hpp> #include <CGAL/boost/iterator/transform_iterator.hpp>
@ -81,7 +81,7 @@ protected: // --- PROTECTED TYPES ---
typedef CGAL::Double_map<Face_handle, Quality, Face_compare> Bad_faces; typedef CGAL::Double_map<Face_handle, Quality, Face_compare> Bad_faces;
protected: protected:
// --- PROTECTED MEMBER DATAS --- // --- PROTECTED MEMBER DATA ---
Criteria& criteria; /**<The meshing criteria */ Criteria& criteria; /**<The meshing criteria */
Previous& previous; Previous& previous;
@ -178,6 +178,15 @@ public:
/** Returns the circumcenter of the face. */ /** Returns the circumcenter of the face. */
Point refinement_point_impl(const Face_handle& f) const Point refinement_point_impl(const Face_handle& f) const
{ {
#ifdef CGAL_MESH_2_DEBUG_REFINEMENT_POINTS
std::cerr << "refinement_point_impl("
<< "#" << f->vertex(0)->time_stamp() << ": " << f->vertex(0)->point() << ", "
<< "#" << f->vertex(1)->time_stamp() << ": " << f->vertex(1)->point() << ", "
<< "#" << f->vertex(2)->time_stamp() << ": " << f->vertex(2)->point() << ") = ";
auto p = triangulation_ref_impl().circumcenter(f);
std::cerr << p << '\n';
return p;
#endif // CGAL_MESH_2_DEBUG_BAD_FACES
return triangulation_ref_impl().circumcenter(f); return triangulation_ref_impl().circumcenter(f);
} }

0
Orthtree/package_info/Orthtree/copyright.txt → Orthtree/package_info/Orthtree/copyright
View File

1
Point_set_2/package_info/Point_set_2/copyright Normal file
View File

@ -0,0 +1 @@
Max-Planck-Institute Saarbruecken (Germany)

0
Point_set_3/package_info/Point_set_3/copyright.txt → Point_set_3/package_info/Point_set_3/copyright
View File

23
Point_set_processing_3/examples/Point_set_processing_3/registration_with_pointmatcher.cpp
View File

@ -21,6 +21,17 @@ typedef std::pair<Point_3, Vector_3> Pwn;
typedef CGAL::First_of_pair_property_map<Pwn> Point_map; typedef CGAL::First_of_pair_property_map<Pwn> Point_map;
typedef CGAL::Second_of_pair_property_map<Pwn> Normal_map; typedef CGAL::Second_of_pair_property_map<Pwn> Normal_map;
struct Weight_map
{
typedef Pwn key_type;
typedef typename K::FT value_type;
typedef value_type reference;
typedef boost::readable_property_map_tag category;
typedef Weight_map Self;
friend reference get(const Self&, const key_type&) { return value_type(1); }
};
namespace params = CGAL::parameters; namespace params = CGAL::parameters;
int main(int argc, const char** argv) int main(int argc, const char** argv)
@ -67,11 +78,13 @@ int main(int argc, const char** argv)
ICP_config matcher { /*.name=*/"KDTreeMatcher", /*.params=*/{ {"knn", "1"}, {"epsilon", "3.16"} } }; ICP_config matcher { /*.name=*/"KDTreeMatcher", /*.params=*/{ {"knn", "1"}, {"epsilon", "3.16"} } };
// Prepare outlier filters // Prepare outlier filters
// NOTE: `GenericDescriptorOutlierFilter` supports only one `descName` that is `weights`!
std::vector<ICP_config> outlier_filters; std::vector<ICP_config> outlier_filters;
outlier_filters.push_back( ICP_config { /*.name=*/"TrimmedDistOutlierFilter", /*.params=*/{ {"ratio", "0.75" }} } ); outlier_filters.push_back( ICP_config { /*.name=*/"TrimmedDistOutlierFilter", /*.params=*/{ {"ratio", "0.75" }} } );
outlier_filters.push_back( ICP_config { /*.name=*/"GenericDescriptorOutlierFilter", /*.params=*/{ {"descName", "weights" }} } );
// Prepare error minimizer // Prepare error minimizer
ICP_config error_minimizer { /*.name=*/"PointToPointErrorMinimizer"}; ICP_config error_minimizer { /*.name=*/"PointToPointErrorMinimizer", /*.params=*/{ } };
// Prepare transformation checker // Prepare transformation checker
std::vector<ICP_config> transformation_checkers; std::vector<ICP_config> transformation_checkers;
@ -81,10 +94,10 @@ int main(int argc, const char** argv)
{"smoothLength" , "4" } } {"smoothLength" , "4" } }
} ); } );
// Prepare inspector // Prepare inspector
ICP_config inspector { /*.name=*/"NullInspector" }; ICP_config inspector { /*.name=*/"NullInspector", /*.params=*/{ } };
// Prepare logger // Prepare logger
ICP_config logger { /*.name=*/"FileLogger" }; ICP_config logger { /*.name=*/"FileLogger", /*.params=*/{ } };
const K::Aff_transformation_3 identity_transform = K::Aff_transformation_3(CGAL::Identity_transformation()); const K::Aff_transformation_3 identity_transform = K::Aff_transformation_3(CGAL::Identity_transformation());
@ -92,7 +105,7 @@ int main(int argc, const char** argv)
std::pair<K::Aff_transformation_3, bool> res = std::pair<K::Aff_transformation_3, bool> res =
CGAL::pointmatcher::compute_registration_transformation CGAL::pointmatcher::compute_registration_transformation
(pwns1, pwns2, (pwns1, pwns2,
params::point_map(Point_map()).normal_map(Normal_map()) params::point_map(Point_map()).normal_map(Normal_map()).scalar_map(Weight_map())
.point_set_filters(point_set_1_filters) .point_set_filters(point_set_1_filters)
.matcher(matcher) .matcher(matcher)
.outlier_filters(outlier_filters) .outlier_filters(outlier_filters)
@ -100,7 +113,7 @@ int main(int argc, const char** argv)
.transformation_checkers(transformation_checkers) .transformation_checkers(transformation_checkers)
.inspector(inspector) .inspector(inspector)
.logger(logger), .logger(logger),
params::point_map(Point_map()).normal_map(Normal_map()) params::point_map(Point_map()).normal_map(Normal_map()).scalar_map(Weight_map())
.point_set_filters(point_set_2_filters) .point_set_filters(point_set_2_filters)
.transformation(identity_transform) /* initial transform for pwns2. .transformation(identity_transform) /* initial transform for pwns2.
* default value is already identity transform. * default value is already identity transform.

71
Point_set_processing_3/include/CGAL/pointmatcher/compute_registration_transformation.h
View File

@ -21,6 +21,7 @@
#include <CGAL/boost/graph/Named_function_parameters.h> #include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h> #include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/aff_transformation_tags.h> #include <CGAL/aff_transformation_tags.h>
#include <CGAL/property_map.h>
#include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_same.hpp>
@ -78,7 +79,7 @@ construct_icp(const NamedParameters1& np1, const NamedParameters2& np2)
icp.setDefault(); icp.setDefault();
const ICP_config null_config { "_null_pm_config_in_cgal" }; const ICP_config null_config { /*.name=*/"_null_pm_config_in_cgal", /*.params=*/{ } };
const std::vector<ICP_config> null_config_chain { null_config }; const std::vector<ICP_config> null_config_chain { null_config };
auto is_null_config = [&](const ICP_config& c) { return !c.name.compare(null_config.name); }; auto is_null_config = [&](const ICP_config& c) { return !c.name.compare(null_config.name); };
@ -220,10 +221,11 @@ template<typename Scalar,
typename PointRange, typename PointRange,
typename PointMap, typename PointMap,
typename VectorMap, typename VectorMap,
typename ScalarMap,
typename PM_matrix> typename PM_matrix>
void void
copy_cgal_points_to_pm_matrix copy_cgal_points_to_pm_matrix
(const PointRange& prange, PointMap point_map, VectorMap vector_map, PM_matrix& pm_points, PM_matrix& pm_normals) (const PointRange& prange, PointMap point_map, VectorMap vector_map, ScalarMap scalar_map, PM_matrix& pm_points, PM_matrix& pm_normals, PM_matrix& pm_weights)
{ {
int idx = 0; int idx = 0;
for(const auto& p : prange) for(const auto& p : prange)
@ -241,6 +243,10 @@ copy_cgal_points_to_pm_matrix
pm_normals(1, idx) = normal.y(); pm_normals(1, idx) = normal.y();
pm_normals(2, idx) = normal.z(); pm_normals(2, idx) = normal.z();
// weight
const auto& weight = get(scalar_map, p);
pm_weights(0, idx) = weight;
++idx; ++idx;
} }
} }
@ -251,11 +257,14 @@ template <class Kernel,
class PointMap1, class PointMap1,
class PointMap2, class PointMap2,
class VectorMap1, class VectorMap1,
class VectorMap2> class VectorMap2,
class ScalarMap1,
class ScalarMap2>
std::pair<typename Kernel::Aff_transformation_3, bool> std::pair<typename Kernel::Aff_transformation_3, bool>
compute_registration_transformation(const PointRange1& range1, const PointRange2& range2, compute_registration_transformation(const PointRange1& range1, const PointRange2& range2,
PointMap1 point_map1, PointMap2 point_map2, PointMap1 point_map1, PointMap2 point_map2,
VectorMap1 vector_map1, VectorMap2 vector_map2, VectorMap1 vector_map1, VectorMap2 vector_map2,
ScalarMap1 scalar_map1, ScalarMap2 scalar_map2,
const typename Kernel::Aff_transformation_3& initial_transform, const typename Kernel::Aff_transformation_3& initial_transform,
ICP<typename Kernel::FT> icp) ICP<typename Kernel::FT> icp)
{ {
@ -273,8 +282,10 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
PM_matrix ref_points_pos_matrix = PM_matrix (4, nb_ref_points); PM_matrix ref_points_pos_matrix = PM_matrix (4, nb_ref_points);
PM_matrix ref_points_normal_matrix = PM_matrix (3, nb_ref_points); PM_matrix ref_points_normal_matrix = PM_matrix (3, nb_ref_points);
PM_matrix ref_points_weight_matrix = PM_matrix (1, nb_ref_points);
PM_matrix points_pos_matrix = PM_matrix (4, nb_points); PM_matrix points_pos_matrix = PM_matrix (4, nb_points);
PM_matrix points_normal_matrix = PM_matrix (3, nb_points); PM_matrix points_normal_matrix = PM_matrix (3, nb_points);
PM_matrix points_weight_matrix = PM_matrix (1, nb_points);
// In CGAL, point_set_1 is the reference while point_set_2 is the data // In CGAL, point_set_1 is the reference while point_set_2 is the data
@ -282,16 +293,20 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
internal::copy_cgal_points_to_pm_matrix<Scalar>(range1, internal::copy_cgal_points_to_pm_matrix<Scalar>(range1,
point_map1, point_map1,
vector_map1, vector_map1,
scalar_map1,
ref_points_pos_matrix, // out ref_points_pos_matrix, // out
ref_points_normal_matrix); // out ref_points_normal_matrix, // out
ref_points_weight_matrix); // out
internal::copy_cgal_points_to_pm_matrix<Scalar>(range2, internal::copy_cgal_points_to_pm_matrix<Scalar>(range2,
point_map2, point_map2,
vector_map2, vector_map2,
scalar_map2,
points_pos_matrix, // out points_pos_matrix, // out
points_normal_matrix); // out points_normal_matrix, // out
points_weight_matrix); // out
auto construct_PM_cloud = [](const PM_matrix& positions, const PM_matrix& normals) -> PM_cloud auto construct_PM_cloud = [](const PM_matrix& positions, const PM_matrix& normals, const PM_matrix& weights) -> PM_cloud
{ {
PM_cloud cloud; PM_cloud cloud;
@ -300,12 +315,13 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
cloud.addFeature("z", positions.row(2)); cloud.addFeature("z", positions.row(2));
cloud.addFeature("pad", positions.row(3)); cloud.addFeature("pad", positions.row(3));
cloud.addDescriptor("normals", normals); cloud.addDescriptor("normals", normals);
cloud.addDescriptor("weights", weights);
return cloud; return cloud;
}; };
PM_cloud ref_cloud = construct_PM_cloud(ref_points_pos_matrix, ref_points_normal_matrix); PM_cloud ref_cloud = construct_PM_cloud(ref_points_pos_matrix, ref_points_normal_matrix, ref_points_weight_matrix);
PM_cloud cloud = construct_PM_cloud(points_pos_matrix, points_normal_matrix); PM_cloud cloud = construct_PM_cloud(points_pos_matrix, points_normal_matrix, points_weight_matrix);
PM_transform_params pm_transform_params = PM_transform_params::Identity(4,4); PM_transform_params pm_transform_params = PM_transform_params::Identity(4,4);
@ -385,6 +401,16 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
of the iterator of `PointRange1` and whose value type is `geom_traits::Vector_3`} of the iterator of `PointRange1` and whose value type is `geom_traits::Vector_3`}
\cgalParamNEnd \cgalParamNEnd
\cgalParamNBegin{scalar_map}
\cgalParamDescription{a property map associating 1D values - scalars to the elements of the point set `point_set_1`}
\cgalParamType{a model of `ReadablePropertyMap` whose key type is the value type
of the iterator of `PointRange1` and whose value type is `geom_traits::FT`}
\cgalParamDefault{`CGAL::Constant_property_map` with the value = 1 for all scalars}
\cgalParamExtra{These scalars, sometimes called weights, can be provided through the `GenericDescriptorOutlierFilter`
of \ref thirdpartylibpointmatcher library, where the `descName = weights`.
See `outlier_filters` below and `registration_with_pointmatcher.cpp` for more details.}
\cgalParamNEnd
\cgalParamNBegin{point_set_filters} \cgalParamNBegin{point_set_filters}
\cgalParamDescription{a chain of filters to be applied to the point set} \cgalParamDescription{a chain of filters to be applied to the point set}
\cgalParamType{a class model of `Range`. The value type of its iterator must be `ICP_config`.} \cgalParamType{a class model of `Range`. The value type of its iterator must be `ICP_config`.}
@ -510,6 +536,15 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
of the iterator of `PointRange2` and whose value type is `geom_traits::Vector_3`} of the iterator of `PointRange2` and whose value type is `geom_traits::Vector_3`}
\cgalParamNEnd \cgalParamNEnd
\cgalParamNBegin{scalar_map}
\cgalParamDescription{a property map associating 1D values - scalars to the elements of the point set `point_set_2`}
\cgalParamType{a model of `ReadablePropertyMap` whose key type is the value type
of the iterator of `PointRange2` and whose value type is `geom_traits::FT`}
\cgalParamDefault{`CGAL::Constant_property_map` with the value = 1 for all scalars}
\cgalParamExtra{These scalars, sometimes called weights, can be provided through the `GenericDescriptorOutlierFilter`
of \ref thirdpartylibpointmatcher library, where the `descName = weights`.}
\cgalParamNEnd
\cgalParamNBegin{point_set_filters} \cgalParamNBegin{point_set_filters}
\cgalParamDescription{a chain of filters to be applied to the point set} \cgalParamDescription{a chain of filters to be applied to the point set}
\cgalParamType{a class model of `Range`. The value type of its iterator must be `ICP_config`.} \cgalParamType{a class model of `Range`. The value type of its iterator must be `ICP_config`.}
@ -563,6 +598,11 @@ compute_registration_transformation (const PointRange1& point_set_1, const Point
namespace PSP = CGAL::Point_set_processing_3; namespace PSP = CGAL::Point_set_processing_3;
// basic types
typedef typename PSP::GetK<PointRange1, NamedParameters1>::Kernel Kernel;
typedef typename Kernel::FT Scalar;
typedef typename Kernel::Aff_transformation_3 Transformation;
// property map types // property map types
typedef typename CGAL::GetPointMap<PointRange1, NamedParameters1>::type PointMap1; typedef typename CGAL::GetPointMap<PointRange1, NamedParameters1>::type PointMap1;
typedef typename CGAL::GetPointMap<PointRange2, NamedParameters2>::type PointMap2; typedef typename CGAL::GetPointMap<PointRange2, NamedParameters2>::type PointMap2;
@ -576,14 +616,22 @@ compute_registration_transformation (const PointRange1& point_set_1, const Point
typename boost::property_traits<NormalMap2>::value_type> ::value), typename boost::property_traits<NormalMap2>::value_type> ::value),
"The vector type of input ranges must be the same"); "The vector type of input ranges must be the same");
typedef typename PSP::GetK<PointRange1, NamedParameters1>::Kernel Kernel; typedef typename std::iterator_traits<typename PointRange1::iterator>::value_type key_type1;
typedef typename Kernel::FT Scalar; typedef typename std::iterator_traits<typename PointRange2::iterator>::value_type key_type2;
typedef typename Kernel::Aff_transformation_3 Transformation;
typedef typename CGAL::Constant_property_map<key_type1, Scalar> DefaultWeightMap1;
typedef typename CGAL::Constant_property_map<key_type2, Scalar> DefaultWeightMap2;
PointMap1 point_map1 = choose_parameter(get_parameter(np1, internal_np::point_map), PointMap1()); PointMap1 point_map1 = choose_parameter(get_parameter(np1, internal_np::point_map), PointMap1());
NormalMap1 normal_map1 = choose_parameter(get_parameter(np1, internal_np::normal_map), NormalMap1()); NormalMap1 normal_map1 = choose_parameter(get_parameter(np1, internal_np::normal_map), NormalMap1());
auto weight_map1 = choose_parameter(get_parameter(np1, internal_np::scalar_map), DefaultWeightMap1(Scalar(1)));
PointMap2 point_map2 = choose_parameter(get_parameter(np2, internal_np::point_map), PointMap2()); PointMap2 point_map2 = choose_parameter(get_parameter(np2, internal_np::point_map), PointMap2());
NormalMap2 normal_map2 = choose_parameter(get_parameter(np2, internal_np::normal_map), NormalMap2()); NormalMap2 normal_map2 = choose_parameter(get_parameter(np2, internal_np::normal_map), NormalMap2());
auto weight_map2 = choose_parameter(get_parameter(np2, internal_np::scalar_map), DefaultWeightMap2(Scalar(1)));
CGAL_static_assertion_msg((boost::is_same< typename boost::property_traits<decltype(weight_map1)>::value_type,
typename boost::property_traits<decltype(weight_map2)>::value_type> ::value),
"The scalar type of input ranges must be the same");
// initial transformation // initial transformation
Transformation initial_transformation Transformation initial_transformation
@ -592,6 +640,7 @@ compute_registration_transformation (const PointRange1& point_set_1, const Point
return internal::compute_registration_transformation<Kernel>(point_set_1, point_set_2, return internal::compute_registration_transformation<Kernel>(point_set_1, point_set_2,
point_map1, point_map2, point_map1, point_map2,
normal_map1, normal_map2, normal_map1, normal_map2,
weight_map1, weight_map2,
initial_transformation, initial_transformation,
internal::construct_icp<Scalar>(np1, np2)); internal::construct_icp<Scalar>(np1, np2));
} }

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h
View File

@ -316,6 +316,7 @@ void split_along_edges(TriangleMesh& tm,
std::set<halfedge_descriptor> extra_border_hedges; std::set<halfedge_descriptor> extra_border_hedges;
for(std::size_t k=0; k<nb_shared_edges; ++k) for(std::size_t k=0; k<nb_shared_edges; ++k)
{ {
if (is_border(shared_edges[k], tm)) continue;
for(halfedge_descriptor h : halfedges_around_target(target(shared_edges[k], tm), tm)) for(halfedge_descriptor h : halfedges_around_target(target(shared_edges[k], tm), tm))
if(is_border(h, tm)) if(is_border(h, tm))
extra_border_hedges.insert(h); extra_border_hedges.insert(h);
@ -334,6 +335,7 @@ void split_along_edges(TriangleMesh& tm,
// now duplicate the edge and set its pointers // now duplicate the edge and set its pointers
for(std::size_t k=0; k<nb_shared_edges; ++k) for(std::size_t k=0; k<nb_shared_edges; ++k)
{ {
if (is_border(shared_edges[k], tm)) continue;
halfedge_descriptor h = halfedge(shared_edges[k], tm); halfedge_descriptor h = halfedge(shared_edges[k], tm);
face_descriptor fh = face(h, tm); face_descriptor fh = face(h, tm);
//add edge //add edge

18
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h
View File

@ -132,6 +132,24 @@ namespace Polygon_mesh_processing {
* \cgalParamExtra{The map is updated during the remeshing process while new faces are created.} * \cgalParamExtra{The map is updated during the remeshing process while new faces are created.}
* \cgalParamNEnd * \cgalParamNEnd
* *
* \cgalParamNBegin{do_split}
* \cgalParamDescription{whether edges that are too long with respect to the given sizing are split}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_collapse}
* \cgalParamDescription{whether edges that are too short with respect to the given sizing are collapsed}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_flip}
* \cgalParamDescription{whether edge flips are performed to improve shape and valence}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_relaxation_steps} * \cgalParamNBegin{number_of_relaxation_steps}
* \cgalParamDescription{the number of iterations of tangential relaxation that are performed * \cgalParamDescription{the number of iterations of tangential relaxation that are performed
* at each iteration of the remeshing process} * at each iteration of the remeshing process}

113
Polygon_mesh_processing/test/Polygon_mesh_processing/test_pmp_clip.cpp
View File

@ -497,12 +497,70 @@ void test()
PMP::clip(tm1, K::Plane_3(0,-1,0,0)); PMP::clip(tm1, K::Plane_3(0,-1,0,0));
assert(vertices(tm1).size() == 7); assert(vertices(tm1).size() == 7);
} }
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
PMP::clip(tm1, K::Plane_3(0,0,1,-1), CGAL::parameters::use_compact_clipper(false));
assert(vertices(tm1).size()==753);
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
std::size_t nbv = vertices(tm1).size();
PMP::clip(tm1, K::Plane_3(0,0,1,-1), CGAL::parameters::use_compact_clipper(true));
assert(vertices(tm1).size()==nbv+2); // because of the plane diagonal
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
PMP::clip(tm1, K::Plane_3(0,0,1,-1), CGAL::parameters::use_compact_clipper(false).allow_self_intersections(true));
assert(vertices(tm1).size()==753);
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
std::size_t nbv = vertices(tm1).size();
PMP::clip(tm1, K::Plane_3(0,0,1,-1), CGAL::parameters::use_compact_clipper(true).allow_self_intersections(true));
assert(vertices(tm1).size()==nbv+2); // because of the plane diagonal
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
PMP::clip(tm1, K::Plane_3(0,0,-1,1), CGAL::parameters::use_compact_clipper(false));
assert(vertices(tm1).size()==0);
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
PMP::clip(tm1, K::Plane_3(0,0,-1,1), CGAL::parameters::use_compact_clipper(true));
assert(vertices(tm1).size()==176);
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
PMP::clip(tm1, K::Plane_3(0,0,-1,1), CGAL::parameters::use_compact_clipper(false).allow_self_intersections(true));
assert(vertices(tm1).size()==0);
}
{
TriangleMesh tm1;
std::ifstream("data-coref/open_large_cube.off") >> tm1;
PMP::clip(tm1, K::Plane_3(0,0,-1,1), CGAL::parameters::use_compact_clipper(true).allow_self_intersections(true));
assert(vertices(tm1).size()==176);
}
} }
template <class Mesh> template <class Mesh>
void test_split_plane() void test_split_plane()
{ {
// test with a clipper mesh //test with a splitter mesh
Mesh tm1; Mesh tm1;
std::ifstream input("data-coref/elephant.off"); std::ifstream input("data-coref/elephant.off");
input >> tm1; input >> tm1;
@ -529,6 +587,44 @@ void test_split_plane()
CGAL::clear(tm1); CGAL::clear(tm1);
meshes.clear(); meshes.clear();
//test with a non-closed splitter mesh (border edges in the plane)
input.open("data-coref/open_large_cube.off");
input >> tm1;
if(!input)
{
std::cerr<<"File not found. Aborting."<<std::endl;
assert(false);
return ;
}
input.close();
PMP::split(tm1,K::Plane_3(0,0,1,-1));
PMP::split_connected_components(tm1, meshes, params::all_default());
assert(meshes.size() == 281);
CGAL::clear(tm1);
meshes.clear();
//test with a non-closed splitter mesh (border edges in the plane)
input.open("data-coref/open_large_cube.off");
input >> tm1;
if(!input)
{
std::cerr<<"File not found. Aborting."<<std::endl;
assert(false);
return ;
}
input.close();
PMP::split(tm1,K::Plane_3(0,-1,0,0.3));
PMP::split_connected_components(tm1, meshes, params::all_default());
assert(meshes.size() == 2);
CGAL::clear(tm1);
meshes.clear();
//test with SI //test with SI
std::ifstream("data-clip/tet_si_to_split.off") >> tm1; std::ifstream("data-clip/tet_si_to_split.off") >> tm1;
if(num_vertices(tm1) == 0) if(num_vertices(tm1) == 0)
@ -735,12 +831,15 @@ void test_isocuboid()
.allow_self_intersections(true)); .allow_self_intersections(true));
PMP::split_connected_components(tm, meshes, params::all_default()); PMP::split_connected_components(tm, meshes, params::all_default());
assert(meshes.size() == 4); assert(meshes.size() == 4);
//if the order is not deterministc, put the num_vertices in a list and check
//if the list does contain all those numbers. std::set<std::size_t> sizes;
assert(vertices(meshes[0]).size() == 22); for (int i=0; i<4; ++i)
assert(vertices(meshes[1]).size() == 23); sizes.insert(vertices(meshes[i]).size());
assert(vertices(meshes[2]).size() == 7);
assert(vertices(meshes[3]).size() == 4); assert(sizes.count(22)==1);
assert(sizes.count(23)==1);
assert(sizes.count(7)==1);
assert(sizes.count(4)==1);
CGAL::clear(tm); CGAL::clear(tm);
meshes.clear(); meshes.clear();

3
Polyhedron/include/CGAL/Polyhedron_3.h
View File

@ -110,7 +110,8 @@ public:
// the degree of the vertex, i.e., edges emanating from this vertex // the degree of the vertex, i.e., edges emanating from this vertex
std::size_t vertex_degree() const { std::size_t vertex_degree() const {
return this->halfedge()->vertex_degree(); return this->halfedge()!=Halfedge_const_handle()
? this->halfedge()->vertex_degree() : 0;
} }
size_type degree() const { return vertex_degree(); } //backwards compatible size_type degree() const { return vertex_degree(); } //backwards compatible

5
Scripts/developer_scripts/run_testsuite_from_branch_name.sh
View File

@ -33,7 +33,7 @@ git fetch $USER_REPO
git checkout $BRANCH_NAME git checkout $BRANCH_NAME
git reset --hard $USER_REPO/$BRANCH_NAME git reset --hard $USER_REPO/$BRANCH_NAME
#setup the list_test_packages #setup the list_test_packages
TMP_LIST=$(git diff --name-only cgal/$BASE_NAME...HEAD |cut -s -d/ -f1 |sort -u | xargs -I {} ls -d {}/package_info 2>/dev/null |cut -d/ -f1 |egrep -v Installation||true) TMP_LIST=$(git diff --name-only cgal/$BASE_NAME...HEAD |egrep -v /doc |egrep "\.h"\|"\.cpp" |cut -s -d/ -f1 |sort -u | xargs -I {} ls -d {}/package_info 2>/dev/null |cut -d/ -f1 |egrep -v Installation||true)
LIST_OF_PKGS="" LIST_OF_PKGS=""
for PKG in $(ls) ; do for PKG in $(ls) ; do
@ -63,6 +63,9 @@ cd ${CGAL_ROOT}
if [ -L CGAL-I ]; then rm CGAL-I; fi if [ -L CGAL-I ]; then rm CGAL-I; fi
ln -s $PWD/CGAL-TEST/$DEST CGAL-I ln -s $PWD/CGAL-TEST/$DEST CGAL-I
if [ -d CGAL-I/cmake/platforms ]; then
rm -rf CGAL-I/cmake/platforms/*
fi
echo "starting testsuite..." echo "starting testsuite..."
./autotest_cgal -c ./autotest_cgal -c

71
Shape_detection/include/CGAL/Shape_detection/Efficient_RANSAC/Efficient_RANSAC.h
View File

@ -480,8 +480,11 @@ public:
return false; return false;
} }
if (callback && !callback(0.)) if (callback && !callback(0.)) {
clear_octrees();
clear_shape_factories();
return false; return false;
}
// Reset data structures possibly used by former search // Reset data structures possibly used by former search
m_extracted_shapes = m_extracted_shapes =
@ -580,8 +583,10 @@ public:
m_shape_index, m_shape_index,
m_required_samples); m_required_samples);
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
} while (m_shape_index[first_sample] != -1 || !done); } while (m_shape_index[first_sample] != -1 || !done);
@ -591,8 +596,10 @@ public:
bool candidate_success = false; bool candidate_success = false;
for(typename std::vector<Shape *(*)()>::iterator it = for(typename std::vector<Shape *(*)()>::iterator it =
m_shape_factories.begin(); it != m_shape_factories.end(); it++) { m_shape_factories.begin(); it != m_shape_factories.end(); it++) {
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
Shape *p = (Shape *) (*it)(); Shape *p = (Shape *) (*it)();
//compute the primitive and says if the candidate is valid //compute the primitive and says if the candidate is valid
p->compute(indices, p->compute(indices,
@ -659,8 +666,10 @@ public:
Shape *best_candidate = Shape *best_candidate =
get_best_candidate(candidates, m_num_available_points - num_invalid); get_best_candidate(candidates, m_num_available_points - num_invalid);
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
// If search is done and the best candidate is too small, we are done. // If search is done and the best candidate is too small, we are done.
if (!keep_searching && best_candidate->m_score < m_options.min_points) if (!keep_searching && best_candidate->m_score < m_options.min_points)
@ -683,8 +692,10 @@ public:
best_candidate->connected_component(best_candidate->m_indices, best_candidate->connected_component(best_candidate->m_indices,
m_options.cluster_epsilon); m_options.cluster_epsilon);
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
// check score against min_points and clear out candidates if too low // check score against min_points and clear out candidates if too low
if (best_candidate->indices_of_assigned_points().size() < if (best_candidate->indices_of_assigned_points().size() <
m_options.min_points) { m_options.min_points) {
@ -700,8 +711,10 @@ public:
delete best_candidate; delete best_candidate;
best_candidate = nullptr; best_candidate = nullptr;
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
// Trimming candidates list // Trimming candidates list
std::size_t empty = 0, occupied = 0; std::size_t empty = 0, occupied = 0;
@ -727,8 +740,10 @@ public:
candidates.resize(empty); candidates.resize(empty);
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
} else if (stop_probability((std::size_t) best_candidate->expected_value(), } else if (stop_probability((std::size_t) best_candidate->expected_value(),
(m_num_available_points - num_invalid), (m_num_available_points - num_invalid),
generated_candidates, generated_candidates,
@ -742,8 +757,10 @@ public:
m_extracted_shapes->push_back( m_extracted_shapes->push_back(
boost::shared_ptr<Shape>(best_candidate)); boost::shared_ptr<Shape>(best_candidate));
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
//2. remove the points //2. remove the points
const std::vector<std::size_t> &indices_points_best_candidate = const std::vector<std::size_t> &indices_points_best_candidate =
@ -777,8 +794,10 @@ public:
failed_candidates = 0; failed_candidates = 0;
best_expected = 0; best_expected = 0;
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
std::vector<std::size_t> subset_sizes(m_num_subsets); std::vector<std::size_t> subset_sizes(m_num_subsets);
subset_sizes[0] = m_available_octree_sizes[0]; subset_sizes[0] = m_available_octree_sizes[0];
@ -807,8 +826,10 @@ public:
} }
} }
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
std::size_t start = 0, end = candidates.size() - 1; std::size_t start = 0, end = candidates.size() - 1;
while (start < end) { while (start < end) {
@ -828,8 +849,10 @@ public:
} else if (!keep_searching) } else if (!keep_searching)
++generated_candidates; ++generated_candidates;
if (callback && !callback(num_invalid / double(m_num_total_points))) if (callback && !callback(num_invalid / double(m_num_total_points))) {
clear(num_invalid, candidates);
return false; return false;
}
keep_searching = (stop_probability(m_options.min_points, keep_searching = (stop_probability(m_options.min_points,
m_num_available_points - num_invalid, m_num_available_points - num_invalid,
@ -841,13 +864,7 @@ public:
|| best_expected >= m_options.min_points); || best_expected >= m_options.min_points);
// Clean up remaining candidates. // Clean up remaining candidates.
for (std::size_t i = 0; i < candidates.size(); i++) clear_candidates(num_invalid, candidates);
delete candidates[i];
candidates.resize(0);
m_num_available_points -= num_invalid;
return true; return true;
} }
@ -912,6 +929,24 @@ public:
/// @} /// @}
private: private:
void clear(
const std::size_t num_invalid, std::vector<Shape *>& candidates) {
clear_octrees();
clear_shape_factories();
clear_candidates(num_invalid, candidates);
}
void clear_candidates(
const std::size_t num_invalid, std::vector<Shape *>& candidates) {
for (std::size_t i = 0; i < candidates.size(); i++) {
delete candidates[i];
}
candidates.resize(0);
m_num_available_points -= num_invalid;
}
int select_random_octree_level() { int select_random_octree_level() {
auto upper_bound = static_cast<unsigned int>(m_global_octree->maxLevel() + 1); auto upper_bound = static_cast<unsigned int>(m_global_octree->maxLevel() + 1);
return (int) get_default_random()(upper_bound); return (int) get_default_random()(upper_bound);

1
Skin_surface_3/package_info/Skin_surface_3/copyright Normal file
View File

@ -0,0 +1 @@
Rijksuniversiteit Groningen (Netherlands)

8
Stream_support/doc/Stream_support/IOstream.txt
View File

@ -252,10 +252,10 @@ for drawing operations in many \cgal output streams.
Each color is defined by a triple of integers `(r,g,b)` with Each color is defined by a triple of integers `(r,g,b)` with
0 \f$ \le \f$ r,g,b \f$ \le \f$ 255, the so-called <I>rgb-value</I> of the color. 0 \f$ \le \f$ r,g,b \f$ \le \f$ 255, the so-called <I>rgb-value</I> of the color.
There are a 11 predefined `Color` constants available: There are a 11 predefined `Color` functions available:
`BLACK`, `WHITE`, `GRAY`, `RED`, `GREEN`, `black()`, `white()`, `gray()`, `red()`, `green()`,
`DEEPBLUE`, `BLUE`, `PURPLE`, `VIOLET`, `ORANGE`, `deep_blue()`, `blue()`, `purple()`, `violet()`, `orange()`,
and `YELLOW`. and `yellow()`.
\subsection IOstreamStream Stream Support \subsection IOstreamStream Stream Support

4
Stream_support/test/Stream_support/data/colored_tetra.ply
View File

@ -18,8 +18,8 @@ property uchar green
property uchar blue property uchar blue
property int label property int label
element edge 6 element edge 6
property int v0 property int vertex1
property int v1 property int vertex2
property float confidence property float confidence
end_header end_header
0 0 0 -0.5 -0.5 -0.5 255 255 0 0 0 0 0 -0.5 -0.5 -0.5 255 255 0 0

12
Surface_mesh/include/CGAL/Surface_mesh/IO/PLY.h
View File

@ -175,8 +175,12 @@ public:
bool has_simplex_specific_property(internal::PLY_read_number* property, Edge_index) bool has_simplex_specific_property(internal::PLY_read_number* property, Edge_index)
{ {
const std::string& name = property->name(); const std::string& name = property->name();
if(name == "vertex1" || name == "vertex2")
return true;
#ifndef CGAL_NO_DEPRECATED_CODE
if(name == "v0" || name == "v1") if(name == "v0" || name == "v1")
return true; return true;
#endif
return false; return false;
} }
@ -365,8 +369,8 @@ public:
void process_line(PLY_element& element, Edge_index& ei) void process_line(PLY_element& element, Edge_index& ei)
{ {
IntType v0, v1; IntType v0, v1;
element.assign(v0, "v0"); element.assign(v0, "vertex1");
element.assign(v1, "v1"); element.assign(v1, "vertex2");
Halfedge_index hi = m_mesh.halfedge(m_map_v2v[std::size_t(v0)], Halfedge_index hi = m_mesh.halfedge(m_map_v2v[std::size_t(v0)],
m_map_v2v[std::size_t(v1)]); m_map_v2v[std::size_t(v1)]);
@ -961,8 +965,8 @@ bool write_PLY(std::ostream& os,
if(!eprinters.empty()) if(!eprinters.empty())
{ {
os << "element edge " << sm.number_of_edges() << std::endl; os << "element edge " << sm.number_of_edges() << std::endl;
os << "property int v0" << std::endl; os << "property int vertex1" << std::endl;
os << "property int v1" << std::endl; os << "property int vertex2" << std::endl;
os << oss.str(); os << oss.str();
} }
} }

4
Surface_mesh/test/Surface_mesh/colored_tetra.ply
View File

@ -18,8 +18,8 @@ property uchar green
property uchar blue property uchar blue
property int label property int label
element edge 6 element edge 6
property int v0 property int vertex1
property int v1 property int vertex2
property float confidence property float confidence
end_header end_header
0 0 0 -0.5 -0.5 -0.5 255 255 0 0 0 0 0 -0.5 -0.5 -0.5 255 255 0 0

0
Surface_mesh_shortest_path/package_info/Surface_mesh_shortest_path/copyright.txt → Surface_mesh_shortest_path/package_info/Surface_mesh_shortest_path/copyright
View File

1
Surface_mesh_topology/package_info/Surface_mesh_topology/copyright Normal file
View File

@ -0,0 +1 @@
CNRS and LIRIS' Establishments (France)

17
TDS_2/include/CGAL/Triangulation_data_structure_2.h
View File

@ -1997,13 +1997,16 @@ copy_tds(const TDS_src& tds_src,
CGAL_triangulation_precondition( tds_src.is_vertex(vert)); CGAL_triangulation_precondition( tds_src.is_vertex(vert));
clear(); clear();
size_type n = tds_src.number_of_vertices();
set_dimension(tds_src.dimension()); set_dimension(tds_src.dimension());
// Number of pointers to cell/vertex to copy per cell. if(tds_src.number_of_vertices() == 0)
int dim = (std::max)(1, dimension() + 1); return Vertex_handle();
if(n == 0) {return Vertex_handle();} // Number of pointers to face/vertex to copy per face.
const int dim = (std::max)(1, dimension() + 1);
// Number of neighbors to set in each face (dim -1 has a single face)
const int nn = (std::max)(0, dimension() + 1);
//initializes maps //initializes maps
Unique_hash_map<typename TDS_src::Vertex_handle,Vertex_handle> vmap; Unique_hash_map<typename TDS_src::Vertex_handle,Vertex_handle> vmap;
@ -2025,7 +2028,7 @@ copy_tds(const TDS_src& tds_src,
convert_face(*fit1, *fh); convert_face(*fit1, *fh);
} }
//link vertices to a cell //link vertices to a face
vit1 = tds_src.vertices_begin(); vit1 = tds_src.vertices_begin();
for ( ; vit1 != tds_src.vertices_end(); vit1++) { for ( ; vit1 != tds_src.vertices_end(); vit1++) {
vmap[vit1]->set_face(fmap[vit1->face()]); vmap[vit1]->set_face(fmap[vit1->face()]);
@ -2034,11 +2037,11 @@ copy_tds(const TDS_src& tds_src,
//update vertices and neighbor pointers //update vertices and neighbor pointers
fit1 = tds_src.faces().begin(); fit1 = tds_src.faces().begin();
for ( ; fit1 != tds_src.faces_end(); ++fit1) { for ( ; fit1 != tds_src.faces_end(); ++fit1) {
for (int j = 0; j < dim ; ++j) { for (int j = 0; j < dim ; ++j)
fmap[fit1]->set_vertex(j, vmap[fit1->vertex(j)] ); fmap[fit1]->set_vertex(j, vmap[fit1->vertex(j)] );
for (int j = 0; j < nn ; ++j)
fmap[fit1]->set_neighbor(j, fmap[fit1->neighbor(j)]); fmap[fit1]->set_neighbor(j, fmap[fit1->neighbor(j)]);
} }
}
// remove the post condition because it is false when copying the // remove the post condition because it is false when copying the
// TDS of a regular triangulation because of hidden vertices // TDS of a regular triangulation because of hidden vertices

2
TDS_2/include/CGAL/Triangulation_ds_face_base_2.h
View File

@ -240,7 +240,7 @@ Triangulation_ds_face_base_2<TDS> ::
set_neighbor(int i, Face_handle n) set_neighbor(int i, Face_handle n)
{ {
CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2); CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2);
CGAL_triangulation_precondition( this != &*n ); CGAL_triangulation_precondition( this != n.operator->() );
N[i] = n; N[i] = n;
} }

31
TDS_3/include/CGAL/Triangulation_data_structure_3.h
View File

@ -4041,32 +4041,27 @@ copy_tds(const TDS_src& tds,
|| tds.is_vertex(vert) ); || tds.is_vertex(vert) );
clear(); clear();
size_type n = tds.number_of_vertices();
set_dimension(tds.dimension()); set_dimension(tds.dimension());
if (n == 0) return Vertex_handle(); if(tds.number_of_vertices() == 0)
return Vertex_handle();
// Number of pointers to cell/vertex to copy per cell. // Number of pointers to cell/vertex to copy per cell.
int dim = (std::max)(1, dimension() + 1); const int dim = (std::max)(1, dimension() + 1);
// Create the vertices. // Number of neighbors to set
std::vector<typename TDS_src::Vertex_handle> TV(n); const int nn = (std::max)(0, dimension() + 1);
size_type i = 0;
for (typename TDS_src::Vertex_iterator vit = tds.vertices_begin();
vit != tds.vertices_end(); ++vit)
TV[i++] = vit;
CGAL_triangulation_assertion( i == n );
// Initializes maps
Unique_hash_map< typename TDS_src::Vertex_handle,Vertex_handle > V; Unique_hash_map< typename TDS_src::Vertex_handle,Vertex_handle > V;
Unique_hash_map< typename TDS_src::Cell_handle,Cell_handle > F; Unique_hash_map< typename TDS_src::Cell_handle,Cell_handle > F;
for (i=0; i <= n-1; ++i){ // Create the vertices.
Vertex_handle vh=create_vertex( convert_vertex(*TV[i]) ); for (typename TDS_src::Vertex_iterator vit = tds.vertices_begin();
V[ TV[i] ] = vh; vit != tds.vertices_end(); ++vit) {
convert_vertex(*TV[i],*vh); Vertex_handle vh = create_vertex( convert_vertex(*vit) );
V[vit] = vh;
convert_vertex(*vit,*vh);
} }
// Create the cells. // Create the cells.
@ -4087,7 +4082,7 @@ copy_tds(const TDS_src& tds,
// Hook neighbor pointers of the cells. // Hook neighbor pointers of the cells.
for (typename TDS_src::Cell_iterator cit2 = tds.cells().begin(); for (typename TDS_src::Cell_iterator cit2 = tds.cells().begin();
cit2 != tds.cells_end(); ++cit2) { cit2 != tds.cells_end(); ++cit2) {
for (int j = 0; j < dim; j++) for (int j = 0; j < nn; j++)
F[cit2]->set_neighbor(j, F[cit2->neighbor(j)] ); F[cit2]->set_neighbor(j, F[cit2->neighbor(j)] );
} }

0
Three/package_info/Three/copyright.txt → Three/package_info/Three/copyright
View File

1
Triangulation/package_info/Triangulation/copyright Normal file
View File

@ -0,0 +1 @@
INRIA Sophia-Antipolis (France)

17
Triangulation_2/test/Triangulation_2/include/CGAL/_test_cls_triangulation_2.h
View File

@ -132,9 +132,14 @@ _test_cls_triangulation_2( const Triangul & )
assert( T1.number_of_vertices() == 0 ); assert( T1.number_of_vertices() == 0 );
Triangul T3(T1); Triangul T3(T1);
Triangul T4 = T1; assert(T3.tds().vertices().size() == T1.tds().vertices().size());
T3.swap(T1); assert(T3.tds().faces().size() == T1.tds().faces().size());
Triangul T4 = T1;
assert(T4.tds().vertices().size() == T1.tds().vertices().size());
assert(T4.tds().faces().size() == T1.tds().faces().size());
T3.swap(T1);
/**************************/ /**************************/
/******* INSERTIONS *******/ /******* INSERTIONS *******/
@ -162,6 +167,10 @@ _test_cls_triangulation_2( const Triangul & )
assert( T0_1.number_of_faces() == 0); assert( T0_1.number_of_faces() == 0);
assert( T0_1.is_valid() ); assert( T0_1.is_valid() );
Triangul T0_1b(T0_1);
assert(T0_1b.tds().vertices().size() == T0_1.tds().vertices().size());
assert(T0_1b.tds().faces().size() == T0_1.tds().faces().size());
// test insert_first() // test insert_first()
Triangul T0_2; Triangul T0_2;
Vertex_handle v0_2_0 = T0_2.insert_first(p0); Vertex_handle v0_2_0 = T0_2.insert_first(p0);
@ -184,6 +193,10 @@ _test_cls_triangulation_2( const Triangul & )
assert( T1_2.number_of_faces() == 0 ); assert( T1_2.number_of_faces() == 0 );
assert( T1_2.is_valid() ); assert( T1_2.is_valid() );
Triangul T1_2b(T1_2);
assert(T1_2b.tds().vertices().size() == T1_2.tds().vertices().size());
assert(T1_2b.tds().faces().size() == T1_2.tds().faces().size());
// p1,p3,p2 [endpoints first] // p1,p3,p2 [endpoints first]
Triangul T1_3_0; Triangul T1_3_0;
Vertex_handle v1_3_0_1 = T1_3_0.insert(p1); assert( v1_3_0_1 != nullptr ); Vertex_handle v1_3_0_1 = T1_3_0.insert(p1); assert( v1_3_0_1 != nullptr );

28
Triangulation_3/test/Triangulation_3/include/CGAL/_test_cls_triangulation_3.h
View File

@ -190,7 +190,21 @@ _test_cls_triangulation_3(const Triangulation &)
//######################################################################## //########################################################################
/**************CONSTRUCTORS (1)*********************/ /************** CONSTRUCTORS (1)********************/
Cls Tm1;
assert( Tm1.dimension() == -1 );
assert( Tm1.number_of_vertices() == 0 );
Cls Tm3(Tm1);
assert(Tm3 == Tm1);
Cls Tm4 = Tm1;
assert(Tm4 == Tm1);
Tm3.swap(Tm1);
/************** INSERTIONS *************************/
/************** and I/O ****************************/ /************** and I/O ****************************/
std::cout << " Constructor " << std::endl; std::cout << " Constructor " << std::endl;
@ -214,6 +228,9 @@ _test_cls_triangulation_3(const Triangulation &)
assert(T0.number_of_vertices() == 1); assert(T0.number_of_vertices() == 1);
assert(T0.is_valid()); assert(T0.is_valid());
Cls T0d0(T0);
assert(T0 == T0d0);
if (! del) // to avoid doing the following tests for both Delaunay if (! del) // to avoid doing the following tests for both Delaunay
// and non Delaunay triangulations // and non Delaunay triangulations
{ {
@ -228,6 +245,9 @@ _test_cls_triangulation_3(const Triangulation &)
assert(T0.number_of_vertices() == 2); assert(T0.number_of_vertices() == 2);
assert(T0.is_valid()); assert(T0.is_valid());
Cls T0d1(T0);
assert(T0 == T0d1);
if (! del) // to avoid doing the following tests for both Delaunay if (! del) // to avoid doing the following tests for both Delaunay
// and non Delaunay triangulations // and non Delaunay triangulations
{ {
@ -242,6 +262,9 @@ _test_cls_triangulation_3(const Triangulation &)
assert(T0.number_of_vertices() == 3); assert(T0.number_of_vertices() == 3);
assert(T0.is_valid()); assert(T0.is_valid());
Cls T0d2(T0);
assert(T0 == T0d2);
if (! del) // to avoid doing the following tests for both Delaunay if (! del) // to avoid doing the following tests for both Delaunay
// and non Delaunay triangulations // and non Delaunay triangulations
{ {
@ -256,6 +279,9 @@ _test_cls_triangulation_3(const Triangulation &)
assert(T0.number_of_vertices() == 4); assert(T0.number_of_vertices() == 4);
assert(T0.is_valid()); assert(T0.is_valid());
Cls T0d3(T0);
assert(T0 == T0d3);
if (! del) // to avoid doing the following tests for both Delaunay if (! del) // to avoid doing the following tests for both Delaunay
// and non Delaunay triangulations // and non Delaunay triangulations
{ {

1
Voronoi_diagram_2/package_info/Voronoi_diagram_2/copyright Normal file
View File

@ -0,0 +1 @@
Foundation for Research and Technology-Hellas (Greece)

72
Weights/doc/Weights/PackageDescription.txt
View File

@ -19,7 +19,9 @@ Models and functions that can be used to compute weights which have a simple ana
\defgroup PkgWeightsRefUniformWeights Uniform Weight \defgroup PkgWeightsRefUniformWeights Uniform Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/uniform_weights.h>` \verbatim
#include <CGAL/Weights/uniform_weights.h>
\endverbatim
This weight is always equal to 1. This weight is always equal to 1.
@ -33,7 +35,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefShepardWeights Shepard Weight \defgroup PkgWeightsRefShepardWeights Shepard Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/shepard_weights.h>` \verbatim
#include <CGAL/Weights/shepard_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = \frac{1}{d^a}\f$ \f$w = \frac{1}{d^a}\f$
@ -61,7 +65,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefInverseDistanceWeights Inverse Distance Weight \defgroup PkgWeightsRefInverseDistanceWeights Inverse Distance Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/inverse_distance_weights.h>` \verbatim
#include <CGAL/Weights/inverse_distance_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = \frac{1}{d}\f$ \f$w = \frac{1}{d}\f$
@ -90,7 +96,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefThreePointFamilyWeights Three Point Family Weight \defgroup PkgWeightsRefThreePointFamilyWeights Three Point Family Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/three_point_family_weights.h>` \verbatim
#include <CGAL/Weights/three_point_family_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = \frac{d_2^a A_1 - d^a B + d_1^a A_2}{A_1 A_2}\f$ \f$w = \frac{d_2^a A_1 - d^a B + d_1^a A_2}{A_1 A_2}\f$
@ -129,7 +137,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefWachspressWeights Wachspress Weight \defgroup PkgWeightsRefWachspressWeights Wachspress Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/wachspress_weights.h>` \verbatim
#include <CGAL/Weights/wachspress_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = \frac{C}{A_1 A_2}\f$ \f$w = \frac{C}{A_1 A_2}\f$
@ -160,7 +170,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefAuthalicWeights Authalic Weight \defgroup PkgWeightsRefAuthalicWeights Authalic Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/authalic_weights.h>` \verbatim
#include <CGAL/Weights/authalic_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = 2 \frac{\cot\beta + \cot\gamma}{d^2}\f$ \f$w = 2 \frac{\cot\beta + \cot\gamma}{d^2}\f$
@ -190,7 +202,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefMeanValueWeights Mean Value Weight \defgroup PkgWeightsRefMeanValueWeights Mean Value Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/mean_value_weights.h>` \verbatim
#include <CGAL/Weights/mean_value_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = \pm 2 \sqrt{\frac{2 (d_1 d_2 - D)}{(d d_1 + D_1)(d d_2 + D_2)}}\f$ \f$w = \pm 2 \sqrt{\frac{2 (d_1 d_2 - D)}{(d d_1 + D_1)(d d_2 + D_2)}}\f$
@ -227,7 +241,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefTangentWeights Tangent Weight \defgroup PkgWeightsRefTangentWeights Tangent Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/tangent_weights.h>` \verbatim
#include <CGAL/Weights/tangent_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = 2 \frac{t_1 + t_2}{d}\f$, where \f$w = 2 \frac{t_1 + t_2}{d}\f$, where
@ -262,7 +278,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefDiscreteHarmonicWeights Discrete Harmonic Weight \defgroup PkgWeightsRefDiscreteHarmonicWeights Discrete Harmonic Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/discrete_harmonic_weights.h>` \verbatim
#include <CGAL/Weights/discrete_harmonic_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = \frac{d_2^2 A_1 - d^2 B + d_1^2 A_2}{A_1 A_2}\f$ \f$w = \frac{d_2^2 A_1 - d^2 B + d_1^2 A_2}{A_1 A_2}\f$
@ -293,7 +311,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefCotangentWeights Cotangent Weight \defgroup PkgWeightsRefCotangentWeights Cotangent Weight
\ingroup PkgWeightsRefAnalytic \ingroup PkgWeightsRefAnalytic
`#include <CGAL/Weights/cotangent_weights.h>` \verbatim
#include <CGAL/Weights/cotangent_weights.h>
\endverbatim
This weight is computed as This weight is computed as
\f$w = 2 (\cot\beta + \cot\gamma)\f$ \f$w = 2 (\cot\beta + \cot\gamma)\f$
@ -328,7 +348,9 @@ to polygons. These weights are then normalized in order to obtain barycentric co
\defgroup PkgWeightsRefBarycentricWachspressWeights Wachspress Weights \defgroup PkgWeightsRefBarycentricWachspressWeights Wachspress Weights
\ingroup PkgWeightsRefBarycentric \ingroup PkgWeightsRefBarycentric
`#include <CGAL/Weights/wachspress_weights.h>` \verbatim
#include <CGAL/Weights/wachspress_weights.h>
\endverbatim
Wachspress weights which can be computed for a query point with respect to the Wachspress weights which can be computed for a query point with respect to the
vertices of a strictly convex polygon. vertices of a strictly convex polygon.
@ -339,7 +361,9 @@ vertices of a strictly convex polygon.
\defgroup PkgWeightsRefBarycentricMeanValueWeights Mean Value Weights \defgroup PkgWeightsRefBarycentricMeanValueWeights Mean Value Weights
\ingroup PkgWeightsRefBarycentric \ingroup PkgWeightsRefBarycentric
`#include <CGAL/Weights/mean_value_weights.h>` \verbatim
#include <CGAL/Weights/mean_value_weights.h>
\endverbatim
Mean value weights which can be computed for a query point with respect to the Mean value weights which can be computed for a query point with respect to the
vertices of a simple polygon. vertices of a simple polygon.
@ -350,7 +374,9 @@ vertices of a simple polygon.
\defgroup PkgWeightsRefBarycentricDiscreteHarmonicWeights Discrete Harmonic Weights \defgroup PkgWeightsRefBarycentricDiscreteHarmonicWeights Discrete Harmonic Weights
\ingroup PkgWeightsRefBarycentric \ingroup PkgWeightsRefBarycentric
`#include <CGAL/Weights/discrete_harmonic_weights.h>` \verbatim
#include <CGAL/Weights/discrete_harmonic_weights.h>
\endverbatim
Discrete Harmonic weights which can be computed for a query point with respect to the Discrete Harmonic weights which can be computed for a query point with respect to the
vertices of a strictly convex polygon. vertices of a strictly convex polygon.
@ -368,7 +394,9 @@ used to balance other weights.
\defgroup PkgWeightsRefUniformRegionWeights Uniform Region Weight \defgroup PkgWeightsRefUniformRegionWeights Uniform Region Weight
\ingroup PkgWeightsRefRegions \ingroup PkgWeightsRefRegions
`#include <CGAL/Weights/uniform_region_weights.h>` \verbatim
#include <CGAL/Weights/uniform_region_weights.h>
\endverbatim
This weight is always equal to 1. This weight is always equal to 1.
@ -382,7 +410,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefTriangularRegionWeights Triangular Region Weight \defgroup PkgWeightsRefTriangularRegionWeights Triangular Region Weight
\ingroup PkgWeightsRefRegions \ingroup PkgWeightsRefRegions
`#include <CGAL/Weights/triangular_region_weights.h>` \verbatim
#include <CGAL/Weights/triangular_region_weights.h>
\endverbatim
This weight is the area of the shaded region in the figure below. The region is This weight is the area of the shaded region in the figure below. The region is
the triangle `[p, q, r]`. the triangle `[p, q, r]`.
@ -401,7 +431,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefBarycentricRegionWeights Barycentric Region Weight \defgroup PkgWeightsRefBarycentricRegionWeights Barycentric Region Weight
\ingroup PkgWeightsRefRegions \ingroup PkgWeightsRefRegions
`#include <CGAL/Weights/barycentric_region_weights.h>` \verbatim
#include <CGAL/Weights/barycentric_region_weights.h>
\endverbatim
This weight is the area of the shaded region in the figure below. The region This weight is the area of the shaded region in the figure below. The region
is formed by the two midpoints of the edges incident to `q` and the barycenter of is formed by the two midpoints of the edges incident to `q` and the barycenter of
@ -421,7 +453,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefVoronoiRegionWeights Voronoi Region Weight \defgroup PkgWeightsRefVoronoiRegionWeights Voronoi Region Weight
\ingroup PkgWeightsRefRegions \ingroup PkgWeightsRefRegions
`#include <CGAL/Weights/voronoi_region_weights.h>` \verbatim
#include <CGAL/Weights/voronoi_region_weights.h>
\endverbatim
This weight is the area of the shaded region in the figure below. The region This weight is the area of the shaded region in the figure below. The region
is formed by the two midpoints of the edges incident to `q` and the circumcenter of is formed by the two midpoints of the edges incident to `q` and the circumcenter of
@ -443,7 +477,9 @@ a model of `AnalyticWeightTraits_3` for 3D points
\defgroup PkgWeightsRefMixedVoronoiRegionWeights Mixed Voronoi Region Weight \defgroup PkgWeightsRefMixedVoronoiRegionWeights Mixed Voronoi Region Weight
\ingroup PkgWeightsRefRegions \ingroup PkgWeightsRefRegions
`#include <CGAL/Weights/mixed_voronoi_region_weights.h>` \verbatim
#include <CGAL/Weights/mixed_voronoi_region_weights.h>
\endverbatim
This weight is the area of the shaded region in the figure below. The region This weight is the area of the shaded region in the figure below. The region
is formed by the two midpoints of the edges incident to `q` and the circumcenter of is formed by the two midpoints of the edges incident to `q` and the circumcenter of