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 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 LAZY_CURVED_KERNEL_2_FILTERED_BBOX
#define CGAL_CAST_INT
#include <CGAL/Cartesian.h>
@ -22,9 +18,7 @@
#include <CGAL/Circular_arc_traits.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>
@ -88,80 +82,7 @@ for(i=1;i<6;i++){
//bench.Compute_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>(Dxffilename[i]);
#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!!!!!!!!!!!!!!!!!!
@ -182,58 +103,7 @@ bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>()
// bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>();
#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());
if (i<5){
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;
};

6
Circular_kernel_2/benchmark/README_benchmark_CK2.txt
View File

@ -3,13 +3,9 @@ The usage is:
where alpha:
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
4: means to bench the Bbox(Lazy(CK)) with Vartraits
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
8: means to bench the Bbox(Lazy(CK)) Circulartraits
(le 0 est interne)
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
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_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/Arrangement_2.h>
@ -141,75 +137,13 @@ Bench bench(Htmlfilename,Texfilename,Dxffilename[i]);
}
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!!!!!!!!!!!!!!!!!!
-------------------------------------------------------------------------------------------------------------------------*/
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::Algebraic_kernel_for_circles_2_2<NT1> Algebraic_k1;
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_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 (strcmp(Dxffilename[i+1],""))
@ -460,4 +192,3 @@ bench.infotable();
return 0;
}

40
Circular_kernel_2/benchmark/benchmark_CK2.cpp
View File

@ -11,7 +11,6 @@
#include <CGAL/intersections.h>
#include <CGAL/Circular_kernel_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/Arrangement_2.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 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
typedef CGAL::Filtered_bbox_circular_kernel_2<CircularKernel>
@ -77,24 +61,6 @@ typedef std::vector<BBCircVarArc>
BBCircVarContainer;
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>
void do_main(const char *s) {
@ -243,9 +209,7 @@ int main(int argc, char* argv[]){
int j = argv[2][0]-'0';
if((j >= 0 && j < 9)) {
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 == 4) do_main<BBLazyKernel,BBLazyVariantTraits, BBLazyVarContainer>(dxf_filename[j]);
if((i >= 5) || (i <= 0)) std::cout << "INVALID PARAMETERS" << std::endl;
} else {
int k = -1;
@ -255,13 +219,9 @@ int main(int argc, char* argv[]){
if(j == ('c'-'0')) k = 3;
if(j == ('d'-'0')) k = 4;
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 == 4) do_main<BBLazyKernel,BBLazyVariantTraits, BBLazyVarContainer>(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 == 8) do_main<BBLazyKernel,BBLazyKernel_CA_Traits, BBLazyKernelArcContainer>(k);
}
} 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 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 LAZY_CURVED_KERNEL_2_FILTERED_BBOX
#include <CGAL/Cartesian.h>
#include <CGAL/Handle_for.h>
#include <CGAL/point_generators_2.h>
#include <CGAL/MP_Float.h>
#include <CGAL/Algebraic_kernel_for_circles_2_2.h>
#include <CGAL/intersections.h>
@ -21,11 +16,6 @@
#include <CGAL/Arr_circular_arc_traits_2.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>
@ -184,123 +174,7 @@ Bench bench; //If you want create table with all datasets
bench.Compute_no_dxf<CircularKernel,CircularK_Variant_Traits,CircularKVarArcContainer>();
#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!!!!!!!!!!!!!!!!!!
@ -333,105 +207,6 @@ bench.Compute_no_dxf<LazyKernelHexagon,HxLazyVariantTraits,HxLazyVarContainer>()
bench.Compute_no_dxf<BBCircularKernel,BBCircVariantTraits,BBCircVarContainer>();
#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;
}

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_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/Arrangement_2.h>
@ -225,4 +221,3 @@ int exit_status = 0;
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_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/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_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 (strcmp(Dxffilename[i+1],""))
@ -388,4 +184,3 @@ bench.infotable();
return 0;
}

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

@ -44,28 +44,20 @@ namespace CGAL {
namespace internal {
#ifdef CGAL_USE_GMP
typedef CGAL::Gmpq NT1;
typedef CGAL::Gmpq NT;
#else
typedef Quotient<MP_Float> NT1;
typedef Quotient<MP_Float> NT;
#endif
typedef Cartesian<NT1> Linear_k1;
typedef Algebraic_kernel_for_circles_2_2<NT1> Algebraic_k1;
typedef Circular_kernel_2<Linear_k1, Algebraic_k1> CK1;
// 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;
typedef Cartesian<NT> Linear_k;
typedef Algebraic_kernel_for_circles_2_2<NT> Algebraic_k;
typedef Circular_kernel_2<Linear_k, Algebraic_k> CK;
} // 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

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)
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_Filtered_bbox_circular_kernel.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;
}