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

Get rid of result types in function objects of Circular_kernel_23

This commit is contained in:
Mael Rouxel-Labbé 2025-01-08 17:25:20 +01:00
parent 8c95fcca9c
commit d02e817bc1
10 changed files with 484 additions and 534 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -4216,8 +4216,7 @@ namespace CartesianKernelFunctors {
&& collinear_are_ordered_along_line(t.vertex(1), p, t.vertex(2))) ||
(o3 == COLLINEAR
&& collinear_are_ordered_along_line(t.vertex(2), p, t.vertex(3)))
? result_type(ON_ORIENTED_BOUNDARY)
: opposite(ot);
? Oriented_side(ON_ORIENTED_BOUNDARY) : opposite(ot);
}
Oriented_side

24
Circular_kernel_2/include/CGAL/Circular_kernel_2/function_objects_on_circle_2.h
View File

@ -31,25 +31,29 @@ namespace CGAL {
namespace CircularFunctors {
template < class CK >
class Construct_circle_2 : public CK::Linear_kernel::Construct_circle_2
class Construct_circle_2
// : public CK::Linear_kernel::Construct_circle_2
{
typedef typename CK::Linear_kernel::Construct_circle_2 Base_functor;
typedef typename CK::FT FT;
typedef typename CK::Linear_kernel::Point_2 Point_2;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Linear_kernel::Construct_circle_2 Linear_Construct_circle_2;
public:
typedef typename Base_functor::result_type result_type;
// using Linear_Construct_circle_2::operator();
using Base_functor::operator();
template <class... Args>
decltype(auto)
operator()(const Args&... args) const
{ return Linear_Construct_circle_2()(args...); }
typedef typename CK::Circular_arc_2 Circular_arc_2;
result_type
Circle_2
operator() ( const typename CK::Polynomial_for_circles_2_2 &eq ) {
return construct_circle_2<CK>(eq);
}
result_type
decltype(auto)
operator() (const Circular_arc_2 & a) const {
return (a.rep().supporting_circle());
}

28
Circular_kernel_2/include/CGAL/Circular_kernel_2/function_objects_on_line_2.h
View File

@ -30,26 +30,32 @@ namespace CGAL {
namespace LinearFunctors {
template < class CK >
class Construct_line_2 : public CK::Linear_kernel::Construct_line_2
class Construct_line_2
// : public CK::Linear_kernel::Construct_line_2
{
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Line_2 Line_2;
public:
typedef typename CK::Linear_kernel::Construct_line_2::result_type
result_type;
using CK::Linear_kernel::Construct_line_2::operator();
typedef typename CK::Linear_kernel::Construct_line_2 Linear_Construct_circle_2;
result_type operator() (const Line_arc_2 & a) const
public:
// using CK::Linear_kernel::Construct_line_2::operator();
template <class... Args>
decltype(auto)
operator()(const Args&... args) const
{ return Linear_Construct_circle_2()(args...); }
decltype(auto) operator() (const Line_arc_2 & a) const
{
return (a.rep().supporting_line());
}
result_type
Line_2
operator() ( const typename CK::Polynomial_1_2 &eq )
{
return construct_line_2<CK>(eq);
}
{
return construct_line_2<CK>(eq);
}
};
} // namespace LinearFunctors

447
Circular_kernel_2/include/CGAL/Circular_kernel_2/function_objects_polynomial_circular.h
View File

@ -30,148 +30,115 @@
namespace CGAL {
namespace CircularFunctors {
#define CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(V)\
template < class CK > \
class Compare_ ##V## _2 {\
/*: public CK::Linear_kernel::Compare_ ##V## _2{*/\
typedef typename CK::Comparison_result Comparison_result;\
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;\
typedef typename CK::Linear_kernel::Compare_ ##V## _2 Linear_Compare_ ##V## _2;\
public:\
template <class... Args>\
Comparison_result\
operator()(const Args&... args) const\
{ return Linear_Compare_ ##V## _2()(args...); }\
/*using CK::Linear_kernel::Compare_ ##V## _2::operator();*/\
Comparison_result\
operator() (const Circular_arc_point_2 &p0,\
const Circular_arc_point_2 &p1) const\
{ return CircularFunctors::compare_ ##V <CK>(p0, p1); }\
};\
template < class CK >
class Compare_x_2
: public CK::Linear_kernel::Compare_x_2
{
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Point_2 Point_2;
CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(x)
CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(y)
CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(xy)
public:
typedef typename CK::Linear_kernel::Compare_x_2::result_type result_type;
using CK::Linear_kernel::Compare_x_2::operator();
result_type
operator() (const Circular_arc_point_2 &p0,
const Circular_arc_point_2 &p1) const
{ return CircularFunctors::compare_x<CK>(p0, p1);}
};
template < class CK >
class Compare_y_2
: public CK::Linear_kernel::Compare_y_2
{
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Point_2 Point_2;
public:
typedef typename CK::Linear_kernel::Compare_y_2::result_type result_type;
using CK::Linear_kernel::Compare_y_2::operator();
result_type
operator() (const Circular_arc_point_2 &p0,
const Circular_arc_point_2 &p1) const
{return CircularFunctors::compare_y<CK>(p0, p1);}
};
template < class CK >
class Compare_xy_2
: public CK::Linear_kernel::Compare_xy_2
{
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Point_2 Point_2;
public:
typedef typename CK::Linear_kernel::Compare_xy_2::result_type result_type;
using CK::Linear_kernel::Compare_xy_2::operator();
result_type
operator() (const Circular_arc_point_2 &p0,
const Circular_arc_point_2 &p1) const
{ return CircularFunctors::compare_xy<CK>(p0, p1);}
};
#undef CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_
template < class CK >
class In_x_range_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef bool result_type;
result_type
Boolean
operator()(const Circular_arc_2 &a, const Circular_arc_point_2 &p) const
{ return CircularFunctors::point_in_x_range<CK>(a, p); }
result_type
Boolean
operator()(const Line_arc_2 &a, const Circular_arc_point_2 &p) const
{ return CircularFunctors::point_in_x_range<CK>(a, p); }
};
template < class CK >
class Has_on_2
: public CK::Linear_kernel::Has_on_2
// : public CK::Linear_kernel::Has_on_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Line_2 Line_2;
typedef typename CK::Linear_kernel::Has_on_2 Linear_Has_on_2;
public:
typedef typename CK::Linear_kernel::Has_on_2::result_type result_type;
// using CK::Linear_kernel::Has_on_2::operator();
using CK::Linear_kernel::Has_on_2::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Has_on_2()(a, b); }
result_type
Boolean
operator()(const Circle_2 &a, const Circular_arc_point_2 &p) const
{ return CircularFunctors::has_on<CK>(a, p); }
result_type
Boolean
operator()(const Line_2 &a, const Circular_arc_point_2 &p) const
{ return LinearFunctors::has_on<CK>(a, p); }
result_type
Boolean
operator()(const Circular_arc_2 &a, const Circular_arc_point_2 &p) const
{ return CircularFunctors::has_on<CK>(a, p); }
result_type
Boolean
operator()(const Line_arc_2 &a, const Circular_arc_point_2 &p) const
{ return CircularFunctors::has_on<CK>(a, p); }
};
template < class CK >
class Compare_y_to_right_2
{
typedef typename CK::Comparison_result Comparison_result;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef CGAL::Comparison_result result_type;
result_type
Comparison_result
operator()(const Circular_arc_2 &a1,
const Circular_arc_2 &a2,
const Circular_arc_point_2 &p) const
{ return CircularFunctors::compare_y_to_right<CK>(a1, a2, p); }
result_type
Comparison_result
operator()(const Line_arc_2 &a1,
const Line_arc_2 &a2,
const Circular_arc_point_2 &p) const
{ return CircularFunctors::compare_y_to_right<CK>(a1, a2, p); }
result_type
Comparison_result
operator()(const Line_arc_2 &a1,
const Circular_arc_2 &a2,
const Circular_arc_point_2 &p) const
{ return CircularFunctors::compare_y_to_right<CK>(a1, a2, p); }
result_type
Comparison_result
operator()(const Circular_arc_2 &a1,
const Line_arc_2 &a2,
const Circular_arc_point_2 &p) const
@ -179,21 +146,16 @@ namespace CircularFunctors {
return CGAL::SMALLER;
return CGAL::LARGER;
}
};
template < class CK >
class Equal_2
: public CK::Linear_kernel::Equal_2
// : public CK::Linear_kernel::Equal_2
{
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef typename CK::Linear_kernel LK;
typedef typename LK::Equal_2 LK_Equal_2;
typedef typename CK::Point_2 Point_2;
typedef typename CK::Vector_2 Vector_2;
typedef typename CK::Direction_2 Direction_2;
@ -204,69 +166,78 @@ namespace CircularFunctors {
typedef typename CK::Iso_rectangle_2 Iso_rectangle_2;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Linear_kernel::Equal_2 Linear_Equal_2;
typedef typename CK::Linear_kernel::Equal_2::result_type result_type;
using CK::Linear_kernel::Equal_2::operator();
public:
// using CK::Linear_kernel::Equal_2::operator();
result_type
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const {
return Linear_Equal_2()(a, b);
}
Boolean
operator() (const Circular_arc_point_2 &p0,
const Circular_arc_point_2 &p1) const
{ return CircularFunctors::equal<CK>(p0, p1); }
result_type
Boolean
operator() (const Circular_arc_2 &a0, const Circular_arc_2 &a1) const
{ return CircularFunctors::equal<CK>(a0, a1); }
result_type
Boolean
operator() (const Line_arc_2 &a0, const Line_arc_2 &a1) const
{ return CircularFunctors::equal<CK>(a0, a1); }
};
template < class CK >
class Compare_y_at_x_2 : public CK::Linear_kernel::Compare_y_at_x_2
class Compare_y_at_x_2
// : public CK::Linear_kernel::Compare_y_at_x_2
{
typedef typename CK::Comparison_result Comparison_result;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Linear_kernel::Compare_y_at_x_2 Linear_Compare_y_at_x_2;
public:
typedef typename CK::Linear_kernel::Compare_y_at_x_2::result_type result_type;
// using CK::Linear_kernel::Compare_y_at_x_2::operator();
using CK::Linear_kernel::Compare_y_at_x_2::operator();
template <class... Args>
Comparison_result
operator()(const Args&... args) const
{ return Linear_Compare_y_at_x_2()(args...); }
result_type
Comparison_result
operator() (const Circular_arc_point_2 &p,
const Circular_arc_2 &A1) const
{ return CircularFunctors::compare_y_at_x<CK>(p, A1); }
result_type
Comparison_result
operator() (const Circular_arc_point_2 &p,
const Line_arc_2 &A1) const
{ return CircularFunctors::compare_y_at_x<CK>(p, A1); }
};
template < class CK >
class Do_overlap_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef bool result_type;
result_type
Boolean
operator() (const Circular_arc_2 &A1, const Circular_arc_2 &A2) const
{ return CircularFunctors::do_overlap<CK>(A1, A2); }
result_type
Boolean
operator() (const Line_arc_2 &A1, const Line_arc_2 &A2) const
{ return CircularFunctors::do_overlap<CK>(A1, A2); }
};
template < class CK >
class Make_x_monotone_2
{
@ -274,9 +245,6 @@ namespace CircularFunctors {
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef void result_type; //!!!
template < class OutputIterator >
OutputIterator
operator()(const Circular_arc_2 &A, OutputIterator res) const
@ -290,7 +258,6 @@ namespace CircularFunctors {
{
return CircularFunctors::make_x_monotone<CK>(A,res);
}
};
template < class CK >
@ -300,9 +267,6 @@ namespace CircularFunctors {
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef void result_type; //!!!
template < class OutputIterator >
OutputIterator
operator()(const Circular_arc_2 &A, OutputIterator res) const
@ -326,19 +290,21 @@ namespace CircularFunctors {
{ *res++ = make_object(A);
return res;
}
};
template < class CK >
class Do_intersect_2
: public CK::Linear_kernel::Do_intersect_2
// : public CK::Linear_kernel::Do_intersect_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Linear_kernel::Do_intersect_2 Linear_Do_intersect_2;
public:
typedef typename CK::Linear_kernel::Do_intersect_2::result_type result_type;
template <class T1, class T2>
result_type
operator()(const T1& t1, const T2& t2) const
{ return Intersections::internal::do_intersect(t1, t2, CK()); }
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Intersections::internal::do_intersect(a, b, CK()); }
};
template < class CK >
@ -347,14 +313,12 @@ namespace CircularFunctors {
//using the Lazy_kernel as linear kernel.
//: public CK::Linear_kernel::Intersect_2
{
typedef typename CK::Circle_2 Circle;
typedef typename CK::Circular_arc_2 Circular_arc;
typedef typename CK::Line_arc_2 Line_arc;
typedef typename CK::Line_2 Line;
public:
//using CK::Linear_kernel::Intersect_2::operator();
template<class A, class B>
@ -460,7 +424,6 @@ namespace CircularFunctors {
*res++=typename CK::Linear_kernel::Intersect_2()(l1, l2);
return res;
}
};
template < class CK >
@ -470,61 +433,61 @@ namespace CircularFunctors {
typename CK::Polynomial_1_2
operator() ( const typename CK::Line_2 & l )
{
return LinearFunctors::get_equation<CK>(l);
}
{
return LinearFunctors::get_equation<CK>(l);
}
typename CK::Polynomial_for_circles_2_2
operator() ( const typename CK::Circle_2 & c )
{
return CircularFunctors::get_equation<CK>(c);
}
{
return CircularFunctors::get_equation<CK>(c);
}
};
template < class CK >
class Split_2
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef void result_type;
result_type
void
operator()(const Circular_arc_2 &A,
const Circular_arc_point_2 &p,
Circular_arc_2 &ca1, Circular_arc_2 &ca2) const
{ return CircularFunctors::split<CK>(A, p, ca1, ca2); }
result_type
void
operator()(const Line_arc_2 &A,
const Circular_arc_point_2 &p,
Line_arc_2 &ca1, Line_arc_2 &ca2) const
{ return CircularFunctors::split<CK>(A, p, ca1, ca2); }
};
template < class CK >
class Is_vertical_2
: public CK::Linear_kernel::Is_vertical_2
// : public CK::Linear_kernel::Is_vertical_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Linear_kernel::Is_vertical_2 Linear_Is_vertical_2;
public:
// using CK::Linear_kernel::Is_vertical_2::operator();
typedef typename CK::Linear_kernel::Is_vertical_2::result_type result_type;
template <typename A>
Boolean
operator()(const A& a) const
{ return Linear_Is_vertical_2()(a); }
using CK::Linear_kernel::Is_vertical_2::operator();
result_type
Boolean
operator()(const Circular_arc_2 &A) const
{ return CircularFunctors::is_vertical<CK>(A); }
result_type
Boolean
operator()(const Line_arc_2 &A) const
{ return CircularFunctors::is_vertical<CK>(A); }
@ -533,56 +496,51 @@ namespace CircularFunctors {
template < class CK >
class Construct_circular_arc_2
{
typedef typename CK::FT FT;
typedef typename CK::RT RT;
typedef typename CK::Point_2 Point_2;
typedef typename CK::Line_2 Line_2;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Kernel_base::Circular_arc_2 RCircular_arc_2;
typedef typename Circular_arc_2::Rep Rep;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
public:
typedef Circular_arc_2 result_type;
result_type
Circular_arc_2
operator()(void)
{ return Rep(); }
result_type
Circular_arc_2
operator()(const Circle_2 &c) const
{ return Rep(c); }
result_type
Circular_arc_2
operator()(const Circle_2 &support,
const Circular_arc_point_2 &source,
const Circular_arc_point_2 &target) const
{ return Rep(support,source,target); }
// Not Documented
result_type
Circular_arc_2
operator()(const Circle_2 &support,
const Line_2 &l1, bool b1,
const Line_2 &l2, bool b2) const
{ return Rep(support,l1,b1,l2,b2); }
// Not Documented
result_type
Circular_arc_2
operator()(const Circle_2 &c,
const Circle_2 &c1, bool b_1,
const Circle_2 &c2, bool b_2) const
{ return Rep(c,c1,b_1,c2,b_2); }
result_type
Circular_arc_2
operator()(const Point_2 &begin,
const Point_2 &middle,
const Point_2 &end) const
{ return Rep(begin,middle,end); }
// Not Documented
result_type
Circular_arc_2
operator()(const Point_2 &begin,
const Point_2 &end,
const FT& bulge) const
@ -600,47 +558,44 @@ namespace CircularFunctors {
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Segment_2 Segment_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Kernel_base::Line_arc_2 RLine_arc_2;
typedef typename Line_arc_2::Rep Rep;
public:
typedef Line_arc_2 result_type;
result_type
Line_arc_2
operator()(void)
{ return Rep(); }
// Not Documented
result_type
Line_arc_2
operator()(const Line_2 &support,
const Circle_2 &c1,const bool b1,
const Circle_2 &c2,const bool b2) const
{ return Rep(support,c1,b1,c2,b2); }
// Not Documented
result_type
Line_arc_2
operator()(const Line_2 &support,
const Line_2 &l1,
const Line_2 &l2) const
{ return Rep(support,l1,l2); }
result_type
Line_arc_2
operator()(const Line_2 &support,
const Circular_arc_point_2 &p1,
const Circular_arc_point_2 &p2) const
{ return Rep(support,p1,p2); }
// result_type
// Line_arc_2
// operator()(const Line_2 &support,
// const Point_2 &p1,
// const Point_2 &p2) const
// { return Rep(support,p1,p2); }
result_type
Line_arc_2
operator()(const Segment_2 &s) const
{ return Rep(s); }
result_type
Line_arc_2
operator()(const Point_2 &p1,
const Point_2 &p2) const
{ return Rep(p1,p2); }
@ -652,40 +607,32 @@ namespace CircularFunctors {
{
typedef typename CK::Point_2 Point_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Kernel_base::Circular_arc_point_2
RCircular_arc_point_2;
typedef typename Circular_arc_point_2::Rep Rep;
typedef typename Circular_arc_point_2::Root_for_circles_2_2
Root_for_circles_2_2;
public:
typedef Circular_arc_point_2 result_type;
result_type
Circular_arc_point_2
operator()(void)
{ return Rep(); }
result_type
Circular_arc_point_2
operator()(const Root_for_circles_2_2 & np) const
{ return Rep(np); }
result_type
Circular_arc_point_2
operator()(const Point_2 & p) const
{ return Rep(p); }
};
template <class CK>
class Compute_circular_x_2
{
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Root_of_2 Root_of_2;
public:
typedef const Root_of_2& result_type;
result_type operator() (const Circular_arc_point_2 & a) const
decltype(auto) operator() (const Circular_arc_point_2 & a) const
{
return (a.rep().x());
}
@ -696,13 +643,9 @@ namespace CircularFunctors {
class Compute_circular_y_2
{
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Root_of_2 Root_of_2;
public:
typedef const Root_of_2& result_type;
result_type operator() (const Circular_arc_point_2 & a) const
decltype(auto) operator() (const Circular_arc_point_2 & a) const
{
return (a.rep().y());
}
@ -714,17 +657,14 @@ namespace CircularFunctors {
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
public:
typedef const Circular_arc_point_2 & result_type;
result_type operator() (const Circular_arc_2 & a) const
decltype(auto) operator() (const Circular_arc_2& a) const
{
return (a.rep().left());
}
result_type operator() (const Line_arc_2 & a) const
decltype(auto) operator() (const Line_arc_2& a) const
{
return (a.rep().left());
}
@ -736,18 +676,14 @@ namespace CircularFunctors {
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
public:
typedef const Circular_arc_point_2& result_type;
result_type operator() (const Circular_arc_2 & a) const
decltype(auto) operator() (const Circular_arc_2& a) const
{
return (a.rep().right());
}
result_type operator() (const Line_arc_2 & a) const
decltype(auto) operator() (const Line_arc_2& a) const
{
return (a.rep().right());
}
@ -759,16 +695,12 @@ namespace CircularFunctors {
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
public:
typedef const Circular_arc_point_2& result_type;
result_type operator() (const Circular_arc_2 & a) const
decltype(auto) operator() (const Circular_arc_2& a) const
{ return a.rep().source(); }
result_type operator() (const Line_arc_2 & a) const
decltype(auto) operator() (const Line_arc_2& a) const
{ return a.rep().source();}
};
@ -779,16 +711,12 @@ namespace CircularFunctors {
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
public:
typedef const Circular_arc_point_2& result_type;
result_type operator() (const Circular_arc_2 & a) const
decltype(auto) operator() (const Circular_arc_2& a) const
{ return a.rep().target();}
result_type operator() (const Line_arc_2 & a) const
decltype(auto) operator() (const Line_arc_2& a) const
{ return a.rep().target();}
};
@ -796,19 +724,17 @@ namespace CircularFunctors {
template <class CK>
class Is_x_monotone_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef bool result_type;
result_type operator() (const Circular_arc_2 & a) const
Boolean operator() (const Circular_arc_2 & a) const
{
return (a.rep().is_x_monotone());
}
result_type operator() (const Line_arc_2 & a) const
Boolean operator() (const Line_arc_2 & a) const
{
return (a.rep().is_x_monotone());
}
@ -818,19 +744,17 @@ namespace CircularFunctors {
template <class CK>
class Is_y_monotone_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Line_arc_2 Line_arc_2;
public:
typedef bool result_type;
result_type operator() (const Circular_arc_2 & a) const
Boolean operator() (const Circular_arc_2& a) const
{
return (a.rep().is_y_monotone());
}
result_type operator() (const Line_arc_2 & a) const
Boolean operator() (const Line_arc_2& a) const
{
return (a.rep().is_y_monotone());
}
@ -839,48 +763,58 @@ namespace CircularFunctors {
template <class CK>
class Construct_bbox_2
: public CK::Linear_kernel::Construct_bbox_2
// : public CK::Linear_kernel::Construct_bbox_2
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Linear_kernel::Construct_bbox_2 Linear_Construct_bbox_2;
public:
// using CK::Linear_kernel::Construct_bbox_2::operator();
typedef typename CK::Linear_kernel::Construct_bbox_2::result_type result_type;
using CK::Linear_kernel::Construct_bbox_2::operator();
template <typename A>
decltype(auto)
operator()(const A& a) const
{ return Linear_Construct_bbox_2()(a); }
result_type operator() (const Circular_arc_point_2 & a) const
decltype(auto) operator() (const Circular_arc_point_2& a) const
{
return a.rep().bbox();
}
result_type operator() (const Circular_arc_2 & a) const
decltype(auto) operator() (const Circular_arc_2& a) const
{
return a.rep().bbox();
}
result_type operator() (const Line_arc_2 & a) const
decltype(auto) operator() (const Line_arc_2& a) const
{
return a.rep().bbox();
}
};
template <class CK>
class Bounded_side_2
: public CK::Linear_kernel::Bounded_side_2
// : public CK::Linear_kernel::Bounded_side_2
{
typedef typename CK::Bounded_side Bounded_side;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Linear_kernel::Bounded_side_2 Linear_Bounded_side_2;
public:
typedef typename CK::Linear_kernel::Bounded_side_2::result_type result_type;
// using CK::Linear_kernel::Bounded_side_2::operator();
using CK::Linear_kernel::Bounded_side_2::operator();
template <typename A, typename B>
Bounded_side
operator()(const A& a, const B& b) const
{ return Linear_Bounded_side_2()(a, b); }
result_type
Bounded_side
operator()(const Circle_2& c, const Circular_arc_point_2& p) const
{ return CircularFunctors::bounded_side<CK>(c,p); }
@ -888,17 +822,23 @@ namespace CircularFunctors {
template <class CK>
class Has_on_bounded_side_2
: public CK::Linear_kernel::Has_on_bounded_side_2
// : public CK::Linear_kernel::Has_on_bounded_side_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Linear_kernel::Has_on_bounded_side_2 Linear_Has_on_bounded_side_2;
public:
typedef typename CK::Linear_kernel::Has_on_bounded_side_2::result_type result_type;
// using CK::Linear_kernel::Has_on_bounded_side_2::operator();
using CK::Linear_kernel::Has_on_bounded_side_2::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Has_on_bounded_side_2()(a, b); }
result_type
Boolean
operator()(const Circle_2& c, const Circular_arc_point_2& p) const
{ return CK().bounded_side_2_object()(c,p) == ON_BOUNDED_SIDE; }
@ -906,20 +846,25 @@ namespace CircularFunctors {
template <class CK>
class Has_on_unbounded_side_2
: public CK::Linear_kernel::Has_on_unbounded_side_2
// : public CK::Linear_kernel::Has_on_unbounded_side_2
{
typedef typename CK::Boolean Boolean;
typedef typename CK::Circle_2 Circle_2;
typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename CK::Linear_kernel::Has_on_unbounded_side_2 Linear_Has_on_unbounded_side_2;
public:
typedef typename CK::Linear_kernel::Has_on_unbounded_side_2::result_type result_type;
// using CK::Linear_kernel::Has_on_unbounded_side_2::operator();
using CK::Linear_kernel::Has_on_unbounded_side_2::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Has_on_unbounded_side_2()(a, b); }
result_type
Boolean
operator()(const Circle_2& c, const Circular_arc_point_2& p) const
{ return CK().bounded_side_2_object()(c,p) == ON_UNBOUNDED_SIDE; }
};
#ifndef CGAL_NO_DEPRECATED_CODE
@ -927,31 +872,21 @@ namespace CircularFunctors {
class Construct_supporting_circle_2
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Circle_2 Circle_2;
public:
typedef Circle_2 result_type;
CGAL_DEPRECATED result_type operator() (const Circular_arc_2 & a) const
CGAL_DEPRECATED decltype(auto) operator() (const Circular_arc_2 & a) const
{
return a.rep().supporting_circle();
}
};
template <class CK>
class Construct_supporting_line_2
{
typedef typename CK::Line_arc_2 Line_arc_2;
typedef typename CK::Line_2 Line_2;
typedef typename CK::Circle_2 Circle_2;
public:
typedef Line_2 result_type;
CGAL_DEPRECATED result_type operator() (const Line_arc_2 & a) const
CGAL_DEPRECATED decltype(auto) operator() (const Line_arc_2 & a) const
{
return a.rep().supporting_line();
}
@ -960,24 +895,28 @@ namespace CircularFunctors {
template <typename CK>
class Construct_center_2
: public CK::Linear_kernel::Construct_center_2
// : public CK::Linear_kernel::Construct_center_2
{
typedef typename CK::Circular_arc_2 Circular_arc_2;
public:
typedef typename CK::Linear_kernel::Construct_center_2::result_type result_type;
using CK::Linear_kernel::Construct_center_2::operator();
result_type
typedef typename CK::Linear_kernel::Construct_center_2 Linear_Construct_center_2;
public:
// using CK::Linear_kernel::Construct_center_2::operator();
template <typename A>
decltype(auto)
operator()(const A& a) const
{ return Linear_Construct_center_2()(a); }
decltype(auto)
operator()(const Circular_arc_2& c) const
{ return c.rep().center(); }
};
template <typename CK>
class Compute_squared_radius_2
{
private:
typedef typename CK::Circular_arc_2 Circular_arc_2;
typedef typename CK::Linear_kernel LK;
typedef typename LK::Compute_squared_radius_2 LK_Compute_squared_radius_2;

2
Circular_kernel_2/include/CGAL/Circular_kernel_intersections.h
View File

@ -54,7 +54,7 @@ namespace Intersections { \
} \
template <class K> \
inline \
bool \
typename K::Boolean \
do_intersect(const A <K> &c1, const B <K> &c2) \
{ \
return typename K::Do_intersect_2()(c1, c2); \

112
Circular_kernel_2/include/CGAL/Filtered_bbox_circular_kernel_2/bbox_filtered_predicates.h
View File

@ -33,6 +33,7 @@ namespace Bbox_functors {
template <class BK>
class Compare_x_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_x_2
{
typedef typename BK::Comparison_result Comparison_result;
typedef typename BK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename BK::Point_2 Point_2;
typedef typename BK::Circular_kernel::
@ -40,12 +41,9 @@ class Compare_x_2 : public BK::Circular_kernel:: template Base< BK >::Type::Comp
typedef CK_Compare_x_2 Base;
public:
typedef typename CK_Compare_x_2::result_type result_type;
using Base::operator();
result_type
Comparison_result
operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
{
Bbox_2 bb1=a.bbox(),bb2=b.bbox();
@ -65,16 +63,15 @@ public:
template <class BK>
class Compare_y_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_y_2
{
typedef typename BK::Comparison_result Comparison_result;
typedef typename BK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename BK::Point_2 Point_2;
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Compare_y_2 CK_Compare_y_2;
typedef CK_Compare_y_2 Base;
public:
typedef typename CK_Compare_y_2::result_type result_type;
result_type
Comparison_result
operator() (const Point_2 &p0,
const Point_2 &p1) const
{
@ -83,7 +80,7 @@ public:
using Base::operator();
result_type
Comparison_result
operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
{
Bbox_2 bb1=a.bbox(),bb2=b.bbox();
@ -105,17 +102,15 @@ class Compare_xy_2 : public BK::Circular_kernel:: template Base< BK >::Type::Com
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Compare_xy_2 CK_Compare_xy_2;
typedef CK_Compare_xy_2 Base;
typedef typename BK::Comparison_result Comparison_result;
typedef typename BK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename BK::Point_2 Point_2;
public:
typedef typename Base::result_type result_type;
using Base::operator();
public:
result_type
Comparison_result
operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
{
typename BK::Compare_x_2 compx;
@ -137,20 +132,18 @@ class In_x_range_2 : public BK::Circular_kernel:: template Base< BK >::Type::In_
typedef typename BK::Circular_kernel::
template Base< BK >::Type::In_x_range_2 CK_In_x_range_2;
typedef CK_In_x_range_2 Base;
typedef typename BK::Boolean Boolean;
typedef typename BK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename BK::Circular_arc_2 Circular_arc_2;
typedef typename BK::Line_arc_2 Line_arc_2;
public:
typedef typename CK_In_x_range_2::result_type result_type;
using Base::operator();
private:
template <class Arc_2>
result_type
Boolean
_in_x_range_2(const Arc_2 &a, const Circular_arc_point_2 &p) const
{
@ -179,42 +172,36 @@ private:
}
public:
result_type
Boolean
operator()( const Circular_arc_2 &a, const Circular_arc_point_2 &p) const
{
CGAL_precondition( a.is_x_monotone());
return _in_x_range_2(a,p);
}
result_type
Boolean
operator()( const Line_arc_2 &a, const Circular_arc_point_2 &p) const
{ return _in_x_range_2(a,p);}
};
template <class BK>
class Compare_y_at_x_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_y_at_x_2
{
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Compare_y_at_x_2 CK_Compare_y_at_x_2;
typedef CK_Compare_y_at_x_2 Base;
typedef typename BK::Comparison_result Comparison_result;
typedef typename BK::Circular_arc_2 Circular_arc_2;
typedef typename BK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename BK::Line_arc_2 Line_arc_2;
public:
typedef typename CK_Compare_y_at_x_2::result_type result_type;
using Base::operator();
private:
template <class Arc_2>
result_type
Comparison_result
_compare_y_at_x_2(const Circular_arc_point_2 &p,const Arc_2 &a) const
{
CGAL_precondition_code(bool tmp=In_x_range_2<BK>()(a,p));
@ -232,41 +219,36 @@ private:
}
public:
result_type
Comparison_result
operator()( const Circular_arc_point_2 &p,const Circular_arc_2 &a ) const
{
CGAL_precondition( a.is_x_monotone());
return _compare_y_at_x_2(p,a);
}
result_type
Comparison_result
operator()( const Circular_arc_point_2 &p,const Line_arc_2 &a ) const
{return _compare_y_at_x_2(p,a);}
};
template <class BK>
class Has_on_2 : public BK::Circular_kernel:: template Base< BK >::Type::Has_on_2
{
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Has_on_2 CK_Has_on_2;
typedef CK_Has_on_2 Base;
typedef typename BK::Boolean Boolean;
typedef typename BK::Circular_arc_2 Circular_arc_2;
typedef typename BK::Circular_arc_point_2 Circular_arc_point_2;
typedef typename BK::Line_arc_2 Line_arc_2;
public:
typedef typename CK_Has_on_2::result_type result_type;
using Base::operator();
private:
template <class Arc_2>
result_type
Boolean
_has_on_2(const Arc_2 &a, const Circular_arc_point_2 &p) const
{
Bbox_2 bb1=a.bbox(),bb2=p.bbox();
@ -278,27 +260,26 @@ private:
}
public:
result_type
Boolean
operator()( const Circular_arc_2 &a,const Circular_arc_point_2 &p ) const
{
CGAL_precondition( a.is_x_monotone());
return _has_on_2(a,p);
}
result_type
Boolean
operator()( const Line_arc_2 &a, const Circular_arc_point_2 &p ) const
{return _has_on_2(a,p);}
};
template <class BK>
class Equal_2
: public BK::Circular_kernel:: template Base< BK >::Type::Equal_2
{
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Equal_2 CK_Equal_2;
typedef typename BK::Boolean Boolean;
typedef typename BK::Circular_arc_2 Circular_arc_2;
typedef typename BK::Point_2 Point_2;
typedef typename BK::Direction_2 Direction_2;
@ -315,15 +296,11 @@ class Equal_2
typedef CK_Equal_2 Base;
public:
typedef typename CK_Equal_2::result_type result_type;
using Base::operator();
private:
template <class Arc_2>
result_type
Boolean
_equal_2(const Arc_2 &a,const Arc_2 &b) const
{
Bbox_2 bb11=a.source().bbox(),
@ -346,8 +323,7 @@ private:
}
public:
result_type
Boolean
operator()( const Circular_arc_point_2 &a ,
const Circular_arc_point_2 &b) const
{
@ -361,14 +337,15 @@ public:
/* WAS THAT HERE FOR OTHER COMPILERS THAN VC* ???
// redefine to solve ambiguous call error
result_type
Boolean
operator()( const Point_2 &a ,
const Point_2 &b) const
{
return CK_Equal_2()( a, b);
}
*/
result_type
Boolean
operator()( const Circular_arc_2 &a , const Circular_arc_2 &b ) const
{
CGAL_precondition( a.is_x_monotone());
@ -377,17 +354,17 @@ public:
return _equal_2(a,b);
}
result_type
Boolean
operator()( const Line_arc_2 &a ,
const Line_arc_2 &b ) const
{ return _equal_2(a,b);}
result_type
Boolean
operator()( const Circular_arc_2 & ,
const Line_arc_2 & ) const
{ return false;}
result_type
Boolean
operator()( const Line_arc_2 & ,
const Circular_arc_2 & ) const
{ return false;}
@ -401,19 +378,17 @@ class Do_overlap_2 : public BK::Circular_kernel:: template Base< BK >::Type::Do_
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Do_overlap_2 CK_Do_overlap_2;
typedef CK_Do_overlap_2 Base;
typedef typename BK::Boolean Boolean;
typedef typename BK::Circular_arc_2 Circular_arc_2;
typedef typename BK::Line_arc_2 Line_arc_2;
public:
typedef typename CK_Do_overlap_2::result_type result_type;
using Base::operator();
private:
template <class Arc_2>
result_type
Boolean
_do_overlap_2(const Arc_2 &a, const Arc_2 &b) const
{
Bbox_2 bb1=a.bbox(),bb2=b.bbox();
@ -424,10 +399,8 @@ private:
return false;
}
public:
result_type
Boolean
operator()( const Circular_arc_2 &a , const Circular_arc_2 &b ) const
{
CGAL_precondition( a.is_x_monotone());
@ -435,28 +408,26 @@ public:
return _do_overlap_2(a,b);
}
result_type
Boolean
operator()( const Line_arc_2 &a ,
const Line_arc_2 &b ) const
{ return _do_overlap_2(a,b);}
result_type
Boolean
operator()( const Circular_arc_2 & ,
const Line_arc_2 & ) const
{ return false;}
result_type
Boolean
operator()( const Line_arc_2 & ,
const Circular_arc_2 & ) const
{ return false;}
};
template < class BK >
class Intersect_2 : public BK::Circular_kernel:: template Base< BK >::Type::Intersect_2
{
public:
typedef typename BK::Circular_kernel::
template Base< BK >::Type::Intersect_2 CK_Intersect_2;
@ -466,6 +437,7 @@ public:
typedef typename BK::Circle_2 Circle;
typedef typename BK::Line_2 Line_2;
public:
using CK_Intersect_2::operator();
template < class OutputIterator >

392
Circular_kernel_3/include/CGAL/Circular_kernel_3/function_objects_polynomial_sphere.h
View File

@ -42,21 +42,27 @@ namespace SphericalFunctors {
#define CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_(V)\
template < class SK > \
class Compare_ ##V## _3: public SK::Linear_kernel::Compare_ ##V## _3{\
class Compare_ ##V## _3 {\
/*: public SK::Linear_kernel::Compare_ ##V## _3{*/\
typedef typename SK::Comparison_result Comparison_result;\
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;\
typedef typename SK::Point_3 Point_3;\
typedef typename SK::Linear_kernel::Compare_ ##V## _3 Linear_Compare_ ##V## _3;\
public:\
typedef typename SK::Linear_kernel::Compare_ ##V## _3::result_type result_type;\
using SK::Linear_kernel::Compare_ ##V## _3::operator();\
result_type\
template <typename A, typename B> \
Comparison_result\
operator()(const A& a, const B& b) const\
{ return Linear_Compare_ ##V## _3()(a, b); }\
/*using SK::Linear_kernel::Compare_ ##V## _3::operator();*/\
Comparison_result\
operator() (const Circular_arc_point_3 &p0,\
const Circular_arc_point_3 &p1) const\
{ return SphericalFunctors::compare_ ##V <SK>(p0, p1); }\
result_type\
Comparison_result\
operator() (const Circular_arc_point_3 &p0,\
const Point_3 &p1) const\
{ return SphericalFunctors::compare_ ##V <SK>(p0, p1); }\
result_type\
Comparison_result\
operator() (const Point_3 &p0,\
const Circular_arc_point_3 &p1) const\
{ return SphericalFunctors::compare_ ##V <SK>(p0, p1); }\
@ -68,6 +74,8 @@ template < class SK > \
CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_(xy)
CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_(xyz)
#undef CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_
template <class SK>
class Compute_circular_x_3
{
@ -103,11 +111,9 @@ template < class SK > \
template < class SK >
class Equal_3
: public SK::Linear_kernel::Equal_3
// : public SK::Linear_kernel::Equal_3
{
typedef typename SK::Linear_kernel LK;
typedef typename LK::Equal_3 LK_Equal_3;
typedef typename SK::Boolean Boolean;
typedef typename SK::Point_3 Point_3;
typedef typename SK::Vector_3 Vector_3;
typedef typename SK::Direction_3 Direction_3;
@ -125,35 +131,39 @@ template < class SK > \
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
typedef typename SK::Linear_kernel::Equal_3 Linear_equal_3;
public:
// using SK::Linear_kernel::Equal_3::operator();
typedef typename SK::Linear_kernel::Equal_3::result_type result_type;
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_equal_3()(a, b); }
using SK::Linear_kernel::Equal_3::operator();
result_type
Boolean
operator() (const Circular_arc_point_3 &c0,
const Circular_arc_point_3 &c1) const
{ return SphericalFunctors::equal<SK>(c0, c1); }
result_type
Boolean
operator() (const Circular_arc_point_3 &c0,
const Point_3 &c1) const
{ return SphericalFunctors::equal<SK>(c0, Circular_arc_point_3(c1)); }
result_type
Boolean
operator() (const Point_3 &c0,
const Circular_arc_point_3 &c1) const
{ return SphericalFunctors::equal<SK>(Circular_arc_point_3(c0), c1); }
// Our Line_arc_3 dont have orientation
result_type
Boolean
operator() (const Line_arc_3 &l0,
const Line_arc_3 &l1) const
{ return SphericalFunctors::equal<SK>(l0, l1); }
// Our Circular_arc_3 dont have orientation (as parameter)
result_type
Boolean
operator() (const Circular_arc_3 &c0,
const Circular_arc_3 &c1) const
{ return SphericalFunctors::equal<SK>(c0, c1); }
@ -175,29 +185,26 @@ template < class SK > \
typedef typename Circular_arc_point_3::Root_for_spheres_2_3 Root_for_spheres_2_3;
public:
typedef Circular_arc_point_3 result_type;
result_type
Circular_arc_point_3
operator()(void)
{ return Rep(); }
result_type
operator()(const Root_of_2 & x,
const Root_of_2 & y,
const Root_of_2 & z
) const
Circular_arc_point_3
operator()(const Root_of_2 & x,
const Root_of_2 & y,
const Root_of_2 & z) const
{ return Rep(x,y,z); }
result_type
Circular_arc_point_3
operator()(const Root_for_spheres_2_3 & np) const
{ return Rep(np); }
result_type
Circular_arc_point_3
operator()(const Point_3 & p) const
{ return Rep(p); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Sphere_3 & s1,
const Sphere_3 & s2,
const Sphere_3 & s3,
@ -205,7 +212,7 @@ template < class SK > \
{ return Rep(s1,s2,s3,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Plane_3 & p,
const Sphere_3 & s1,
const Sphere_3 & s2,
@ -213,7 +220,7 @@ template < class SK > \
{ return Rep(p,s1,s2,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Sphere_3 & s1,
const Plane_3 & p,
const Sphere_3 & s2,
@ -221,7 +228,7 @@ template < class SK > \
{ return Rep(p,s1,s2,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Sphere_3 & s1,
const Sphere_3 & s2,
const Plane_3 & p,
@ -229,7 +236,7 @@ template < class SK > \
{ return Rep(p,s1,s2,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Plane_3 & p1,
const Plane_3 & p2,
const Sphere_3 & s,
@ -237,7 +244,7 @@ template < class SK > \
{ return Rep(p1,p2,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Plane_3 & p1,
const Sphere_3 & s,
const Plane_3 & p2,
@ -245,7 +252,7 @@ template < class SK > \
{ return Rep(p1,p2,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Sphere_3 & s,
const Plane_3 & p1,
const Plane_3 & p2,
@ -253,42 +260,42 @@ template < class SK > \
{ return Rep(p1,p2,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Line_3 & l,
const Sphere_3 & s,
const bool less_xyz = true) const
{ return Rep(l,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Sphere_3 & s,
const Line_3 & l,
const bool less_xyz = true) const
{ return Rep(l,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Circle_3 & c,
const Sphere_3 & s,
const bool less_xyz = true) const
{ return Rep(c,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Sphere_3 & s,
const Circle_3 & c,
const bool less_xyz = true) const
{ return Rep(c,s,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Circle_3 & c,
const Plane_3 & p,
const bool less_xyz = true) const
{ return Rep(c,p,less_xyz); }
// Not Documented
result_type
Circular_arc_point_3
operator()(const Plane_3 & p,
const Circle_3 & c,
const bool less_xyz = true) const
@ -466,8 +473,6 @@ template < class SK > \
{ return c.rep().supporting_plane(); }
};
template <class SK>
class Construct_line_3
{
@ -611,43 +616,41 @@ template < class SK > \
typedef typename Line_arc_3::Rep Rep;
public:
typedef Line_arc_3 result_type;
result_type
Line_arc_3
operator()(void) const
{ return Rep(); }
result_type
Line_arc_3
operator()(const Line_3 &l,
const Circular_arc_point_3 &s,
const Circular_arc_point_3 &t) const
{ return Rep(l,s,t); }
result_type
Line_arc_3
operator()(const Point_3 &s,
const Point_3 &t) const
{ return Rep(s,t); }
result_type
Line_arc_3
operator()(const Segment_3 &s) const
{ return Rep(s); }
// Not Documented
result_type
Line_arc_3
operator()(const Line_3 &l,
const Sphere_3 &s,
bool less_xyz_first = true) const
{ return Rep(l,s,less_xyz_first); }
// Not Documented
result_type
Line_arc_3
operator()(const Sphere_3 &s,
const Line_3 &l,
bool less_xyz_first = true) const
{ return Rep(l,s,less_xyz_first); }
// Not Documented
result_type
Line_arc_3
operator()(const Line_3 &l,
const Sphere_3 &s1, bool less_xyz_s1,
const Sphere_3 &s2, bool less_xyz_s2) const
@ -655,7 +658,7 @@ template < class SK > \
s2,less_xyz_s2); }
// Not Documented
result_type
Line_arc_3
operator()(const Sphere_3 &s1, bool less_xyz_s1,
const Sphere_3 &s2, bool less_xyz_s2,
const Line_3 &l) const
@ -663,14 +666,14 @@ template < class SK > \
s2,less_xyz_s2); }
// Not Documented
result_type
Line_arc_3
operator()(const Line_3 &l,
const Plane_3 &p1,
const Plane_3 &p2) const
{ return Rep(l,p1,p2); }
// Not Documented
result_type
Line_arc_3
operator()(const Plane_3 &p1,
const Plane_3 &p2,
const Line_3 &l) const
@ -694,56 +697,55 @@ template < class SK > \
typedef typename SK::Circular_arc_3 Circular_arc_3;
typedef typename SK::Kernel_base::Circular_arc_3 RCircular_arc_3;
typedef typename Circular_arc_3::Rep Rep;
public:
typedef Circular_arc_3 result_type;
result_type
public:
Circular_arc_3
operator()(void) const
{ return Rep(); }
result_type
Circular_arc_3
operator()(const Circle_3 &c) const
{ return Rep(c); }
result_type
Circular_arc_3
operator()(const Circle_3 &c,const Circular_arc_point_3& pt) const
{ return Rep(c,pt); }
result_type
Circular_arc_3
operator()(const Circle_3 &l,
const Circular_arc_point_3 &s,
const Circular_arc_point_3 &t) const
{ return Rep(l,s,t); }
// Not Documented
result_type
Circular_arc_3
operator()(const Circle_3 &c,
const Sphere_3 &s1, bool less_xyz_s1,
const Sphere_3 &s2, bool less_xyz_s2) const
{ return Rep(c,s1,less_xyz_s1,s2,less_xyz_s2); }
// Not Documented
result_type
Circular_arc_3
operator()(const Sphere_3 &s1, bool less_xyz_s1,
const Sphere_3 &s2, bool less_xyz_s2,
const Circle_3 &c) const
{ return Rep(c,s1,less_xyz_s1,s2,less_xyz_s2); }
// Not Documented
result_type
Circular_arc_3
operator()(const Circle_3 &c,
const Plane_3 &p1, bool less_xyz_p1,
const Plane_3 &p2, bool less_xyz_p2) const
{ return Rep(c,p1,less_xyz_p1,p2,less_xyz_p2); }
// Not Documented
result_type
Circular_arc_3
operator()(const Plane_3 &p1, bool less_xyz_p1,
const Plane_3 &p2, bool less_xyz_p2,
const Circle_3 &c) const
{ return Rep(c,p1,less_xyz_p1,p2,less_xyz_p2); }
result_type
Circular_arc_3
operator()(const Point_3 &begin,
const Point_3 &middle,
const Point_3 &end) const
@ -755,13 +757,9 @@ template < class SK > \
class Construct_circular_min_vertex_3
{
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
public:
typedef const Circular_arc_point_3& result_type;
result_type operator() (const Line_arc_3 & a) const
decltype(auto) operator() (const Line_arc_3& a) const
{ return (a.rep().lower_xyz_extremity()); }
};
@ -770,13 +768,9 @@ template < class SK > \
class Construct_circular_max_vertex_3
{
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
public:
typedef const Circular_arc_point_3& result_type;
result_type operator() (const Line_arc_3 & a) const
decltype(auto) operator() (const Line_arc_3& a) const
{ return (a.rep().higher_xyz_extremity()); }
};
@ -786,16 +780,12 @@ template < class SK > \
{
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
public:
typedef const Circular_arc_point_3& result_type;
result_type operator() (const Line_arc_3 & a) const
decltype(auto) operator() (const Line_arc_3& a) const
{ return (a.rep().source()); }
result_type operator() (const Circular_arc_3 & a) const
decltype(auto) operator() (const Circular_arc_3& a) const
{ return (a.rep().source()); }
};
@ -804,30 +794,27 @@ template < class SK > \
class Construct_circular_target_vertex_3
{
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
public:
typedef const Circular_arc_point_3& result_type;
result_type operator() (const Line_arc_3 & a) const
decltype(auto) operator() (const Line_arc_3 & a) const
{ return (a.rep().target()); }
result_type operator() (const Circular_arc_3 & a) const
decltype(auto) operator() (const Circular_arc_3 & a) const
{ return (a.rep().target()); }
};
template < class SK >
class Has_on_3
: public SK::Linear_kernel::Has_on_3
// : public SK::Linear_kernel::Has_on_3
{
typedef typename SK::Boolean Boolean;
typedef typename SK::Point_3 Point_3;
typedef typename SK::Sphere_3 Sphere_3;
typedef typename SK::Plane_3 Plane_3;
typedef typename SK::Line_3 Line_3;
typedef typename SK::Segment_3 Segment_3;
typedef typename SK::Segment_3 Segment_3;
typedef typename SK::Ray_3 Ray_3;
typedef typename SK::Triangle_3 Triangle_3;
typedef typename SK::Line_arc_3 Line_arc_3;
@ -835,69 +822,73 @@ template < class SK > \
typedef typename SK::Circular_arc_3 Circular_arc_3;
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Linear_kernel::Has_on_3 Linear_Has_on_3;
public:
typedef typename SK::Linear_kernel::Has_on_3::result_type result_type;
// using SK::Linear_kernel::Has_on_3::operator();
using SK::Linear_kernel::Has_on_3::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Has_on_3()(a, b); }
result_type
Boolean
operator()(const Sphere_3 &a, const Circular_arc_point_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Plane_3 &a, const Circular_arc_point_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Line_3 &a, const Circular_arc_point_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Circle_3 &a, const Circular_arc_point_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Line_arc_3 &a, const Circular_arc_point_3 &p,
const bool already_know_point_on_line = false) const
{ return SphericalFunctors::has_on<SK>(a, p, already_know_point_on_line); }
result_type
Boolean
operator()(const Line_arc_3 &a, const Point_3 &p,
const bool already_know_point_on_line = false) const
{ return SphericalFunctors::has_on<SK>(a, p, already_know_point_on_line); }
result_type
Boolean
operator()(const Plane_3 &p, const Line_arc_3 &a) const
{ return SphericalFunctors::has_on<SK>(p, a); }
result_type
Boolean
operator()(const Line_3 &a, const Line_arc_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Circular_arc_3 &a, const Point_3 &p,
const bool has_on_supporting_circle = false) const
{ return SphericalFunctors::has_on<SK>(a, p, has_on_supporting_circle); }
result_type
Boolean
operator()(const Circular_arc_3 &a, const Circular_arc_point_3 &p,
const bool has_on_supporting_circle = false) const
{ return SphericalFunctors::has_on<SK>(a, p, has_on_supporting_circle); }
result_type
Boolean
operator()(const Sphere_3 &a, const Circular_arc_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Plane_3 &a, const Circular_arc_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Circle_3 &a, const Circular_arc_3 &p) const
{ return SphericalFunctors::has_on<SK>(a, p); }
result_type
Boolean
operator()(const Circular_arc_3 &p, const Circle_3 &a) const
{ return SphericalFunctors::has_on<SK>(p, a); }
@ -905,9 +896,9 @@ template < class SK > \
template < class SK >
class Do_intersect_3
: public SK::Linear_kernel::Do_intersect_3
// : public SK::Linear_kernel::Do_intersect_3
{
typedef typename SK::Boolean Boolean;
typedef typename SK::Sphere_3 Sphere_3;
typedef typename SK::Line_3 Line_3;
typedef typename SK::Line_arc_3 Line_arc_3;
@ -916,20 +907,25 @@ template < class SK > \
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Circle_3 Circular_arc_point_3;
public:
typedef typename SK::Linear_kernel::Do_intersect_3::result_type result_type;
typedef typename SK::Linear_kernel::Do_intersect_3 Linear_Do_intersect_3;
using SK::Linear_kernel::Do_intersect_3::operator();
public:
// using SK::Linear_kernel::Do_intersect_3::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Do_intersect_3()(a, b); }
#define CGAL_SPHERICAL_KERNEL_MACRO_DO_INTERSECTION_3_2(A,B) \
result_type \
Boolean \
operator()(const A & c1, const B & c2) const \
{ std::vector< typename SK3_Intersection_traits<SK, A, B>::type > res; \
typename SK::Intersect_3()(c1,c2,std::back_inserter(res)); \
return !res.empty(); }
#define CGAL_SPHERICAL_KERNEL_MACRO_DO_INTERSECTION_3_3(A,B,C) \
result_type \
Boolean \
operator()(const A & c1, const B & c2, const C & c3) const \
{ std::vector< typename SK3_Intersection_traits<SK, A, B, C>::type > res; \
typename SK::Intersect_3()(c1,c2,c3,std::back_inserter(res)); \
@ -987,22 +983,21 @@ template < class SK > \
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
public:
typedef typename SK::Linear_kernel::Intersect_3 Linear_Intersect_3;
public:
//using SK::Linear_kernel::Intersect_3::operator();
typedef typename SK::Linear_kernel::Intersect_3 Intersect_linear_3;
template<class A, class B>
template <typename A, typename B>
decltype(auto)
operator()(const A& a, const B& b) const{
return Intersect_linear_3()(a,b);
return Linear_Intersect_3()(a,b);
}
decltype(auto)
operator()(const Plane_3& p, const Plane_3& q, const Plane_3& r) const
{
return Intersect_linear_3()(p, q, r);
return Linear_Intersect_3()(p, q, r);
}
template < class OutputIterator >
@ -1217,18 +1212,17 @@ template < class SK > \
template < class SK >
class Do_overlap_3
{
typedef typename SK::Boolean Boolean;
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
public:
typedef bool result_type;
result_type
Boolean
operator() (const Line_arc_3 &l1, const Line_arc_3 &l2,
const bool known_equal_supporting_line = false) const
{ return SphericalFunctors::do_overlap<SK>(l1, l2, known_equal_supporting_line); }
result_type
Boolean
operator() (const Circular_arc_3 &c1, const Circular_arc_3 &c2,
const bool known_equal_supporting_circle = false) const
{ return SphericalFunctors::do_overlap<SK>(c1, c2, known_equal_supporting_circle); }
@ -1243,16 +1237,13 @@ template < class SK > \
typedef typename SK::Circular_arc_3 Circular_arc_3;
public:
typedef void result_type;
result_type
void
operator()(const Line_arc_3 &l,
const Circular_arc_point_3 &p,
Line_arc_3 &ca1, Line_arc_3 &ca2) const
{ return SphericalFunctors::split<SK>(l, p, ca1, ca2); }
result_type
void
operator()(const Circular_arc_3 &c,
const Circular_arc_point_3 &p,
Circular_arc_3 &ca1, Circular_arc_3 &ca2) const
@ -1262,7 +1253,7 @@ template < class SK > \
template <class SK>
class Construct_bbox_3
: public SK::Linear_kernel::Construct_bbox_3
// : public SK::Linear_kernel::Construct_bbox_3
{
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
@ -1275,8 +1266,15 @@ template < class SK > \
typedef typename SK::Iso_cuboid_3 Iso_cuboid_3;
typedef typename SK::Line_arc_3 Line_arc_3;
typedef typename SK::Linear_kernel::Construct_bbox_3 Linear_Construct_bbox_3;
public:
using SK::Linear_kernel::Construct_bbox_3::operator();
// using SK::Linear_kernel::Construct_bbox_3::operator();
template<class A>
decltype(auto)
operator()(const A& a) const
{ return Linear_Construct_bbox_3()(a); }
decltype(auto) operator() (const Circular_arc_point_3 & c) const
{ return c.rep().bbox(); }
@ -1291,60 +1289,73 @@ template < class SK > \
template <class SK>
class Compute_approximate_squared_length_3
: public SK::Linear_kernel::Compute_approximate_squared_length_3
// : public SK::Linear_kernel::Compute_approximate_squared_length_3
{
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
typedef typename SK::FT FT;
typedef typename SK::Linear_kernel::Compute_approximate_squared_length_3 Linear_Compute_approximate_squared_length_3;
public:
typedef double result_type;
// using SK::Linear_kernel::Compute_approximate_squared_length_3::operator();
using SK::Linear_kernel::Compute_approximate_squared_length_3::operator();
template<class A>
double
operator()(const A& a) const
{ return Linear_Compute_approximate_squared_length_3()(a); }
result_type operator() (const Circular_arc_3 & c) const
double operator() (const Circular_arc_3 & c) const
{ return c.rep().approximate_squared_length(); }
};
template <class SK>
class Compute_approximate_angle_3
: public SK::Linear_kernel::Compute_approximate_angle_3
// : public SK::Linear_kernel::Compute_approximate_angle_3
{
typedef typename SK::Point_3 Point_3;
typedef typename SK::Vector_3 Vector_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
typedef typename SK::FT FT;
typedef typename SK::Linear_kernel::Compute_approximate_angle_3 Linear_Compute_approximate_angle_3;
public:
typedef double result_type;
// using SK::Linear_kernel::Compute_approximate_angle_3::operator();
using SK::Linear_kernel::Compute_approximate_angle_3::operator();
template <class... Args>
decltype(auto) // the linear kernel has "FT" as return type...
operator()(const Args&... args) const
{ return Linear_Compute_approximate_angle_3()(args...); }
result_type operator() (const Circular_arc_3 & c) const
double operator() (const Circular_arc_3 & c) const
{ return c.rep().approximate_angle(); }
};
template <class SK>
class Bounded_side_3
: public SK::Linear_kernel::Bounded_side_3
// : public SK::Linear_kernel::Bounded_side_3
{
typedef typename SK::Bounded_side Bounded_side;
typedef typename SK::Sphere_3 Sphere_3;
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Point_3 Point_3;
typedef typename SK::Linear_kernel::Bounded_side_3 Linear_Bounded_side_3;
public:
typedef typename SK::Linear_kernel::Bounded_side_3::result_type result_type;
// using SK::Linear_kernel::Bounded_side_3::operator();
using SK::Linear_kernel::Bounded_side_3::operator();
template <typename A, typename B>
Bounded_side
operator()(const A& a, const B& b) const
{ return Linear_Bounded_side_3()(a, b); }
result_type
Bounded_side
operator()( const Sphere_3& s, const Circular_arc_point_3& p) const
{ return SphericalFunctors::bounded_side<SK>(s,p); }
result_type
Bounded_side
operator()( const Circle_3& c, const Circular_arc_point_3& p) const
{ return SphericalFunctors::bounded_side<SK>(c,p); }
@ -1354,23 +1365,29 @@ template < class SK > \
template <class SK>
class Has_on_bounded_side_3
: public SK::Linear_kernel::Has_on_bounded_side_3
// : public SK::Linear_kernel::Has_on_bounded_side_3
{
typedef typename SK::Boolean Boolean;
typedef typename SK::Sphere_3 Sphere_3;
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Point_3 Point_3;
typedef typename SK::Linear_kernel::Has_on_bounded_side_3 Linear_Has_on_bounded_side_3;
public:
typedef typename SK::Linear_kernel::Has_on_bounded_side_3::result_type result_type;
// using SK::Linear_kernel::Has_on_bounded_side_3::operator();
using SK::Linear_kernel::Has_on_bounded_side_3::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Has_on_bounded_side_3()(a, b); }
result_type
Boolean
operator()( const Sphere_3& s, const Circular_arc_point_3& p) const
{ return SK().bounded_side_3_object()(s,p) == ON_BOUNDED_SIDE; }
result_type
Boolean
operator()( const Circle_3& c, const Circular_arc_point_3& p) const
{ return SK().bounded_side_3_object()(c,p) == ON_BOUNDED_SIDE; }
@ -1380,87 +1397,93 @@ template < class SK > \
template <class SK>
class Has_on_unbounded_side_3
: public SK::Linear_kernel::Has_on_unbounded_side_3
// : public SK::Linear_kernel::Has_on_unbounded_side_3
{
typedef typename SK::Boolean Boolean;
typedef typename SK::Sphere_3 Sphere_3;
typedef typename SK::Circle_3 Circle_3;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Point_3 Point_3;
typedef typename SK::Linear_kernel::Has_on_unbounded_side_3 Linear_Has_on_unbounded_side_3;
public:
typedef typename SK::Linear_kernel::Has_on_unbounded_side_3::result_type result_type;
// using SK::Linear_kernel::Has_on_unbounded_side_3::operator();
using SK::Linear_kernel::Has_on_unbounded_side_3::operator();
template <typename A, typename B>
Boolean
operator()(const A& a, const B& b) const
{ return Linear_Has_on_unbounded_side_3()(a, b); }
result_type
Boolean
operator()( const Sphere_3& s, const Circular_arc_point_3& p) const
{ return SK().bounded_side_3_object()(s,p) == ON_UNBOUNDED_SIDE; }
result_type
Boolean
operator()( const Circle_3& c, const Circular_arc_point_3& p) const
{ return SK().bounded_side_3_object()(c,p) == ON_UNBOUNDED_SIDE; }
// We can maybe optimize it doing the operator() for point_3 too
};
template <class SK>
class Is_theta_monotone_3{
class Is_theta_monotone_3
{
typename SK::Sphere_3 sphere_;
public:
typedef bool result_type;
public:
Is_theta_monotone_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
result_type
typename SK::Boolean
operator()(const typename SK::Circular_arc_3& arc) const {
return SphericalFunctors::is_theta_monotone_3<SK>(arc,sphere_);
}
};
template < class SK >
class Compare_theta_3{
class Compare_theta_3
{
typedef typename SK::Comparison_result Comparison_result;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Vector_3 Vector_3;
typedef typename SK::Vector_3 Vector_3;
typename SK::Sphere_3 sphere_;
public:
typedef CGAL::Comparison_result result_type;
Compare_theta_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
result_type
Comparison_result
operator() (const Circular_arc_point_3 &p0,
const Circular_arc_point_3 &p1) const
{ return SphericalFunctors::compare_theta_of_pts<SK>(p0, p1,sphere_); }
result_type
Comparison_result
operator() (const Circular_arc_point_3 &p,
const Vector_3 &v) const
{ return SphericalFunctors::compare_theta_pt_vector<SK>(p,v,sphere_); }
result_type
Comparison_result
operator() (const Vector_3 &m1,
const Vector_3 &m2) const
{ return SphericalFunctors::compare_theta_vectors<SK>(m1,m2); }
result_type
Comparison_result
operator() (const Vector_3 &v,const Circular_arc_point_3 &p0) const
{ return CGAL::opposite( SphericalFunctors::compare_theta_pt_vector<SK>(p0, v,sphere_) ); }
};
template < class SK >
class Compare_theta_z_3{
class Compare_theta_z_3
{
typedef typename SK::Comparison_result Comparison_result;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typename SK::Sphere_3 sphere_;
public:
typedef CGAL::Comparison_result result_type;
Compare_theta_z_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
result_type
Comparison_result
operator() (const Circular_arc_point_3 &p0,
const Circular_arc_point_3 &p1,bool decreasing_z=false) const
{ return SphericalFunctors::compare_theta_z<SK>(p0, p1,sphere_,decreasing_z); }
@ -1468,7 +1491,8 @@ template < class SK > \
};
template < class SK >
class Make_theta_monotone_3{
class Make_theta_monotone_3
{
typename SK::Sphere_3 sphere_;
public:
@ -1487,16 +1511,18 @@ template < class SK > \
};
template <class SK>
class Compare_z_to_right_3{
class Compare_z_to_right_3
{
typedef typename SK::Comparison_result Comparison_result;
typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
typedef typename SK::Circular_arc_3 Circular_arc_3;
typename SK::Sphere_3 sphere_;
public:
typedef CGAL::Comparison_result result_type;
Compare_z_to_right_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
result_type
Comparison_result
operator()(const Circular_arc_3& arc1,const Circular_arc_3& arc2,const Circular_arc_point_3& pt,bool do_to_the_left=false){
CGAL_kernel_precondition(SK().has_on_3_object()(sphere_,arc1));
CGAL_kernel_precondition(SK().has_on_3_object()(sphere_,arc2));
@ -1519,14 +1545,16 @@ template < class SK > \
};
template <class SK>
class Compare_z_at_theta_3{
typename SK::Sphere_3 sphere_;
class Compare_z_at_theta_3
{
typedef typename SK::Comparison_result Comparison_result;
typename SK::Sphere_3 sphere_;
public:
typedef CGAL::Comparison_result result_type;
Compare_z_at_theta_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
result_type
Comparison_result
operator()( const typename SK::Circular_arc_3& arc1,
const typename SK::Circular_arc_3& arc2,
const typename SK::Vector_3& m) const
@ -1534,7 +1562,7 @@ template < class SK > \
return SphericalFunctors::compare_z_at_theta_arcs<SK>(arc1,arc2,m,sphere_);
}
result_type
Comparison_result
operator()(const typename SK::Circular_arc_point_3& point,
const typename SK::Circular_arc_3& arc) const
{

4
Circular_kernel_3/include/CGAL/Circular_kernel_3/internal_functions_on_sphere_3.h
View File

@ -85,7 +85,7 @@ namespace CGAL {
template < class SK >
inline
typename SK::Linear_kernel::Bounded_side_3::result_type
typename SK::Bounded_side
bounded_side(const typename SK::Sphere_3 &s,
const typename SK::Circular_arc_point_3 &p) {
typedef typename SK::Algebraic_kernel Algebraic_kernel;
@ -99,7 +99,7 @@ namespace CGAL {
template < class SK >
inline
typename SK::Linear_kernel::Bounded_side
typename SK::Bounded_side
bounded_side(const typename SK::Circle_3 &c,
const typename SK::Circular_arc_point_3 &p) {
typedef typename SK::Algebraic_kernel Algebraic_kernel;

4
Circular_kernel_3/include/CGAL/Spherical_kernel_intersections.h
View File

@ -46,7 +46,7 @@ intersection(const A <K> &c1, const B <K> &c2, OutputIterator res) \
} \
template <class K> \
inline \
bool \
typename K::Boolean \
do_intersect(const A <K> &c1, const B <K> &c2) \
{ \
return typename K::Do_intersect_3()(c1, c2); \
@ -61,7 +61,7 @@ intersection(const A <K> &c1, const B <K> &c2, const C <K> &c3, OutputIterator r
} \
template <class K> \
inline \
bool \
typename K::Boolean \
do_intersect(const A <K> &c1, const B <K> &c2, const C <K> &c3) \
{ \
return typename K::Do_intersect_3()(c1, c2, c3); \

2
NewKernel_d/include/CGAL/NewKernel_d/Cartesian_static_filters.h
View File

@ -22,6 +22,8 @@ namespace CGAL {
namespace SFA { // static filter adapter
// Note that this would be quite a bit simpler without stateful kernels
template <class Base_,class R_> struct Adapter_2 {
typedef typename Get_type<R_, Orientation_tag>::type Orientation;
typedef typename Get_type<R_, Oriented_side_tag>::type Oriented_side;
typedef typename Get_type<R_, Point_tag>::type Point;
typedef typename Get_functor<R_, Compute_point_cartesian_coordinate_tag>::type CC;
typedef typename Get_functor<Base_, Orientation_of_points_tag>::type Orientation_base;