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

Merge pull request #5735 from afabri/CK_2-cleanup-GF 

Circular_kernel_2: Cleanup
This commit is contained in:
Sebastien Loriot 2021-08-12 10:02:07 +02:00 committed by GitHub
parent 3404633d3e d11533c9e4
commit 763a1d16c9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 6 additions and 943 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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;
}