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

Continued

This commit is contained in:
Efi Fogel 2022-05-31 11:15:54 +03:00
parent 6e50ac3fce
commit ab52d337b7
4 changed files with 328 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Arrangement_on_surface_2/include/CGAL/Arr_conic_traits_2.h
View File

@ -2239,8 +2239,8 @@ public:
//check if the orientation conforms to the src and tgt. //check if the orientation conforms to the src and tgt.
if( (xcv.is_directed_right() && compare_x_2(src, tgt) == LARGER) || if( (xcv.is_directed_right() && compare_x_2(src, tgt) == LARGER) ||
(! xcv.is_directed_right() && compare_x_2(src, tgt) == SMALLER) ) (! xcv.is_directed_right() && compare_x_2(src, tgt) == SMALLER) )
return (trim(xcv, tgt, src)); return trim(xcv, tgt, src);
else return (trim(xcv, src, tgt)); else return trim(xcv, src, tgt);
} }
private: private:
@ -2258,34 +2258,35 @@ public:
CGAL_precondition(xcv.contains_point(ps) && xcv.contains_point(pt)); CGAL_precondition(xcv.contains_point(ps) && xcv.contains_point(pt));
// Make sure that the endpoints conform with the direction of the arc. // Make sure that the endpoints conform with the direction of the arc.
X_monotone_curve_2 res_xcv = xcv;
auto cmp_xy = m_traits.m_alg_kernel->compare_xy_2_object(); auto cmp_xy = m_traits.m_alg_kernel->compare_xy_2_object();
if (! ((xcv.test_flag(X_monotone_curve_2::IS_DIRECTED_RIGHT) && if (! ((xcv.test_flag(X_monotone_curve_2::IS_DIRECTED_RIGHT) &&
(cmp_xy()(ps, pt) == SMALLER)) || (cmp_xy(ps, pt) == SMALLER)) ||
(xcv.test_flag(X_monotone_curve_2::IS_DIRECTED_RIGHT) && (xcv.test_flag(X_monotone_curve_2::IS_DIRECTED_RIGHT) &&
(cmp_xy(ps, pt) == LARGER)))) (cmp_xy(ps, pt) == LARGER))))
{ {
// We are allowed to change the direction only in case of a segment. // We are allowed to change the direction only in case of a segment.
CGAL_assertion(xcv.orientation() == COLLINEAR); CGAL_assertion(xcv.orientation() == COLLINEAR);
xcv.flip_flag(X_monotone_curve_2::IS_DIRECTED_RIGHT); res_xcv.flip_flag(X_monotone_curve_2::IS_DIRECTED_RIGHT);
} }
// Make a copy of the current arc and assign its endpoints. // Make a copy of the current arc and assign its endpoints.
auto eq = m_traits.m_alg_kernel->equal_2_object()(); auto eq = m_traits.m_alg_kernel->equal_2_object();
if (! eq(ps, xcv.source())) { if (! eq(ps, xcv.source())) {
xcv.set_source(ps); res_xcv.set_source(ps);
if (! ps.is_generating_conic(xcv.id())) if (! ps.is_generating_conic(xcv.id()))
xcv.m_source.set_generating_conic(xcv.id()); res_xcv.source().set_generating_conic(xcv.id());
} }
if (! eq(pt, xcv.target())) { if (! eq(pt, xcv.target())) {
xcv.set_target(pt); res_xcv.set_target(pt);
if (! pt.is_generating_conic(xcv.id())) if (! pt.is_generating_conic(xcv.id()))
xcv.m_target.set_generating_conic(xcv.id()); res_xcv.target().set_generating_conic(xcv.id());
} }
return xcv; return res_xcv;
} }
}; };

51
Arrangement_on_surface_2/test/Arrangement_on_surface_2/IO_base_test.h
View File

