mirror of https://github.com/CGAL/cgal
392 lines
18 KiB
C++
392 lines
18 KiB
C++
#define CGAL_CAST_INT
|
|
#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>
|
|
|
|
#include <CGAL/Circular_kernel_2.h>
|
|
#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>
|
|
#include <CGAL/Arr_naive_point_location.h>
|
|
#include <CGAL/Variant_traits.h>
|
|
|
|
|
|
#include <CGAL/Random.h>
|
|
#include <fstream>
|
|
|
|
#include "benchmark.h"
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
char* Dxffilename[]={"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf","smallpainttrack.dxf","mask0_25.dxf","mask0_5.dxf","mask1.dxf","cad_l2.dxf","cad_l1.dxf"/*,"CIOnZDraw.dxf","che_mod1.dxf","elekonta.dxf","painttrack.dxf","netlist_signal_1.dxf","51.dxf"*/};
|
|
char* Htmlfilename;
|
|
char* Texfilename;
|
|
char exten[4];
|
|
int i;
|
|
i=0;
|
|
|
|
|
|
if (argv[1] != NULL)
|
|
{
|
|
int len =strlen(argv[1]);
|
|
for (int j=0; j < 3 ; j++)
|
|
{
|
|
exten[j]=argv[1][len - 3 + j];
|
|
}
|
|
if (strncmp(exten,"dxf",3) !=0)
|
|
{
|
|
std::cout<< "File is not correct (*.dxf is needed)." << std::endl;
|
|
return 0;
|
|
}
|
|
else{
|
|
Dxffilename[i] = argv[1];
|
|
std::cout<< "File "<< Dxffilename[i] << " is correct."<<std::endl;
|
|
}
|
|
if (argc >2 and argv[2] != NULL)
|
|
{
|
|
int len =strlen(argv[2]);
|
|
for (int j=0; j < 4 ; j++)
|
|
{
|
|
exten[j]=argv[2][len - 4 + j];
|
|
}
|
|
if (strncmp(exten,"html",4) !=0)
|
|
{
|
|
std::cout<< "File "<< argv[2] << " is not correct (*.html is needed)." << std::endl;
|
|
return 0;
|
|
}
|
|
else{
|
|
std::cout<< "File "<< argv[2] << " is correct." <<std::endl;
|
|
}
|
|
if (argv[3] != NULL)
|
|
{
|
|
int len =strlen(argv[3]);
|
|
for (int j=0; j < 3 ; j++)
|
|
{
|
|
exten[j]=argv[3][len - 3 + j];
|
|
}
|
|
if (strncmp(exten,"tex",3) !=0)
|
|
{
|
|
std::cout<< "File "<< argv[3] << " is not correct (*.tex is needed)."
|
|
<< std::endl;
|
|
return 0;
|
|
}
|
|
else{
|
|
std::cout<< "File "<< argv[3] << " is correct." <<std::endl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Texfilename="benchmarks.tex";
|
|
std::cout<< "Default *.tex file is :" << Texfilename<< std::endl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Htmlfilename="benchmarks.html";
|
|
Texfilename="benchmarks.tex";
|
|
std::cout<< "Default *.html file is :" << Htmlfilename<< std::endl;
|
|
std::cout<< "Default *.tex file is :" << Texfilename<< std::endl;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
Dxffilename[i]="myFirst.dxf";
|
|
//Dxffilename[i]="CIOnZDraw.dxf";
|
|
|
|
//Dxffilename[]={"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf"};
|
|
// Dxffilename[]={/*"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf","smallpainttrack.dxf","mask0_25.dxf","mask0_5.dxf","cad_l2.dxf","cad_l1.dxf",*/"CIOnZDraw.dxf","che_mod1.dxf","elekonta.dxf","painttrack.dxf","netlist_signal_1.dxf","51.dxf"};
|
|
Htmlfilename="benchmarks.html";
|
|
Texfilename="benchmarks.tex";
|
|
std::cout<< "Default *.dxf file is :" << Dxffilename[i]<< std::endl;
|
|
std::cout<< "Default *.html file is :" << Htmlfilename<< std::endl;
|
|
std::cout<< "Default *.tex file is :" << Texfilename<< std::endl;
|
|
}
|
|
|
|
|
|
|
|
|
|
Bench bench(Htmlfilename,Texfilename,Dxffilename[i],true);
|
|
|
|
for(i=0;i<15;i++){
|
|
|
|
std::ifstream fin;
|
|
fin.open (Dxffilename[i]);
|
|
if (!fin.is_open())
|
|
{
|
|
std::cout<<"file "<< Dxffilename[i] << " is not found"<<std::endl;
|
|
fin.close();
|
|
return 0;
|
|
|
|
}
|
|
fin.close();
|
|
/*-------------------------------------------------------------------------------------------------------------------------
|
|
!!!!!!!!!!!Circular_Kernel!!!!!!!!!!!!!!!!!!
|
|
|
|
-------------------------------------------------------------------------------------------------------------------------*/
|
|
|
|
typedef 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;
|
|
/*
|
|
#ifndef CGAL_CURVED_KERNEL_DEBUG
|
|
typedef CGAL::Circular_arc_traits<CircularKernel> CircularK_CA_Traits;
|
|
#else
|
|
typedef CGAL::Circular_arc_traits<CircularKernel> Traits0;
|
|
typedef CGAL::Circular_arc_traits_tracer<Traits0> CircularK_CA_Traits;
|
|
#endif
|
|
|
|
typedef CircularKernel::Circular_arc_2 CircularKArc;
|
|
typedef std::vector<CircularKArc> CircularKArcContainer;
|
|
bench.kernel("Circular kernel Circular arc traits");
|
|
|
|
bench.Compute_no_dxf<CircularKernel,CircularK_CA_Traits,CircularKArcContainer>();*/
|
|
|
|
|
|
typedef CircularKernel::Circular_arc_2 Circular_arc_2;
|
|
typedef CircularKernel::Line_arc_2 Line_arc_2;
|
|
typedef CGAL::Variant_traits<CircularKernel,Line_arc_2,Circular_arc_2> CircularK_Variant_Traits;
|
|
|
|
typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc;
|
|
typedef std::vector<CircularKVarArc> CircularKVarArcContainer;
|
|
|
|
bench.kernel("Circular kernel Variant traits");
|
|
|
|
// 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],""))
|
|
{
|
|
bench.newDxfFilename(Dxffilename[i+1]);
|
|
}
|
|
else
|
|
{
|
|
std::cout << "that's all" << Dxffilename[i+1] << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bench.infotable();
|
|
|
|
return 0;
|
|
}
|
|
|