@ -293,8 +293,7 @@ bool read_general_conic(InputStream_& is, typename Traits::Curve_2& cv,
/*! */ /*! */
template <typename InputStream_, typename Traits> template <typename InputStream_, typename Traits>
bool read_general_curve(InputStream_& is, typename Traits::Curve_2& cv, bool read_general_curve(InputStream_& is, typename Traits::Curve_2& cv,
const Traits& traits) const Traits& traits) {
{
Rational r, s, t, u, v, w; // The conic coefficients. Rational r, s, t, u, v, w; // The conic coefficients.
// Read a general conic, given by its coefficients <r,s,t,u,v,w>. // Read a general conic, given by its coefficients <r,s,t,u,v,w>.
is >> r >> s >> t >> u >> v >> w; is >> r >> s >> t >> u >> v >> w;
@ -313,8 +312,7 @@ bool read_general_curve(InputStream_& is, typename Traits::Curve_2& cv,
template <> template <>
template <typename InputStream_> template <typename InputStream_>
bool IO_base_test<Base_geom_traits>::read_xcurve(InputStream_& is, bool IO_base_test<Base_geom_traits>::read_xcurve(InputStream_& is,
X_monotone_curve_2& xcv) X_monotone_curve_2& xcv) {
{
// since we are dealing with polycurve, we will make more than 1 conic curves // since we are dealing with polycurve, we will make more than 1 conic curves
// (polycurve compatible) and return the x-monotone-constructed polycurve. // (polycurve compatible) and return the x-monotone-constructed polycurve.
@ -329,26 +327,24 @@ bool IO_base_test<Base_geom_traits>::read_xcurve(InputStream_& is,
is >> type; is >> type;
//get number of x-monotone conic-arcs. //get number of x-monotone conic-arcs.
unsigned int number_of_curves; size_t number_of_curves;
is >> number_of_curves; is >> number_of_curves;
ctr_xcv = m_geom_traits.construct_x_monotone_curve_2_object(); const auto& sub_traits = *(m_geom_traits.subcurve_traits_2());
auto ctr_xcv = sub_traits.construct_x_monotone_curve_2_object();
for (unsigned int i=0; i<number_of_curves; ++i) { for (unsigned int i=0; i<number_of_curves; ++i) {
if ((type == 'a') || (type == 'A')) { if ((type == 'a') || (type == 'A')) {
if (! read_general_curve(is, tmp_cv, m_geom_traits)) return false; if (! read_general_curve(is, tmp_cv, sub_traits)) return false;
X_monotone_subcurve_2 tmp_xcv = ctr_xcv(tmp_cv); conic_x_monotone_segments.push_back(ctr_xcv(tmp_cv));
conic_x_monotone_segments.push_back(tmp_xcv);
} }
else if ((type == 'c') || (type == 'C')) { else if ((type == 'c') || (type == 'C')) {
if (! read_general_conic(is, tmp_cv, m_geom_traits)) return false; if (! read_general_conic(is, tmp_cv, sub_traits)) return false;
X_monotone_subcurve_2 tmp_xcv = ctr_xcv(tmp_cv); conic_x_monotone_segments.push_back(ctr_xcv(tmp_cv));
conic_x_monotone_segments.push_back(tmp_xcv);
} }
else if ((type == 'i') || (type == 'I')) { else if ((type == 'i') || (type == 'I')) {
if (! read_general_arc(is, tmp_cv, m_geom_traits)) return false; if (! read_general_arc(is, tmp_cv, sub_traits)) return false;
X_monotone_subcurve_2 tmp_xcv = ctr_xcv(tmp_cv); conic_x_monotone_segments.push_back(ctr_xcv(tmp_cv));
conic_x_monotone_segments.push_back(tmp_xcv);
} }
else { else {
std::cerr << "Illegal conic type specification: " << type << "." std::cerr << "Illegal conic type specification: " << type << "."
@ -368,8 +364,7 @@ bool IO_base_test<Base_geom_traits>::read_xcurve(InputStream_& is,
/*! Read a conic poly-curve */ /*! Read a conic poly-curve */
template <> template <>
template <typename InputStream_> template <typename InputStream_>
bool IO_base_test<Base_geom_traits>::read_curve(InputStream_& is, Curve_2& cv) bool IO_base_test<Base_geom_traits>::read_curve(InputStream_& is, Curve_2& cv) {
{
// since we are dealing with polycurve, we will make more than 1 conic curves // since we are dealing with polycurve, we will make more than 1 conic curves
// (polycurve compatible) and return the constructed polycurve. // (polycurve compatible) and return the constructed polycurve.
@ -383,20 +378,21 @@ bool IO_base_test<Base_geom_traits>::read_curve(InputStream_& is, Curve_2& cv)
is >> type; is >> type;
//get number of xmonotone-conic arcs. //get number of xmonotone-conic arcs.
unsigned int number_of_curves; size_t number_of_curves;
is >> number_of_curves; is >> number_of_curves;
const auto& sub_traits = *(m_geom_traits.subcurve_traits_2());
for (unsigned int i = 0; i < number_of_curves; ++i) { for (unsigned int i = 0; i < number_of_curves; ++i) {
if ((type == 'a') || (type == 'A')) { if ((type == 'a') || (type == 'A')) {
if (! read_general_curve(is, tmp_cv, m_geom_traits)) return false; if (! read_general_curve(is, tmp_cv, sub_traits)) return false;
conic_segments.push_back(tmp_cv); conic_segments.push_back(tmp_cv);
} }
else if ((type == 'c') || (type == 'C')) { else if ((type == 'c') || (type == 'C')) {
if (! read_general_conic(is, tmp_cv, m_geom_traits)) return false; if (! read_general_conic(is, tmp_cv, sub_traits)) return false;
conic_segments.push_back(tmp_cv); conic_segments.push_back(tmp_cv);
} }
else if ((type == 'i') || (type == 'I')) { else if ((type == 'i') || (type == 'I')) {
if (! read_general_arc(is, tmp_cv, m_geom_traits)) return false; if (! read_general_arc(is, tmp_cv, sub_traits)) return false;
conic_segments.push_back(tmp_cv); conic_segments.push_back(tmp_cv);
} }
@ -429,12 +425,11 @@ template <typename InputStream_>
bool IO_base_test<Base_geom_traits>::read_segment(InputStream_& is, bool IO_base_test<Base_geom_traits>::read_segment(InputStream_& is,
Subcurve_2& seg) Subcurve_2& seg)
{ {
Subcurve_2 tmp_seg;
char type; char type;
is >> type; is >> type;
if (!read_general_curve(is, tmp_seg)) return false; const auto& sub_traits = *(m_geom_traits.subcurve_traits_2());
seg = tmp_seg; if (! read_general_curve(is, seg, sub_traits)) return false;
return true; return true;
} }
template <> template <>
@ -445,8 +440,10 @@ bool IO_base_test<Base_geom_traits>::read_xsegment(InputStream_& is,
char type; char type;
is >> type; is >> type;
Subcurve_2 tmp_seg; Subcurve_2 tmp_seg;
if (!read_general_curve(is, tmp_seg)) return false; const auto& sub_traits = *(m_geom_traits.subcurve_traits_2());
xseg = X_monotone_subcurve_2(tmp_seg); if (! read_general_curve(is, tmp_seg, sub_traits)) return false;
auto ctr_xcv = sub_traits.construct_x_monotone_curve_2_object();
xseg = ctr_xcv(tmp_seg);
return true; return true;
} }

494
Arrangement_on_surface_2/test/Arrangement_on_surface_2/test_conic_polycurve.cpp
View File

@ -51,43 +51,41 @@ typedef Polycurve_conic_traits_2::Point_2 Pc_point_2;
// CGAL::CORE_algebraic_number_traits> // CGAL::CORE_algebraic_number_traits>
// >::Point_2 test_point_2; // >::Point_2 test_point_2;
void check_equal() void check_equal() {
{
bool are_equal; bool are_equal;
Polycurve_conic_traits_2 traits; Conic_traits_2 sub_traits;
Polycurve_conic_traits_2::Equal_2 equal = traits.equal_2_object(); Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto equal = traits.equal_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
auto ctr_sub_cv = sub_traits.construct_curve_2_object();
//create some curves //create some curves
Conic_point_2 ps1(Rational(1,4), 4); Conic_point_2 ps1(Rational(1,4), 4);
Conic_point_2 pt1(2, Rational(1,2)); Conic_point_2 pt1(2, Rational(1,2));
Conic_curve_2 c1(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps1, pt1); Conic_curve_2 c1 =
ctr_sub_cv(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps1, pt1);
Conic_point_2 ps2(Rational(1,4), 4); Conic_point_2 ps2(Rational(1,4), 4);
Conic_point_2 pt2(2, Rational(1,2)); Conic_point_2 pt2(2, Rational(1,2));
Conic_curve_2 c2(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps2, pt2); Conic_curve_2 c2 =
ctr_sub_cv(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps2, pt2);
Rat_point_2 ps3(Rational(1,4), 4); Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2); Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3)); Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3); Conic_curve_2 c3 = ctr_sub_cv(ps3, pmid3, pt3);
Rat_point_2 ps4(1, 5); Rat_point_2 ps4(1, 5);
Rat_point_2 pmid4(Rational(3,2), 3); Rat_point_2 pmid4(Rational(3,2), 3);
Rat_point_2 pt4(3, Rational(1,3)); Rat_point_2 pt4(3, Rational(1,3));
Conic_curve_2 c4(ps4, pmid4, pt4); Conic_curve_2 c4 = ctr_sub_cv(ps4, pmid4, pt4);
// //make x_monotone // //make x_monotone
Polycurve_conic_traits_2::X_monotone_curve_2 xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1); Polycurve_conic_traits_2::X_monotone_curve_2 xmc2 = ctr_xcv(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc2 = Polycurve_conic_traits_2::X_monotone_curve_2 xmc3 = ctr_xcv(c3);
construct_x_monotone_curve_2(c2); Polycurve_conic_traits_2::X_monotone_curve_2 xmc4 = ctr_xcv(c4);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc3 =
construct_x_monotone_curve_2(c3);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc4 =
construct_x_monotone_curve_2(c4);
are_equal = equal(xmc1, xmc2); are_equal = equal(xmc1, xmc2);
std::cout << "Two equal conic arcs are computed as: " std::cout << "Two equal conic arcs are computed as: "
@ -105,8 +103,7 @@ void check_equal()
template <typename Traits> template <typename Traits>
void check_intersect(typename Traits::X_monotone_curve_2& xcv1, void check_intersect(typename Traits::X_monotone_curve_2& xcv1,
typename Traits::X_monotone_curve_2& xcv2, typename Traits::X_monotone_curve_2& xcv2,
const Traits& traits) const Traits& traits) {
{
typedef typename Traits::Multiplicity Multiplicity; typedef typename Traits::Multiplicity Multiplicity;
typedef typename Traits::Point_2 Point_2; typedef typename Traits::Point_2 Point_2;
typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2;
@ -115,8 +112,8 @@ void check_equal()
Intersection_result; Intersection_result;
std::vector<Intersection_result> intersection_points; std::vector<Intersection_result> intersection_points;
traits.intersect_2_object()(xcv1, xcv2, auto intersect = traits.intersect_2_object();
std::back_inserter(intersection_points)); intersect(xcv1, xcv2, std::back_inserter(intersection_points));
std::cout<< "Number of intersection Points: " << intersection_points.size() std::cout<< "Number of intersection Points: " << intersection_points.size()
<< std::endl; << std::endl;
@ -134,13 +131,12 @@ void check_equal()
// } // }
} }
void check_compare_end_points_xy_2() void check_compare_end_points_xy_2() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto cmp_endpoints = traits.compare_endpoints_xy_2_object();
Polycurve_conic_traits_2::Compare_endpoints_xy_2 compare_endpoints_xy_2 = auto ctr_sub_cv = sub_traits.construct_curve_2_object();
traits.compare_endpoints_xy_2_object();
//create some curves //create some curves
Conic_point_2 ps1(Rational(1,4), 4); Conic_point_2 ps1(Rational(1,4), 4);
@ -154,69 +150,69 @@ void check_compare_end_points_xy_2()
// as the intersections of the parabola with the lines y = -3 and y = -2. // as the intersections of the parabola with the lines y = -3 and y = -2.
// Note that the arc is clockwise oriented. // Note that the arc is clockwise oriented.
Conic_curve_2 Conic_curve_2
c2 = Conic_curve_2(1, 0, 0, 0, 1, 0, // The parabola. c2 = ctr_sub_cv(1, 0, 0, 0, 1, 0, // The parabola.
CGAL::CLOCKWISE, CGAL::CLOCKWISE,
Conic_point_2(-1.73, -3), // Approximation of the source. Conic_point_2(-1.73, -3), // Approximation of the source.
0, 0, 0, 0, 1, 3, // The line: y = -3. 0, 0, 0, 0, 1, 3, // The line: y = -3.
Conic_point_2(1.41, -2), // Approximation of the target. Conic_point_2(1.41, -2), // Approximation of the target.
0, 0, 0, 0, 1, 2); // The line: y = -2. 0, 0, 0, 0, 1, 2); // The line: y = -2.
assert(c2.is_valid()); assert(c2.is_valid());
//make polyline x-monotone curves //make polyline x-monotone curves
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1); Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 = ctr_xcv(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
CGAL::Comparison_result res = compare_endpoints_xy_2(polyline_xmc1); CGAL::Comparison_result res = cmp_endpoints(polyline_xmc1);
std::cout << "compare_end_points_xy_2 for counterclockwise curve: " std::cout << "compare_end_points_xy_2 for counterclockwise curve: "
<< (res == CGAL::SMALLER ? "SMALLER": << (res == CGAL::SMALLER ? "SMALLER":
(res == CGAL::LARGER ? "LARGER" : "EQUAL")) << std::endl; (res == CGAL::LARGER ? "LARGER" : "EQUAL")) << std::endl;
res = compare_endpoints_xy_2(polyline_xmc2); res = cmp_endpoints(polyline_xmc2);
std::cout<< "compare_end_points_xy_2 for clockwise curve: " std::cout<< "compare_end_points_xy_2 for clockwise curve: "
<< (res == CGAL::SMALLER ? "SMALLER": << (res == CGAL::SMALLER ? "SMALLER":
(res == CGAL::LARGER ? "LARGER" : "EQUAL")) << std::endl; (res == CGAL::LARGER ? "LARGER" : "EQUAL")) << std::endl;
} }
template <typename Curve_type> template <typename Curve_type>
void check_split(Curve_type &xcv1, Curve_type &xcv2) void check_split(Curve_type& xcv1, Curve_type& xcv2) {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
auto ctr_sub_cv = sub_traits.construct_curve_2_object();
auto ctr_sub_xcv = sub_traits.construct_x_monotone_curve_2_object();
//split x poly-curves //split x poly-curves
Conic_curve_2 c6(1,1,0,6,-26,162,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c6 = ctr_sub_cv(1,1,0,6,-26,162,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(-7), Algebraic(13)), Conic_point_2(Algebraic(-7), Algebraic(13)),
Conic_point_2(Algebraic(-3), Algebraic(9))); Conic_point_2(Algebraic(-3), Algebraic(9)));
Conic_curve_2 c7(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c7 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(-3), Algebraic(9)), Conic_point_2(Algebraic(-3), Algebraic(9)),
Conic_point_2(Algebraic(0), Algebraic(0))); Conic_point_2(Algebraic(0), Algebraic(0)));
Conic_curve_2 c8(0,1,0,-1,0,0, CGAL::COUNTERCLOCKWISE, Conic_curve_2 c8 = ctr_sub_cv(0,1,0,-1,0,0, CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)), Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(4), Algebraic(-2))); Conic_point_2(Algebraic(4), Algebraic(-2)));
Conic_x_monotone_curve_2 xc6(c6); Conic_x_monotone_curve_2 xc6 = ctr_sub_xcv(c6);
Conic_x_monotone_curve_2 xc7(c7); Conic_x_monotone_curve_2 xc7 = ctr_sub_xcv(c7);
Conic_x_monotone_curve_2 xc8(c8); Conic_x_monotone_curve_2 xc8 = ctr_sub_xcv(c8);
std::vector<Conic_x_monotone_curve_2> xmono_conic_curves_2; std::vector<Conic_x_monotone_curve_2> xmono_conic_curves_2;
auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
xmono_conic_curves_2.push_back(xc6); xmono_conic_curves_2.push_back(xc6);
xmono_conic_curves_2.push_back(xc7); xmono_conic_curves_2.push_back(xc7);
Pc_x_monotone_curve_2 split_expected_1 = Pc_x_monotone_curve_2 split_expected_1 =
traits.construct_x_monotone_curve_2_object()(xmono_conic_curves_2.begin(), ctr_xcv(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
xmono_conic_curves_2.end());
xmono_conic_curves_2.clear(); xmono_conic_curves_2.clear();
xmono_conic_curves_2.push_back(xc8); xmono_conic_curves_2.push_back(xc8);
Pc_x_monotone_curve_2 split_expected_2 = Pc_x_monotone_curve_2 split_expected_2 =
traits.construct_x_monotone_curve_2_object()(xmono_conic_curves_2.begin(), ctr_xcv(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
xmono_conic_curves_2.end());
Polycurve_conic_traits_2::X_monotone_curve_2 split_curve_1, split_curve_2; Polycurve_conic_traits_2::X_monotone_curve_2 split_curve_1, split_curve_2;
Polycurve_conic_traits_2::Point_2 Polycurve_conic_traits_2::Point_2 point_of_split =
point_of_split = Polycurve_conic_traits_2::Point_2(0,0); Polycurve_conic_traits_2::Point_2(0,0);
//Split functor //Split functor
traits.split_2_object()(xcv2, point_of_split, split_curve_1, split_curve_2); traits.split_2_object()(xcv2, point_of_split, split_curve_1, split_curve_2);
@ -230,23 +226,21 @@ void check_split(Curve_type &xcv1, Curve_type &xcv2)
std::cout << "Something is wrong with split" << std::endl; std::cout << "Something is wrong with split" << std::endl;
} }
void check_is_vertical() void check_is_vertical() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_sub_cv = sub_traits.construct_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Is_vertical_2 is_vertical = auto is_vertical = traits.is_vertical_2_object();
traits.is_vertical_2_object();
//create a curve //create a curve
Rat_point_2 ps1(1, 10); Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4); Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1); Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1); Conic_curve_2 c1 = ctr_sub_cv(ps1, pmid1, pt1);
//make x-monotone curve //make x-monotone curve
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1);
bool result = is_vertical(polyline_xmc1); bool result = is_vertical(polyline_xmc1);
std::cout << "Is_verticle:: Expected first result is not vertivle: Computed: " std::cout << "Is_verticle:: Expected first result is not vertivle: Computed: "
@ -255,8 +249,7 @@ void check_is_vertical()
/*! */ /*! */
template <typename stream> template <typename stream>
bool read_orientation(stream& is, CGAL::Orientation& orient) bool read_orientation(stream& is, CGAL::Orientation& orient) {
{
int i_orient; int i_orient;
is >> i_orient; is >> i_orient;
orient = (i_orient > 0) ? CGAL::COUNTERCLOCKWISE : orient = (i_orient > 0) ? CGAL::COUNTERCLOCKWISE :
@ -266,8 +259,7 @@ bool read_orientation(stream& is, CGAL::Orientation& orient)
/*! */ /*! */
template <typename stream> template <typename stream>
bool read_app_point(stream& is, Conic_point_2& p) bool read_app_point(stream& is, Conic_point_2& p) {
{
//waqar: original //waqar: original
double x, y; double x, y;
is >> x >> y; is >> x >> y;
@ -291,18 +283,18 @@ bool read_orientation_and_end_points(stream& is, CGAL::Orientation& orient,
Conic_point_2& target) Conic_point_2& target)
{ {
// Read the orientation. // Read the orientation.
if (!read_orientation(is, orient)) return false; if (! read_orientation(is, orient)) return false;
// Read the end points of the arc and create it. // Read the end points of the arc and create it.
if (!read_app_point(is, source)) return false; if (! read_app_point(is, source)) return false;
if (!read_app_point(is, target)) return false; if (! read_app_point(is, target)) return false;
return true; return true;
} }
/*! */ /*! */
template <typename stream, typename Curve> template <typename stream, typename Traits>
bool read_general_arc(stream& is, Curve& cv) bool read_general_arc(stream& is, typename Traits::Curve_2& cv,
{ const Traits& traits) {
// Read a general conic, given by its coefficients <r,s,t,u,v,w>. // Read a general conic, given by its coefficients <r,s,t,u,v,w>.
Rational r, s, t, u, v, w; // The conic coefficients. Rational r, s, t, u, v, w; // The conic coefficients.
is >> r >> s >> t >> u >> v >> w; is >> r >> s >> t >> u >> v >> w;
@ -316,7 +308,7 @@ bool read_general_arc(stream& is, Curve& cv)
// <r_1,s_1,t_1,u_1,v_1,w_1> whose intersection with <r,s,t,u,v,w> // <r_1,s_1,t_1,u_1,v_1,w_1> whose intersection with <r,s,t,u,v,w>
// defines the source. // defines the source.
Conic_point_2 app_source; Conic_point_2 app_source;
if (!read_app_point(is, app_source)) return false; if (! read_app_point(is, app_source)) return false;
Rational r1, s1, t1, u1, v1, w1; Rational r1, s1, t1, u1, v1, w1;
is >> r1 >> s1 >> t1 >> u1 >> v1 >> w1; is >> r1 >> s1 >> t1 >> u1 >> v1 >> w1;
@ -324,7 +316,7 @@ bool read_general_arc(stream& is, Curve& cv)
// <r_2,s_2,t_2,u_2,v_2,w_2> whose intersection with <r,s,t,u,v,w> // <r_2,s_2,t_2,u_2,v_2,w_2> whose intersection with <r,s,t,u,v,w>
// defines the target. // defines the target.
Conic_point_2 app_target; Conic_point_2 app_target;
if (!read_app_point(is, app_target)) return false; if (! read_app_point(is, app_target)) return false;
Rational r2, s2, t2, u2, v2, w2; Rational r2, s2, t2, u2, v2, w2;
is >> r2 >> s2 >> t2 >> u2 >> v2 >> w2; is >> r2 >> s2 >> t2 >> u2 >> v2 >> w2;
@ -334,34 +326,36 @@ bool read_general_arc(stream& is, Curve& cv)
<< r2 << s2 << t2 << u2 << v2 << w2 << std::endl; << r2 << s2 << t2 << u2 << v2 << w2 << std::endl;
// Create the conic arc. // Create the conic arc.
cv = Curve(r, s, t, u, v, w, orient, auto ctr_cv = traits.construct_curve_2_object();
app_source, r1, s1, t1, u1, v1, w1, cv = ctr_cv(r, s, t, u, v, w, orient,
app_target, r2, s2, t2, u2, v2, w2); app_source, r1, s1, t1, u1, v1, w1,
app_target, r2, s2, t2, u2, v2, w2);
return true; return true;
} }
/*! */ /*! */
template <typename stream, typename Curve> template <typename stream, typename Traits>
bool read_general_conic(stream& is, Curve& cv) bool read_general_conic(stream& is, typename Traits::Curve_2& cv,
{ const Traits& traits) {
// Read a general conic, given by its coefficients <r,s,t,u,v,w>. // Read a general conic, given by its coefficients <r,s,t,u,v,w>.
Rational r, s, t, u, v, w; Rational r, s, t, u, v, w;
is >> r >> s >> t >> u >> v >> w; is >> r >> s >> t >> u >> v >> w;
// Create a full conic (should work only for ellipses). // Create a full conic (should work only for ellipses).
cv = Curve(r, s, t, u, v, w); auto ctr_cv = traits.construct_curve_2_object();
cv = ctr_cv(r, s, t, u, v, w);
return true; return true;
} }
// /*! */ // /*! */
template <typename stream, typename Curve> template <typename stream, typename Traits>
bool read_general_curve(stream& is, Curve& cv) bool read_general_curve(stream& is, typename Traits::Curve_2& cv,
{ const Traits& traits) {
Rational r, s, t, u, v, w; // The conic coefficients. Rational r, s, t, u, v, w; // The conic coefficients.
// Read a general conic, given by its coefficients <r,s,t,u,v,w>. // Read a general conic, given by its coefficients <r,s,t,u,v,w>.
is >> r >> s >> t >> u >> v >> w; is >> r >> s >> t >> u >> v >> w;
CGAL::Orientation orient; CGAL::Orientation orient;
Conic_point_2 source, target; Conic_point_2 source, target;
if (!read_orientation_and_end_points(is, orient, source, target)) if (! read_orientation_and_end_points(is, orient, source, target))
return false; return false;
// Create the conic (or circular) arc. // Create the conic (or circular) arc.
@ -369,26 +363,25 @@ bool read_general_curve(stream& is, Curve& cv)
// << u << " " << v << " " << w << std::endl; // << u << " " << v << " " << w << std::endl;
// std::cout << "Read Points : " << source.x() << " " << source.y() << " " // std::cout << "Read Points : " << source.x() << " " << source.y() << " "
// << target.x() << " " << target.y() << std::endl; // << target.x() << " " << target.y() << std::endl;
cv = Curve(r, s, t, u, v, w, orient, source, target); auto ctr_cv = traits.construct_curve_2_object();
cv = ctr_cv(r, s, t, u, v, w, orient, source, target);
return true; return true;
} }
std::istream& skip_comments(std::istream& is, std::string& line) std::istream& skip_comments(std::istream& is, std::string& line) {
{
while (std::getline(is, line)) while (std::getline(is, line))
if (!line.empty() && (line[0] != '#')) break; if (!line.empty() && (line[0] != '#')) break;
return is; return is;
} }
bool check_compare_y_at_x_2() bool check_compare_y_at_x_2() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Compare_y_at_x_2 cmp_y_at_x_2 = auto ctr_sub_cv = sub_traits.construct_curve_2_object();
traits.compare_y_at_x_2_object(); auto ctr_sub_xcv = sub_traits.construct_x_monotone_curve_2_object();
auto cmp_y_at_x_2 = traits.compare_y_at_x_2_object();
//polycurve constructors //polycurve constructors
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto construct_x_mono_polycurve = traits.construct_x_monotone_curve_2_object();
construct_x_mono_polycurve = traits.construct_x_monotone_curve_2_object(); auto ctr_cv = traits.construct_curve_2_object();
Polycurve_conic_traits_2::Construct_curve_2 construct_polycurve =
traits.construct_curve_2_object();
//create a curve //create a curve
Rat_point_2 ps1(1, 10); Rat_point_2 ps1(1, 10);
@ -400,14 +393,14 @@ bool check_compare_y_at_x_2()
Rat_point_2 ps2(10, 1); Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 5); Rat_point_2 pmid2(15, 5);
Rat_point_2 pt2(20, 10); Rat_point_2 pt2(20, 10);
Conic_curve_2 c2(ps2, pmid2, pt2); Conic_curve_2 c2 = ctr_sub_cv(ps2, pmid2, pt2);
Conic_curve_2 c3(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c3 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)), Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(3), Algebraic(9))); Conic_point_2(Algebraic(3), Algebraic(9)));
Conic_curve_2 c4(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c4 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(3), Algebraic(9)), Conic_point_2(Algebraic(3), Algebraic(9)),
Conic_point_2(Algebraic(5), Algebraic(25))); Conic_point_2(Algebraic(5), Algebraic(25)));
std::vector<Conic_curve_2> conic_curves, conic_curves_2, Conic_curves_3; std::vector<Conic_curve_2> conic_curves, conic_curves_2, Conic_curves_3;
conic_curves.push_back(c1); conic_curves.push_back(c1);
@ -416,10 +409,10 @@ bool check_compare_y_at_x_2()
//conic_curves_2.push_back(c3); //conic_curves_2.push_back(c3);
//conic_curves_2.push_back(c4); //conic_curves_2.push_back(c4);
Conic_x_monotone_curve_2 xc1(c1); Conic_x_monotone_curve_2 xc1 = ctr_sub_xcv(c1);
Conic_x_monotone_curve_2 xc2(c2); Conic_x_monotone_curve_2 xc2 = ctr_sub_xcv(c2);
Conic_x_monotone_curve_2 xc3(c3); Conic_x_monotone_curve_2 xc3 = ctr_sub_xcv(c3);
Conic_x_monotone_curve_2 xc4(c4); Conic_x_monotone_curve_2 xc4 = ctr_sub_xcv(c4);
std::vector<Conic_x_monotone_curve_2> xmono_conic_curves, xmono_conic_curves_2; std::vector<Conic_x_monotone_curve_2> xmono_conic_curves, xmono_conic_curves_2;
/* VERY IMPORTANT /* VERY IMPORTANT
@ -442,13 +435,13 @@ bool check_compare_y_at_x_2()
//construct poly-curve //construct poly-curve
Polycurve_conic_traits_2::Curve_2 conic_polycurve = Polycurve_conic_traits_2::Curve_2 conic_polycurve =
construct_polycurve(conic_curves.begin(), conic_curves.end()); ctr_cv(conic_curves.begin(), conic_curves.end());
//Polycurve_conic_traits_2::Curve_2 conic_polycurve_2 = //Polycurve_conic_traits_2::Curve_2 conic_polycurve_2 =
// construct_polycurve(conic_curves_2.begin(), conic_curves_2.end()); // ctr_cv(conic_curves_2.begin(), conic_curves_2.end());
//make x-monotone curve //make x-monotone curve
//Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = //Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
// construct_x_monotone_curve_2(c1); // ctr_xcv(c1);
//create points //create points
Polycurve_conic_traits_2::Point_2 Polycurve_conic_traits_2::Point_2
@ -476,37 +469,33 @@ bool check_compare_y_at_x_2()
return true; return true;
} }
void check_are_mergable() void check_are_mergable() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_sub_cv = sub_traits.construct_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Are_mergeable_2 are_mergeable_2 = auto are_mergeable_2 = traits.are_mergeable_2_object();
traits.are_mergeable_2_object();
//create a curve //create a curve
Rat_point_2 ps1(1, 10); Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4); Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1); Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1); Conic_curve_2 c1 = ctr_sub_cv(ps1, pmid1, pt1);
Rat_point_2 ps2(10, 1); Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 14); Rat_point_2 pmid2(15, 14);
Rat_point_2 pt2(20, 20); Rat_point_2 pt2(20, 20);
Conic_curve_2 c2(ps2, pmid2, pt2); Conic_curve_2 c2 = ctr_sub_cv(ps2, pmid2, pt2);
Rat_point_2 ps3(Rational(1,4), 4); Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2); Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3)); Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3); Conic_curve_2 c3 = ctr_sub_cv(ps3, pmid3, pt3);
//construct x-monotone curve(compatible with polyline class) //construct x-monotone curve(compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1); Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 = ctr_xcv(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc3 = ctr_xcv(c3);
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc3 =
construct_x_monotone_curve_2(c3);
bool result = are_mergeable_2(polyline_xmc1, polyline_xmc2); bool result = are_mergeable_2(polyline_xmc1, polyline_xmc2);
std::cout << "Are_mergable:: Mergable x-monotone polycurves are Computed as: " std::cout << "Are_mergable:: Mergable x-monotone polycurves are Computed as: "
@ -517,29 +506,27 @@ void check_are_mergable()
<< ((result)? "Mergable" : "Not-Mergable") << std::endl; << ((result)? "Mergable" : "Not-Mergable") << std::endl;
} }
void check_merge_2() void check_merge_2() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_sub_cv = sub_traits.construct_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Merge_2 merge_2 = traits.merge_2_object(); auto merge_2 = traits.merge_2_object();
//create a curve //create a curve
Rat_point_2 ps1(1, 10); Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4); Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1); Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1); Conic_curve_2 c1 = ctr_sub_cv(ps1, pmid1, pt1);
Rat_point_2 ps2(10, 1); Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 14); Rat_point_2 pmid2(15, 14);
Rat_point_2 pt2(20, 20); Rat_point_2 pt2(20, 20);
Conic_curve_2 c2(ps2, pmid2, pt2); Conic_curve_2 c2 = ctr_sub_cv(ps2, pmid2, pt2);
//construct x-monotone curve (compatible with polyline class) //construct x-monotone curve (compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1); Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 = ctr_xcv(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 merged_xmc; Polycurve_conic_traits_2::X_monotone_curve_2 merged_xmc;
@ -548,101 +535,93 @@ void check_merge_2()
<< std:: endl; << std:: endl;
} }
void check_construct_opposite() void check_construct_opposite() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_sub_cv = sub_traits.construct_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Construct_opposite_2 construct_opposite_2 = auto ctr_opposite = traits.construct_opposite_2_object();
traits.construct_opposite_2_object();
//create a curve //create a curve
Rat_point_2 ps1(1, 10); Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4); Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1); Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1); Conic_curve_2 c1 = ctr_sub_cv(ps1, pmid1, pt1);
//construct x-monotone curve (compatible with polyline class) //construct x-monotone curve (compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
construct_x_monotone_curve_2(c1); ctr_xcv(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_opposite_curve = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_opposite_curve =
construct_opposite_2(polyline_xmc1); ctr_opposite(polyline_xmc1);
std::cout<< "Construct_opposite_2:: Opposite curve created"; std::cout<< "Construct_opposite_2:: Opposite curve created";
} }
void check_compare_y_at_x_right() void check_compare_y_at_x_right() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_sub_cv = sub_traits.construct_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Compare_y_at_x_right_2 cmp_y_at_x_right_2 = auto cmp_y_at_x_right = traits.compare_y_at_x_right_2_object();
traits.compare_y_at_x_right_2_object();
//create constructing curves //create constructing curves
Rat_point_2 ps2(1, 10); Rat_point_2 ps2(1, 10);
Rat_point_2 pmid2(5, 4); Rat_point_2 pmid2(5, 4);
Rat_point_2 pt2(10, 1); Rat_point_2 pt2(10, 1);
Conic_curve_2 c1(ps2, pmid2, pt2); Conic_curve_2 c1 = ctr_sub_cv(ps2, pmid2, pt2);
Rat_point_2 ps3(10, 1); Rat_point_2 ps3(10, 1);
Rat_point_2 pmid3(5, 4); Rat_point_2 pmid3(5, 4);
Rat_point_2 pt3(1, 10); Rat_point_2 pt3(1, 10);
Conic_curve_2 c2(ps3, pmid3, pt3); Conic_curve_2 c2 = ctr_sub_cv(ps3, pmid3, pt3);
//construct x-monotone curve (compatible with polyline class) //construct x-monotone curve (compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1); Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 = ctr_xcv(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::Point_2 intersection_point = Polycurve_conic_traits_2::Point_2 intersection_point =
Polycurve_conic_traits_2::Point_2(5,4); Polycurve_conic_traits_2::Point_2(5,4);
CGAL::Comparison_result result; CGAL::Comparison_result result;
result = cmp_y_at_x_right_2(polyline_xmc1, polyline_xmc2, intersection_point); result = cmp_y_at_x_right(polyline_xmc1, polyline_xmc2, intersection_point);
std::cout << "Compare_y_at_x_right:: Expected Answer: equal, Computed answer: " std::cout << "Compare_y_at_x_right:: Expected Answer: equal, Computed answer: "
<< (result == CGAL::SMALLER ? "smaller": << (result == CGAL::SMALLER ? "smaller":
(result == CGAL::LARGER ? "Larger" : "equal")) << std::endl; (result == CGAL::LARGER ? "Larger" : "equal")) << std::endl;
} }
void check_compare_y_at_x_left() void check_compare_y_at_x_left() {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
Polycurve_conic_traits_2::Construct_x_monotone_curve_2 auto ctr_sub_cv = sub_traits.construct_curve_2_object();
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Compare_y_at_x_left_2 cmp_y_at_x_left_2 = auto cmp_y_at_x_left = traits.compare_y_at_x_left_2_object();
traits.compare_y_at_x_left_2_object();
//create constructing curves //create constructing curves
Rat_point_2 ps2(1, 10); Rat_point_2 ps2(1, 10);
Rat_point_2 pmid2(5, 4); Rat_point_2 pmid2(5, 4);
Rat_point_2 pt2(10, 1); Rat_point_2 pt2(10, 1);
Conic_curve_2 c1(ps2, pmid2, pt2); Conic_curve_2 c1 = ctr_sub_cv(ps2, pmid2, pt2);
Rat_point_2 ps3(10, 1); Rat_point_2 ps3(10, 1);
Rat_point_2 pmid3(5, 4); Rat_point_2 pmid3(5, 4);
Rat_point_2 pt3(1, 10); Rat_point_2 pt3(1, 10);
Conic_curve_2 c2(ps3, pmid3, pt3); Conic_curve_2 c2 = ctr_sub_cv(ps3, pmid3, pt3);
//construct x-monotone curve(compatible with polyline class) //construct x-monotone curve(compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 = ctr_xcv(c1);
construct_x_monotone_curve_2(c1); Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 = ctr_xcv(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::Point_2 intersection_point = Polycurve_conic_traits_2::Point_2 intersection_point =
Polycurve_conic_traits_2::Point_2(5,4); Polycurve_conic_traits_2::Point_2(5,4);
CGAL::Comparison_result result; CGAL::Comparison_result result;
result = cmp_y_at_x_left_2(polyline_xmc1, polyline_xmc2, intersection_point); result = cmp_y_at_x_left(polyline_xmc1, polyline_xmc2, intersection_point);
std::cout << "Compare_y_at_x_left:: Expected Answer: equal, Computed answer: " std::cout << "Compare_y_at_x_left:: Expected Answer: equal, Computed answer: "
<< (result == CGAL::SMALLER ? "smaller": << (result == CGAL::SMALLER ? "smaller":
(result == CGAL::LARGER ? "Larger" : "equal")) << std::endl; (result == CGAL::LARGER ? "Larger" : "equal")) << std::endl;
} }
template <typename GeometryTraits> template <typename GeometryTraits>
void check_make_x_monotne_curve(const typename GeometryTraits::Curve_2& c1) void check_make_x_monotne_curve(const typename GeometryTraits::Curve_2& c1) {
{
typename GeometryTraits::Point_2 Point_2; typename GeometryTraits::Point_2 Point_2;
typename GeometryTraits::X_monotone_curve_2 X_monotone_curve_2; typename GeometryTraits::X_monotone_curve_2 X_monotone_curve_2;
typedef boost::variant<Point_2, X_monotone_curve_2> Make_x_monotone_result; typedef boost::variant<Point_2, X_monotone_curve_2> Make_x_monotone_result;
@ -663,8 +642,7 @@ void check_make_x_monotne_curve(const typename GeometryTraits::Curve_2& c1)
} }
template<typename Curve, typename Segment> template<typename Curve, typename Segment>
void check_push_front(Curve base_curve, Segment curve_tobe_pushed) void check_push_front(Curve base_curve, Segment curve_tobe_pushed) {
{
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits;
std::cout << "Base curve: " << base_curve << std::endl; std::cout << "Base curve: " << base_curve << std::endl;
@ -675,8 +653,7 @@ void check_push_front(Curve base_curve, Segment curve_tobe_pushed)
} }
template<typename Curve, typename Segment> template<typename Curve, typename Segment>
void check_push_back(Curve& base_curve, Segment curve_tobe_pushed) void check_push_back(Curve& base_curve, Segment curve_tobe_pushed) {
{
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits;
std::cout << "Base curve: " << base_curve << std::endl; std::cout << "Base curve: " << base_curve << std::endl;
@ -688,8 +665,7 @@ void check_push_back(Curve& base_curve, Segment curve_tobe_pushed)
} }
template<typename Segment> template<typename Segment>
void check_compare_x_2(const Segment& seg1, const Segment& seg2) void check_compare_x_2(const Segment& seg1, const Segment& seg2) {
{
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits;
CGAL::Comparison_result result; CGAL::Comparison_result result;
@ -707,16 +683,14 @@ void check_compare_x_2(const Segment& seg1, const Segment& seg2)
} }
template<typename Curve> template<typename Curve>
void check_compare_points(Curve& cv) void check_compare_points(Curve& cv) {
{
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits;
CGAL::Arr_parameter_space result = CGAL::Arr_parameter_space result =
traits.parameter_space_in_x_2_object()(cv, CGAL::ARR_MAX_END); traits.parameter_space_in_x_2_object()(cv, CGAL::ARR_MAX_END);
} }
template <typename curve> template <typename curve>
void check_trim(curve& xcv, int sx, int sy, int tx, int ty) void check_trim(curve& xcv, int sx, int sy, int tx, int ty) {
{
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits;
// Conic_point_2 source(Algebraic(-16), Algebraic(-4)); // Conic_point_2 source(Algebraic(-16), Algebraic(-4));
@ -732,39 +706,41 @@ void check_trim(curve& xcv, int sx, int sy, int tx, int ty)
} }
int main(int argc, char* argv[]) int main(int argc, char* argv[]) {
{ Conic_traits_2 sub_traits;
Polycurve_conic_traits_2 traits; Polycurve_conic_traits_2 traits(&sub_traits);
auto ctr_sub_cv = sub_traits.construct_curve_2_object();
auto ctr_sub_xcv = sub_traits.construct_x_monotone_curve_2_object();
//polycurve constructors //polycurve constructors
auto construct_x_mono_polycurve = traits.construct_x_monotone_curve_2_object(); auto ctr_xcv = traits.construct_x_monotone_curve_2_object();
auto construct_polycurve = traits.construct_curve_2_object(); auto ctr_cv = traits.construct_curve_2_object();
//create a curve //create a curve
Conic_curve_2 c3(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c3 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)), Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(3), Algebraic(9))); Conic_point_2(Algebraic(3), Algebraic(9)));
Conic_curve_2 c4(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c4 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(3), Algebraic(9)), Conic_point_2(Algebraic(3), Algebraic(9)),
Conic_point_2(Algebraic(5), Algebraic(25))); Conic_point_2(Algebraic(5), Algebraic(25)));
Conic_curve_2 c5(0,1,0,1,0,0, CGAL::COUNTERCLOCKWISE, Conic_curve_2 c5 = ctr_sub_cv(0,1,0,1,0,0, CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(-25), Algebraic(-5)), Conic_point_2(Algebraic(-25), Algebraic(-5)),
Conic_point_2(Algebraic(0), Algebraic(0))); Conic_point_2(Algebraic(0), Algebraic(0)));
Conic_curve_2 c6(1,1,0,6,-26,162,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c6 = ctr_sub_cv(1,1,0,6,-26,162,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(-7), Algebraic(13)), Conic_point_2(Algebraic(-7), Algebraic(13)),
Conic_point_2(Algebraic(-3), Algebraic(9))); Conic_point_2(Algebraic(-3), Algebraic(9)));
Conic_curve_2 c7(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c7 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(-3), Algebraic(9)), Conic_point_2(Algebraic(-3), Algebraic(9)),
Conic_point_2(Algebraic(0), Algebraic(0))); Conic_point_2(Algebraic(0), Algebraic(0)));
Conic_curve_2 c8(0,1,0,-1,0,0, CGAL::COUNTERCLOCKWISE, Conic_curve_2 c8 = ctr_sub_cv(0,1,0,-1,0,0, CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)), Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(4), Algebraic(-2))); Conic_point_2(Algebraic(4), Algebraic(-2)));
Conic_curve_2 c9(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c9 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(-5), Algebraic(25)), Conic_point_2(Algebraic(-5), Algebraic(25)),
Conic_point_2(Algebraic(5), Algebraic(25))); Conic_point_2(Algebraic(5), Algebraic(25)));
Conic_curve_2 c10(58, 72, -48, 0, 0, -360); Conic_curve_2 c10 = ctr_sub_cv(58, 72, -48, 0, 0, -360);
//This vector is used to store curves that will be used to create polycurve //This vector is used to store curves that will be used to create polycurve
std::vector<Conic_curve_2> conic_curves; std::vector<Conic_curve_2> conic_curves;
@ -772,21 +748,21 @@ int main(int argc, char* argv[])
//construct poly-curve //construct poly-curve
Polycurve_conic_traits_2::Curve_2 conic_polycurve = Polycurve_conic_traits_2::Curve_2 conic_polycurve =
construct_polycurve(conic_curves.begin(), conic_curves.end()); ctr_cv(conic_curves.begin(), conic_curves.end());
Conic_curve_2 c11(0,1,0,-1,0,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c11 = ctr_sub_cv(0,1,0,-1,0,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(25), Algebraic(-5)), Conic_point_2(Algebraic(25), Algebraic(-5)),
Conic_point_2(Algebraic(0), Algebraic(0))); Conic_point_2(Algebraic(0), Algebraic(0)));
Conic_curve_2 c12(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c12 = ctr_sub_cv(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)), Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(5), Algebraic(25))); Conic_point_2(Algebraic(5), Algebraic(25)));
conic_curves.clear(); conic_curves.clear();
conic_curves.push_back(c11); conic_curves.push_back(c11);
conic_curves.push_back(c12); conic_curves.push_back(c12);
//construct poly-curve //construct poly-curve
Polycurve_conic_traits_2::Curve_2 conic_polycurve_2 = Polycurve_conic_traits_2::Curve_2 conic_polycurve_2 =
construct_polycurve(conic_curves.begin(), conic_curves.end()); ctr_cv(conic_curves.begin(), conic_curves.end());
/* VERY IMPORTANT /* VERY IMPORTANT
* For efficiency reasons, we recommend users not to construct * For efficiency reasons, we recommend users not to construct
@ -794,13 +770,12 @@ int main(int argc, char* argv[])
* functor supplied by the conic-arc traits class to convert conic curves * functor supplied by the conic-arc traits class to convert conic curves
* to x-monotone curves. * to x-monotone curves.
*/ */
Conic_x_monotone_curve_2 xc3(c3); Conic_x_monotone_curve_2 xc3 = ctr_sub_xcv(c3);
Conic_x_monotone_curve_2 xc4(c4); Conic_x_monotone_curve_2 xc4 = ctr_sub_xcv(c4);
Conic_x_monotone_curve_2 xc5(c5); Conic_x_monotone_curve_2 xc5 = ctr_sub_xcv(c5);
Conic_x_monotone_curve_2 xc6(c6); Conic_x_monotone_curve_2 xc6 = ctr_sub_xcv(c6);
Conic_x_monotone_curve_2 xc7(c7); Conic_x_monotone_curve_2 xc7 = ctr_sub_xcv(c7);
Conic_x_monotone_curve_2 xc8(c8); Conic_x_monotone_curve_2 xc8 = ctr_sub_xcv(c8);
//This vector is used to store curves that will be used to create //This vector is used to store curves that will be used to create
//X-monotone-polycurve //X-monotone-polycurve
@ -809,11 +784,9 @@ int main(int argc, char* argv[])
xmono_conic_curves_2.push_back(xc3); xmono_conic_curves_2.push_back(xc3);
xmono_conic_curves_2.push_back(xc4); xmono_conic_curves_2.push_back(xc4);
//construct x-monotone poly-curve //construct x-monotone poly-curve
Pc_x_monotone_curve_2 conic_x_mono_polycurve_1 = Pc_x_monotone_curve_2 conic_x_mono_polycurve_1 =
construct_x_mono_polycurve(xmono_conic_curves_2.begin(), ctr_xcv(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
xmono_conic_curves_2.end());
xmono_conic_curves_2.clear(); xmono_conic_curves_2.clear();
xmono_conic_curves_2.push_back(xc6); xmono_conic_curves_2.push_back(xc6);
@ -821,15 +794,13 @@ int main(int argc, char* argv[])
xmono_conic_curves_2.push_back(xc8); xmono_conic_curves_2.push_back(xc8);
//construct x-monotone poly-curve //construct x-monotone poly-curve
Pc_x_monotone_curve_2 conic_x_mono_polycurve_2 = Pc_x_monotone_curve_2 conic_x_mono_polycurve_2 =
construct_x_mono_polycurve(xmono_conic_curves_2.begin(), ctr_xcv(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
xmono_conic_curves_2.end());
xmono_conic_curves_2.clear(); xmono_conic_curves_2.clear();
xmono_conic_curves_2.push_back(xc5); xmono_conic_curves_2.push_back(xc5);
Pc_x_monotone_curve_2 x_polycurve_push = Pc_x_monotone_curve_2 x_polycurve_push =
construct_x_mono_polycurve(xmono_conic_curves_2.begin(), ctr_xcv(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
xmono_conic_curves_2.end());
Polycurve_conic_traits_2::X_monotone_subcurve_2 xcurve_push = Polycurve_conic_traits_2::X_monotone_subcurve_2 xcurve_push =
Polycurve_conic_traits_2::X_monotone_subcurve_2(c5); Polycurve_conic_traits_2::X_monotone_subcurve_2(c5);
//traits.construct_x_monotone_curve_2_object()(c5); //traits.construct_x_monotone_curve_2_object()(c5);
@ -838,28 +809,27 @@ int main(int argc, char* argv[])
xmono_conic_curves_2.push_back(xc3); xmono_conic_curves_2.push_back(xc3);
xmono_conic_curves_2.push_back(xc4); xmono_conic_curves_2.push_back(xc4);
Pc_x_monotone_curve_2 base_curve = Pc_x_monotone_curve_2 base_curve =
construct_x_mono_polycurve(xmono_conic_curves_2.begin(), ctr_xcv(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
xmono_conic_curves_2.end());
//curves for push_back //curves for push_back
Conic_curve_2 c13(1,1,0,-50,12,660,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c13 = ctr_sub_cv(1,1,0,-50,12,660,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(25), Algebraic(-7)), Conic_point_2(Algebraic(25), Algebraic(-7)),
Conic_point_2(Algebraic(25), Algebraic(-5))); Conic_point_2(Algebraic(25), Algebraic(-5)));
Conic_curve_2 c14(0,1,0,-1,0,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c14 = ctr_sub_cv(0,1,0,-1,0,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(25), Algebraic(-5)), Conic_point_2(Algebraic(25), Algebraic(-5)),
Conic_point_2(Algebraic(0), Algebraic(0))); Conic_point_2(Algebraic(0), Algebraic(0)));
Conic_curve_2 c15(-1,0,0,0,1,0,CGAL::COUNTERCLOCKWISE, Conic_curve_2 c15 = ctr_sub_cv(-1,0,0,0,1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)), Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(5), Algebraic(25))); Conic_point_2(Algebraic(5), Algebraic(25)));
conic_curves.clear(); conic_curves.clear();
conic_curves.push_back(c13); conic_curves.push_back(c13);
conic_curves.push_back(c14); conic_curves.push_back(c14);
Polycurve_conic_traits_2::Curve_2 base_curve_push_back = Polycurve_conic_traits_2::Curve_2 base_curve_push_back =
construct_polycurve(conic_curves.begin(), conic_curves.end()); ctr_cv(conic_curves.begin(), conic_curves.end());
conic_curves.push_back(c15); conic_curves.push_back(c15);
Polycurve_conic_traits_2::Curve_2 Expected_push_back_result = Polycurve_conic_traits_2::Curve_2 Expected_push_back_result =
construct_polycurve(conic_curves.begin(), conic_curves.end()); ctr_cv(conic_curves.begin(), conic_curves.end());
// //checking the orientattion consistency // //checking the orientattion consistency
// Conic_curve_2 c21(0,1,0,1,0,0,CGAL::CLOCKWISE, // Conic_curve_2 c21(0,1,0,1,0,0,CGAL::CLOCKWISE,
@ -874,7 +844,7 @@ int main(int argc, char* argv[])
// xmono_conic_curves_2.push_back(xc20); // xmono_conic_curves_2.push_back(xc20);
// xmono_conic_curves_2.push_back(xc21); // xmono_conic_curves_2.push_back(xc21);
// Pc_x_monotone_curve_2 eric_polycurve = // Pc_x_monotone_curve_2 eric_polycurve =
// construct_x_mono_polycurve(xmono_conic_curves_2.begin(), // ctr_xcv(xmono_conic_curves_2.begin(),
// xmono_conic_curves_2.end()); // xmono_conic_curves_2.end());
// std::cout << "the polycurve is: " << eric_polycurve << std::endl; // std::cout << "the polycurve is: " << eric_polycurve << std::endl;

144
Surface_sweep_2/test/Surface_sweep_2/test_sweep_conic.cpp
View File

@ -40,13 +40,14 @@ typedef std::list<Curve_2> CurveList;
typedef std::list<Point_2> PointList; typedef std::list<Point_2> PointList;
typedef PointList::iterator PointListIter; typedef PointList::iterator PointListIter;
/*! Conic reader */ /*! Conic reader */
template <typename Traits> template <typename Traits>
class Conic_reader { class Conic_reader {
private:
Traits_2 m_traits;
public: public:
int ReadData(const char* filename, CurveList& curves, CGAL::Bbox_2& bbox) int read_data(const char* filename, CurveList& curves, CGAL::Bbox_2& bbox) {
{
Curve_2 cv; Curve_2 cv;
char dummy[256]; char dummy[256];
@ -58,8 +59,8 @@ public:
int count; int count;
inp >> count; inp >> count;
inp.getline(dummy, sizeof(dummy)); inp.getline(dummy, sizeof(dummy));
for (int i = 0; i < count; i++) { for (int i = 0; i < count; ++i) {
ReadCurve(inp, cv); read_curve(inp, cv);
curves.push_back(cv); curves.push_back(cv);
CGAL::Bbox_2 curve_bbox = cv.bbox(); CGAL::Bbox_2 curve_bbox = cv.bbox();
if (i == 0) bbox = curve_bbox; if (i == 0) bbox = curve_bbox;
@ -69,50 +70,47 @@ public:
return 0; return 0;
} }
void ReadCurve(std::ifstream & is, Curve_2 & cv) void read_curve(std::ifstream& is, Curve_2& cv) {
{ auto ctr_cv = m_traits.construct_curve_2_object();
// Read a line from the input file. // Read a line from the input file.
char one_line[128]; char one_line[128];
skip_comments (is, one_line); skip_comments(is, one_line);
std::string stringvalues(one_line); std::string stringvalues(one_line);
std::istringstream str_line (stringvalues, std::istringstream::in); std::istringstream str_line(stringvalues, std::istringstream::in);
// Get the arc type. // Get the arc type.
// Supported types are: 'f' - Full ellipse (or circle). // Supported types are: 'f' - Full ellipse (or circle).
// 'e' - Elliptic arc (or circular arc). // 'e' - Elliptic arc (or circular arc).
// 's' - Line segment. // 's' - Line segment.
char type; bool is_circle(false); // Is this a circle.
bool is_circle = false; // Is this a circle.
Rat_circle_2 circle; Rat_circle_2 circle;
Rational r, s, t, u, v, w; // The conic coefficients. Rational r, s, t, u, v, w; // The conic coefficients.
char type;
str_line >> type; str_line >> type;
// An ellipse (full ellipse or a partial ellipse): // An ellipse (full ellipse or a partial ellipse):
if (type == 'f' || type == 'F' || type == 'e' || type == 'E') if (type == 'f' || type == 'F' || type == 'e' || type == 'E') {
{
// Read the ellipse (using the format "a b x0 y0"): // Read the ellipse (using the format "a b x0 y0"):
// //
// x - x0 2 y - y0 2 // x - x0 2 y - y0 2
// ( -------- ) + ( -------- ) = 1 // ( -------- ) + ( -------- ) = 1
// a b // a b
// //
int a, b, x0, y0; int a, b, x0, y0;
str_line >> a >> b >> x0 >> y0; str_line >> a >> b >> x0 >> y0;
Rational a_sq = Rational(a*a); Rational a_sq = Rational(a*a);
Rational b_sq = Rational(b*b); Rational b_sq = Rational(b*b);
if (a == b) if (a == b) {
{
is_circle = true; is_circle = true;
circle = Rat_circle_2 (Rat_point_2 (Rational(x0), Rational(y0)), circle =
Rational(a*b)); Rat_circle_2(Rat_point_2(Rational(x0), Rational(y0)), Rational(a*b));
} }
else else {
{
r = b_sq; r = b_sq;
s = a_sq; s = a_sq;
t = 0; t = 0;
@ -121,54 +119,43 @@ public:
w = Rational(x0*x0*b_sq + y0*y0*a_sq - a_sq*b_sq); w = Rational(x0*x0*b_sq + y0*y0*a_sq - a_sq*b_sq);
} }
if (type == 'f' || type == 'F') if (type == 'f' || type == 'F') {
{
// Create a full ellipse (or circle). // Create a full ellipse (or circle).
if (is_circle) cv = (is_circle) ? ctr_cv(circle) : ctr_cv(r, s, t, u, v, w);
cv = Curve_2 (circle); return;
else
cv = Curve_2 (r, s, t, u, v, w);
} }
else
{
// Read the endpointd of the arc.
int x1, y1, x2, y2;
str_line >> x1 >> y1 >> x2 >> y2; // Read the endpointd of the arc.
int x1, y1, x2, y2;
str_line >> x1 >> y1 >> x2 >> y2;
Point_2 source = Point_2 (Algebraic(x1), Algebraic(y1)); Point_2 source = Point_2 (Algebraic(x1), Algebraic(y1));
Point_2 target = Point_2 (Algebraic(x2), Algebraic(y2)); Point_2 target = Point_2 (Algebraic(x2), Algebraic(y2));
// Create the arc. Note that it is always clockwise oriented. // Create the arc. Note that it is always clockwise oriented.
if (is_circle) cv = (is_circle) ?
cv = Curve_2 (circle, ctr_cv(circle, CGAL::CLOCKWISE, source, target) :
CGAL::CLOCKWISE, ctr_cv(r, s, t, u, v, w, CGAL::CLOCKWISE, source, target);
source, target); return;
else
cv = Curve_2 (r, s, t, u, v, w,
CGAL::CLOCKWISE,
source, target);
}
} }
else if (type == 's' || type == 'S')
{
// Read a segment, given by its endpoints (x1,y1) and (x2,y2);
int x1, y1, x2, y2;
if (type == 's' || type == 'S') {
// Read a segment, given by its endpoints (x1,y1) and (x2,y2);
int x1, y1, x2, y2;
str_line >> x1 >> y1 >> x2 >> y2; str_line >> x1 >> y1 >> x2 >> y2;
// Create the segment. // Create the segment.
Rat_point_2 source = Rat_point_2 (Rational(x1), Rational(y1)); Rat_point_2 source = Rat_point_2(Rational(x1), Rational(y1));
Rat_point_2 target = Rat_point_2 (Rational(x2), Rational(y2)); Rat_point_2 target = Rat_point_2(Rational(x2), Rational(y2));
cv = Curve_2(Rat_segment_2 (source, target)); cv = ctr_cv(Rat_segment_2(source, target));
return;
} }
return; std::cerr << "Invalid type (" << type << ")" << std::endl;
} }
void skip_comments( std::ifstream& is, char* one_line ) void skip_comments( std::ifstream& is, char* one_line) {
{
while( !is.eof() ){ while( !is.eof() ){
is.getline( one_line, 128 ); is.getline( one_line, 128 );
if( one_line[0] != '#' ){ if( one_line[0] != '#' ){
@ -181,13 +168,11 @@ public:
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// The main: // The main:
// //
int main (int argc, char** argv) int main(int argc, char* argv[]) {
{
bool verbose = false; bool verbose = false;
// Define a test objects to read the conic arcs from it. // Define a test objects to read the conic arcs from it.
if (argc<2) if (argc<2) {
{
std::cerr << "Usage: Conic_traits_test <filename>" << std::endl; std::cerr << "Usage: Conic_traits_test <filename>" << std::endl;
exit(1); exit(1);
} }
@ -196,27 +181,25 @@ int main (int argc, char** argv)
CurveList curves; CurveList curves;
Conic_reader<Traits_2> reader; Conic_reader<Traits_2> reader;
reader.ReadData(argv[1], curves, bbox); reader.read_data(argv[1], curves, bbox);
// run the sweep // run the sweep
std::list<X_monotone_curve_2> mylist; std::list<X_monotone_curve_2> mylist;
CGAL::compute_subcurves(curves.begin(), curves.end(), CGAL::compute_subcurves(curves.begin(), curves.end(),
std::back_inserter(mylist), false); std::back_inserter(mylist), false);
PointList point_list_with_ends; PointList point_list_with_ends;
CGAL::compute_intersection_points(curves.begin(), curves.end(), CGAL::compute_intersection_points(curves.begin(), curves.end(),
std::back_inserter(point_list_with_ends), true); std::back_inserter(point_list_with_ends),
true);
std::size_t point_count_with_ends_calculated = point_list_with_ends.size(); std::size_t point_count_with_ends_calculated = point_list_with_ends.size();
// generate the string for the output // generate the string for the output
std::stringstream out1; std::stringstream out1;
for ( std::list<X_monotone_curve_2>::iterator iter = mylist.begin() ; for (auto iter = mylist.begin(); iter != mylist.end(); ++iter)
iter != mylist.end() ; ++iter )
{
out1 << *iter << "\n"; out1 << *iter << "\n";
}
// read the output from the file // read the output from the file
std::stringstream out2; std::stringstream out2;
@ -226,12 +209,10 @@ int main (int argc, char** argv)
std::ifstream in_file(argv[1]); std::ifstream in_file(argv[1]);
in_file >> count; in_file >> count;
in_file.getline(buf, 1024); // to get rid of the new line in_file.getline(buf, 1024); // to get rid of the new line
for ( int i = 0 ; i < count ; i++ ) { for (int i = 0 ; i < count ; ++i) in_file.getline(buf, 1024);
in_file.getline(buf, 1024);
}
in_file >> count; in_file >> count;
in_file.getline(buf, 1024); // to get rid of the new line in_file.getline(buf, 1024); // to get rid of the new line
for (int i = 0; i < count; i++) { for (int i = 0; i < count; ++i) {
in_file.getline(buf, 1024); in_file.getline(buf, 1024);
out2 << buf << "\n"; out2 << buf << "\n";
} }
@ -239,31 +220,28 @@ int main (int argc, char** argv)
in_file >> point_count_with_ends_from_file; in_file >> point_count_with_ends_from_file;
in_file.close(); in_file.close();
if ( verbose ) if (verbose) {
{
std::cout << "Result: \n" << mylist.size() << "\n"; std::cout << "Result: \n" << mylist.size() << "\n";
for ( std::list<X_monotone_curve_2>::iterator i = mylist.begin() ; for (auto i = mylist.begin(); i != mylist.end() ; ++i)
i != mylist.end() ; ++i )
{
std::cout << *i << "\n"; std::cout << *i << "\n";
}
} }
std::string calculated = out1.str(); std::string calculated = out1.str();
std::string infile = out2.str(); std::string infile = out2.str();
if ( infile == calculated ) { if (infile == calculated) {
if ( point_count_with_ends_from_file != if (point_count_with_ends_from_file != point_count_with_ends_calculated) {
point_count_with_ends_calculated ) {
std::cout << "number of intersection points (with ends):" std::cout << "number of intersection points (with ends):"
<< point_count_with_ends_calculated << ". Should be " << point_count_with_ends_calculated << ". Should be "
<< point_count_with_ends_from_file << "\n"; << point_count_with_ends_from_file << "\n";
std::cout << argv[1] << " Error\n"; std::cout << argv[1] << " Error\n";
return -1; return -1;
} else { }
else {
std::cout << argv[1] << " OK!\n"; std::cout << argv[1] << " OK!\n";
} }
} else { }
else {
std::cout << argv[1] << " Error\n"; std::cout << argv[1] << " Error\n";
std::cout << "\ncalculated:\n"; std::cout << "\ncalculated:\n";
std::cout << calculated << std::endl; std::cout << calculated << std::endl;