Merge branch 'Aos_2-boundary_objects-efic-old' into Aos_2-boundary_objects-efic
|
|
@ -55,7 +55,7 @@ namespace CGAL {
|
|||
|
||||
# define Min_bounded(ver) \
|
||||
( ((ver).min_parameter_space() == ARR_BOTTOM_BOUNDARY ) ? false : true )
|
||||
|
||||
|
||||
|
||||
template <class Traits_>
|
||||
class Arr_traits_with_vertical_segments
|
||||
|
|
@ -63,30 +63,30 @@ class Arr_traits_with_vertical_segments
|
|||
public:
|
||||
typedef Traits_ Traits;
|
||||
typedef Arr_traits_with_vertical_segments<Traits> Self;
|
||||
|
||||
|
||||
typedef typename Traits::Algebraic_kernel_d_1 Algebraic_kernel_d_1;
|
||||
|
||||
typedef typename Traits::Point_2 Point_2;
|
||||
typedef typename Traits::Multiplicity Multiplicity;
|
||||
typedef typename Traits::Algebraic_real_1 Algebraic_real_1;
|
||||
typedef typename Traits::Rat_vector Rat_vector;
|
||||
typedef typename Traits::Coefficient Coefficient;
|
||||
typedef typename Traits::Coefficient Coefficient;
|
||||
|
||||
typedef typename Traits::Integer Integer;
|
||||
typedef typename Traits::Rational Rational;
|
||||
typedef typename Traits::Polynomial_1 Polynomial_1;
|
||||
typedef typename Traits::Rational Rational;
|
||||
typedef typename Traits::Polynomial_1 Polynomial_1;
|
||||
typedef typename Traits::Rational_function Rational_function;
|
||||
|
||||
|
||||
|
||||
typedef typename Traits::X_monotone_curve_2 Non_vertical_x_curve_2;
|
||||
typedef typename Traits::Curve_2 Non_vertical_curve_2;
|
||||
typedef typename Traits::Vertical_segment Vertical_segment;
|
||||
|
||||
typedef Arr_vertical_rational_arc::Rational_arc_with_ver_d_1
|
||||
typedef Arr_vertical_rational_arc::Rational_arc_with_ver_d_1
|
||||
<Non_vertical_x_curve_2,Algebraic_kernel_d_1> X_monotone_curve_2;
|
||||
typedef Arr_vertical_rational_arc::Rational_arc_with_ver_d_1
|
||||
typedef Arr_vertical_rational_arc::Rational_arc_with_ver_d_1
|
||||
<Non_vertical_curve_2,Algebraic_kernel_d_1> Curve_2;
|
||||
|
||||
|
||||
//Category tags:
|
||||
typedef Tag_true Has_left_category;
|
||||
typedef Tag_true Has_merge_category;
|
||||
|
|
@ -121,17 +121,17 @@ public:
|
|||
Construct_point_2 (Traits& traits) :_traits(traits) {}
|
||||
Point_2 operator() (const Rational_function& rational_function,
|
||||
const Algebraic_real_1& x_coordinate)
|
||||
{
|
||||
{
|
||||
return _traits.construct_point_2_object()(rational_function,x_coordinate);
|
||||
}
|
||||
Point_2 operator() (const Rational& x,const Rational& y)
|
||||
{
|
||||
{
|
||||
return _traits.construct_point_2_object()(x,y);
|
||||
}
|
||||
Point_2 operator() (const Algebraic_real_1& x,const Rational& y)
|
||||
{
|
||||
return _traits.construct_point_2_object()(x,y);
|
||||
}
|
||||
}
|
||||
}; //Construct_point_2
|
||||
|
||||
Construct_point_2 construct_point_2_object() const {return Construct_point_2(_traits);}
|
||||
|
|
@ -141,7 +141,7 @@ public:
|
|||
private:
|
||||
Traits& _traits;
|
||||
public:
|
||||
Construct_vertical_x_curve_2(Traits& traits)
|
||||
Construct_vertical_x_curve_2(Traits& traits)
|
||||
:_traits(traits)
|
||||
{}
|
||||
|
||||
|
|
@ -184,7 +184,7 @@ public:
|
|||
{
|
||||
return _traits.construct_vertical_segment_object()(p,is_directed_up);
|
||||
}
|
||||
|
||||
|
||||
}; //Construct_vertical_curve_2
|
||||
|
||||
Construct_vertical_curve_2 construct_vertical_curve_2_object () const
|
||||
|
|
@ -194,48 +194,48 @@ public:
|
|||
|
||||
class Construct_curve_2
|
||||
{
|
||||
private:
|
||||
private:
|
||||
typedef typename Traits::Algebraic_real_1 Algebraic_real_1;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Construct_curve_2 (Traits& traits)
|
||||
Construct_curve_2 (Traits& traits)
|
||||
:_traits(traits)
|
||||
{}
|
||||
template <class InputIterator>
|
||||
Curve_2 operator() (InputIterator begin, InputIterator end) const
|
||||
{
|
||||
return _traits.construct_curve_2_object()(begin,end);
|
||||
return _traits.construct_curve_2_object()(begin,end);
|
||||
}
|
||||
template <class InputIterator>
|
||||
Curve_2 operator() (InputIterator begin, InputIterator end,const Algebraic_real_1& x_s, bool dir_right) const
|
||||
{
|
||||
return _traits.construct_curve_2_object()(begin,end,x_s,dir_right);
|
||||
return _traits.construct_curve_2_object()(begin,end,x_s,dir_right);
|
||||
}
|
||||
template <class InputIterator>
|
||||
Curve_2 operator() (InputIterator begin, InputIterator end,
|
||||
const Algebraic_real_1& x_s, const Algebraic_real_1& x_t) const
|
||||
{
|
||||
return _traits.construct_curve_2_object()(begin,end,x_s,x_t);
|
||||
return _traits.construct_curve_2_object()(begin,end,x_s,x_t);
|
||||
}
|
||||
template <class InputIterator>
|
||||
Curve_2 operator() (InputIterator begin_numer, InputIterator end_numer,
|
||||
InputIterator begin_denom, InputIterator end_denom) const
|
||||
InputIterator begin_denom, InputIterator end_denom) const
|
||||
{
|
||||
return _traits.construct_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom);
|
||||
return _traits.construct_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom);
|
||||
}
|
||||
template <class InputIterator>
|
||||
Curve_2 operator() (InputIterator begin_numer, InputIterator end_numer,
|
||||
InputIterator begin_denom, InputIterator end_denom,
|
||||
const Algebraic_real_1& x_s, bool dir_right) const
|
||||
{
|
||||
return _traits.construct_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,dir_right);
|
||||
return _traits.construct_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,dir_right);
|
||||
}
|
||||
template <class InputIterator>
|
||||
Curve_2 operator() (InputIterator begin_numer, InputIterator end_numer,
|
||||
InputIterator begin_denom, InputIterator end_denom,
|
||||
const Algebraic_real_1& x_s, const Algebraic_real_1& x_t) const
|
||||
{
|
||||
return _traits.construct_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,x_t);
|
||||
return _traits.construct_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,x_t);
|
||||
}
|
||||
}; //Construct_rational_curve_2
|
||||
|
||||
|
|
@ -245,7 +245,7 @@ public:
|
|||
}
|
||||
class Construct_x_monotone_curve_2
|
||||
{
|
||||
private:
|
||||
private:
|
||||
typedef typename Traits::Algebraic_real_1 Algebraic_real_1;
|
||||
Traits& _traits;
|
||||
public:
|
||||
|
|
@ -255,39 +255,39 @@ public:
|
|||
template <class InputIterator>
|
||||
X_monotone_curve_2 operator() (InputIterator begin, InputIterator end) const
|
||||
{
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin,end);
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin,end);
|
||||
}
|
||||
template <class InputIterator>
|
||||
X_monotone_curve_2 operator() ( InputIterator begin, InputIterator end,
|
||||
const Algebraic_real_1& x_s, bool dir_right) const
|
||||
{
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin,end,x_s,dir_right);
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin,end,x_s,dir_right);
|
||||
}
|
||||
template <class InputIterator>
|
||||
X_monotone_curve_2 operator() (InputIterator begin, InputIterator end,
|
||||
const Algebraic_real_1& x_s, const Algebraic_real_1& x_t) const
|
||||
{
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin,end,x_s,x_t);
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin,end,x_s,x_t);
|
||||
}
|
||||
template <class InputIterator>
|
||||
X_monotone_curve_2 operator() ( InputIterator begin_numer, InputIterator end_numer,
|
||||
InputIterator begin_denom, InputIterator end_denom) const
|
||||
InputIterator begin_denom, InputIterator end_denom) const
|
||||
{
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom);
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom);
|
||||
}
|
||||
template <class InputIterator>
|
||||
X_monotone_curve_2 operator() ( InputIterator begin_numer, InputIterator end_numer,
|
||||
InputIterator begin_denom, InputIterator end_denom,
|
||||
const Algebraic_real_1& x_s, bool dir_right) const
|
||||
{
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,dir_right);
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,dir_right);
|
||||
}
|
||||
template <class InputIterator>
|
||||
X_monotone_curve_2 operator() ( InputIterator begin_numer, InputIterator end_numer,
|
||||
InputIterator begin_denom, InputIterator end_denom,
|
||||
const Algebraic_real_1& x_s, const Algebraic_real_1& x_t) const
|
||||
{
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,x_t);
|
||||
return _traits.construct_x_monotone_curve_2_object()(begin_numer, end_numer,begin_denom,end_denom,x_s,x_t);
|
||||
}
|
||||
}; //Construct_rational_x_curve_2
|
||||
|
||||
|
|
@ -300,7 +300,7 @@ public:
|
|||
//------------------------
|
||||
|
||||
//---------------------------------------------------------------
|
||||
//A functor that compares the x-coordinates of two points
|
||||
//A functor that compares the x-coordinates of two points
|
||||
class Compare_x_2
|
||||
{
|
||||
private:
|
||||
|
|
@ -348,7 +348,7 @@ public:
|
|||
|
||||
/*! A functor that obtains the left endpoint of a curve. */
|
||||
class Construct_min_vertex_2
|
||||
{
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
public:
|
||||
|
|
@ -466,7 +466,7 @@ public:
|
|||
class Compare_y_at_x_2
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Compare_y_at_x_2(Traits& traits) : _traits(traits) {}
|
||||
/*!
|
||||
|
|
@ -497,10 +497,10 @@ public:
|
|||
}
|
||||
Comparison_result operator() (const Vertical_segment & cv) const
|
||||
{
|
||||
CGAL_precondition(_traits.compare_x_2_object()(_p,cv.max()) == CGAL::EQUAL);
|
||||
CGAL_precondition(_traits.compare_x_2_object()(_p,cv.max()) == CGAL::EQUAL);
|
||||
|
||||
typename Traits::Compare_xy_2 compare_xy_2 = _traits.compare_xy_2_object();
|
||||
|
||||
|
||||
if (Is_line(cv))
|
||||
return CGAL::EQUAL;
|
||||
if ((Max_bounded(cv)) && (!Min_bounded(cv)) )
|
||||
|
|
@ -544,7 +544,7 @@ public:
|
|||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Comparison_result> Base;
|
||||
Compare_y_at_x_left_2_visitor(Traits& traits,const Point_2& p)
|
||||
Compare_y_at_x_left_2_visitor(Traits& traits,const Point_2& p)
|
||||
: _traits(traits), _p(p), Base() {}
|
||||
Comparison_result operator() (const Non_vertical_x_curve_2 & cv1,
|
||||
const Non_vertical_x_curve_2 & cv2) const
|
||||
|
|
@ -579,7 +579,7 @@ public:
|
|||
/*! A functor that compares compares the y-coordinates of two curves
|
||||
* immediately to the left of their intersection point.
|
||||
*/
|
||||
|
||||
|
||||
/*! A functor that checks whether two points and two curves are identical. */
|
||||
class Equal_2
|
||||
{
|
||||
|
|
@ -610,34 +610,34 @@ public:
|
|||
if (&p1 == &p2)
|
||||
return (true);
|
||||
return _traits.equal_2_object() (p1,p2);
|
||||
|
||||
|
||||
}
|
||||
private:
|
||||
class Equal_2_visitor
|
||||
: public boost::static_visitor <bool>
|
||||
{
|
||||
private:
|
||||
typedef boost::static_visitor <bool> Base;
|
||||
typedef boost::static_visitor <bool> Base;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Equal_2_visitor(Traits& traits) : _traits(traits), Base() {}
|
||||
bool operator() (const Non_vertical_x_curve_2& cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
{
|
||||
return _traits.equal_2_object() (cv1,cv2);
|
||||
}
|
||||
bool operator() (const Non_vertical_x_curve_2& cv1,
|
||||
const Vertical_segment & cv2) const
|
||||
const Vertical_segment & cv2) const
|
||||
{
|
||||
return false;
|
||||
return false;
|
||||
}
|
||||
bool operator() (const Vertical_segment & cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
{
|
||||
return false;
|
||||
return false;
|
||||
}
|
||||
bool operator() (const Vertical_segment & cv1,
|
||||
const Vertical_segment & cv2) const
|
||||
const Vertical_segment & cv2) const
|
||||
{
|
||||
if (&cv1 == &cv2)
|
||||
return (true);
|
||||
|
|
@ -657,7 +657,7 @@ public:
|
|||
|
||||
if (Min_bounded(cv1) && Min_bounded(cv2))
|
||||
return (_traits.equal_2_object() (cv1.min(),cv2.min() ));
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
}; //Equal_2_visitor
|
||||
|
|
@ -672,12 +672,12 @@ public:
|
|||
/*! A functor that divides a curve into continues (x-monotone) curves. */
|
||||
class Make_x_monotone_2
|
||||
{
|
||||
private:
|
||||
private:
|
||||
Traits& _traits;
|
||||
public:
|
||||
Make_x_monotone_2(Traits& traits) : _traits(traits) {}
|
||||
template<class OutputIterator>
|
||||
OutputIterator operator() (const Curve_2& cv, OutputIterator oi) const
|
||||
OutputIterator operator() (const Curve_2& cv, OutputIterator oi) const
|
||||
{
|
||||
Object_vector res (boost::apply_visitor(Make_x_monotone_2_visitor(_traits),cv.variant()));
|
||||
re_cast_object_vector(res,oi);
|
||||
|
|
@ -688,17 +688,17 @@ public:
|
|||
: public boost::static_visitor < Object_vector >
|
||||
{
|
||||
private:
|
||||
typedef boost::static_visitor <Object_vector> Base;
|
||||
typedef boost::static_visitor <Object_vector> Base;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Make_x_monotone_2_visitor(Traits& traits) : _traits(traits), Base() {}
|
||||
Object_vector operator() (const Non_vertical_curve_2& cv) const
|
||||
Object_vector operator() (const Non_vertical_curve_2& cv) const
|
||||
{
|
||||
Object_vector vec;
|
||||
_traits.make_x_monotone_2_object() (cv,std::back_inserter(vec));
|
||||
return vec;
|
||||
}
|
||||
Object_vector operator() (const Vertical_segment & cv) const
|
||||
Object_vector operator() (const Vertical_segment & cv) const
|
||||
{
|
||||
Object_vector vec;
|
||||
vec.push_back(make_object (Vertical_segment(cv)));
|
||||
|
|
@ -743,7 +743,7 @@ public:
|
|||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Res_type> Base;
|
||||
Split_2_visitor(Traits& traits,const Point_2 & p)
|
||||
Split_2_visitor(Traits& traits,const Point_2 & p)
|
||||
: _traits(traits),_p(p), Base() {}
|
||||
Res_type operator() (const Non_vertical_x_curve_2& cv) const
|
||||
{
|
||||
|
|
@ -751,9 +751,9 @@ public:
|
|||
_traits.split_2_object() (cv,_p,_c1,_c2);
|
||||
return Res_type(_c1,_c2);
|
||||
}
|
||||
Res_type operator() (const Vertical_segment & cv) const
|
||||
Res_type operator() (const Vertical_segment & cv) const
|
||||
{
|
||||
typename Traits::Construct_vertical_segment
|
||||
typename Traits::Construct_vertical_segment
|
||||
construct_vertical_segment = _traits.construct_vertical_segment_object();
|
||||
Vertical_segment _c1,_c2;
|
||||
if (Is_line(cv))
|
||||
|
|
@ -794,7 +794,7 @@ public:
|
|||
class Intersect_2
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
Traits& _traits;
|
||||
public:
|
||||
/*!
|
||||
* Find the intersections of the two given curves and insert them to the
|
||||
|
|
@ -809,7 +809,7 @@ public:
|
|||
template<class OutputIterator>
|
||||
OutputIterator operator() ( const X_monotone_curve_2& cv1,
|
||||
const X_monotone_curve_2& cv2,
|
||||
OutputIterator oi) const
|
||||
OutputIterator oi) const
|
||||
{
|
||||
Object_vector res (boost::apply_visitor(Intersect_2_visitor(_traits),cv1.variant(),cv2.variant()));
|
||||
re_cast_object_vector(res,oi);
|
||||
|
|
@ -823,12 +823,12 @@ public:
|
|||
typedef boost::static_visitor <Object_vector> Base;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Intersect_2_visitor(Traits& traits)
|
||||
Intersect_2_visitor(Traits& traits)
|
||||
: _traits(traits), Base() {}
|
||||
|
||||
//intersection of two Non_vertical_x_curve_2
|
||||
Object_vector operator() (const Non_vertical_x_curve_2& cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
{
|
||||
Object_vector vec;
|
||||
_traits.intersect_2_object() (cv1,cv2,std::back_inserter(vec));
|
||||
|
|
@ -836,7 +836,7 @@ public:
|
|||
}
|
||||
//intersection of a Non_vertical_x_curve_2 and a Vertical_segment
|
||||
Object_vector operator() (const Vertical_segment& cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
{
|
||||
Object_vector vec;
|
||||
_traits.intersect_2_object() (cv2,cv1,std::back_inserter(vec));
|
||||
|
|
@ -844,7 +844,7 @@ public:
|
|||
}
|
||||
//intersection of a Non_vertical_x_curve_2 and a Vertical_segment
|
||||
Object_vector operator() (const Non_vertical_x_curve_2& cv1,
|
||||
const Vertical_segment& cv2) const
|
||||
const Vertical_segment& cv2) const
|
||||
{
|
||||
Object_vector vec;
|
||||
_traits.intersect_2_object() (cv1,cv2,std::back_inserter(vec));
|
||||
|
|
@ -852,7 +852,7 @@ public:
|
|||
}
|
||||
//intersection of two Vertical_segment
|
||||
Object_vector operator() (const Vertical_segment& cv1,
|
||||
const Vertical_segment& cv2) const
|
||||
const Vertical_segment& cv2) const
|
||||
{
|
||||
Object_vector vec;
|
||||
CGAL::Object object;
|
||||
|
|
@ -862,7 +862,7 @@ public:
|
|||
object = make_object(Vertical_segment(cv2));
|
||||
else if (Is_line(cv2))
|
||||
object = make_object(Vertical_segment(cv1));
|
||||
|
||||
|
||||
if (object.empty() == false)
|
||||
{
|
||||
vec.push_back(object);
|
||||
|
|
@ -894,9 +894,9 @@ public:
|
|||
Object_vector intersect_ray_ray ( const Vertical_segment& ray1,
|
||||
const Vertical_segment& ray2) const
|
||||
{
|
||||
typename Traits::Compare_xy_2
|
||||
typename Traits::Compare_xy_2
|
||||
compare_xy_2 = _traits.compare_xy_2_object();
|
||||
typename Traits::Construct_vertical_segment
|
||||
typename Traits::Construct_vertical_segment
|
||||
construct_vertical_segment = _traits.construct_vertical_segment_object();
|
||||
|
||||
CGAL_precondition (Is_ray(ray1));
|
||||
|
|
@ -952,10 +952,10 @@ public:
|
|||
{
|
||||
CGAL_precondition (Is_ray(ray));
|
||||
CGAL_precondition (Is_segment(seg));
|
||||
|
||||
typename Traits::Compare_xy_2
|
||||
|
||||
typename Traits::Compare_xy_2
|
||||
compare_xy_2 = _traits.compare_xy_2_object();
|
||||
typename Traits::Construct_vertical_segment
|
||||
typename Traits::Construct_vertical_segment
|
||||
construct_vertical_segment = _traits.construct_vertical_segment_object();
|
||||
|
||||
Object_vector vec;
|
||||
|
|
@ -967,7 +967,7 @@ public:
|
|||
Comparison_result cr = compare_xy_2 (ray.min(),seg.min());
|
||||
if (cr != LARGER)
|
||||
object = make_object (seg);
|
||||
else
|
||||
else
|
||||
{
|
||||
cr = compare_xy_2 (ray.min(),seg.max());
|
||||
if (cr == LARGER)
|
||||
|
|
@ -984,7 +984,7 @@ public:
|
|||
Comparison_result cr = compare_xy_2 (ray.max(),seg.max());
|
||||
if (cr != SMALLER)
|
||||
object = make_object (seg);
|
||||
else
|
||||
else
|
||||
{
|
||||
cr = compare_xy_2 (ray.max(),seg.min());
|
||||
if (cr == SMALLER)
|
||||
|
|
@ -1005,11 +1005,11 @@ public:
|
|||
CGAL_precondition (Is_segment(seg1));
|
||||
CGAL_precondition (Is_segment(seg2));
|
||||
|
||||
typename Traits::Compare_xy_2
|
||||
typename Traits::Compare_xy_2
|
||||
compare_xy_2 = _traits.compare_xy_2_object();
|
||||
typename Traits::Construct_vertical_segment
|
||||
typename Traits::Construct_vertical_segment
|
||||
construct_vertical_segment = _traits.construct_vertical_segment_object();
|
||||
|
||||
|
||||
Object_vector vec;
|
||||
CGAL::Object object;
|
||||
|
||||
|
|
@ -1024,18 +1024,18 @@ public:
|
|||
Comparison_result cr1 = compare_xy_2 (seg1.min(),seg2.min());
|
||||
Comparison_result cr2 = compare_xy_2 (seg1.max(),seg2.max());
|
||||
|
||||
if ( (cr1 == CGAL::LARGER ) &&
|
||||
if ( (cr1 == CGAL::LARGER ) &&
|
||||
(cr2 == CGAL::LARGER ) )
|
||||
object = make_object (construct_vertical_segment(seg1.min(),seg2.max()));
|
||||
else if ( (cr1 == CGAL::LARGER ) &&
|
||||
else if ( (cr1 == CGAL::LARGER ) &&
|
||||
(cr2 == CGAL::SMALLER ) )
|
||||
object = make_object (construct_vertical_segment(seg1.min(),seg1.max()));
|
||||
else if ( (cr1 == CGAL::SMALLER) &&
|
||||
else if ( (cr1 == CGAL::SMALLER) &&
|
||||
(cr2 == CGAL::LARGER ) )
|
||||
object = make_object (construct_vertical_segment(seg2.min(),seg2.max()));
|
||||
else //SMALLER,SMALLER
|
||||
object = make_object (construct_vertical_segment(seg2.min(),seg1.max()));
|
||||
|
||||
|
||||
vec.push_back(object);
|
||||
return vec;
|
||||
}
|
||||
|
|
@ -1072,10 +1072,10 @@ public:
|
|||
: public boost::static_visitor <bool>
|
||||
{
|
||||
private:
|
||||
typedef boost::static_visitor <bool> Base;
|
||||
typedef boost::static_visitor <bool> Base;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Are_mergeable_2_visitor(Traits& traits)
|
||||
Are_mergeable_2_visitor(Traits& traits)
|
||||
: _traits(traits), Base() {}
|
||||
bool operator() ( const Non_vertical_x_curve_2& cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
|
|
@ -1108,7 +1108,7 @@ public:
|
|||
if (_traits.equal_2_object()(cv1.min(),cv2.min()))
|
||||
return true;
|
||||
}
|
||||
//try to merge at minimum and maximum
|
||||
//try to merge at minimum and maximum
|
||||
if ((Max_bounded(cv1)) && (Min_bounded(cv2)))
|
||||
{
|
||||
res = (_traits.equal_2_object()(cv1.max(),cv2.min()));
|
||||
|
|
@ -1147,7 +1147,7 @@ public:
|
|||
const X_monotone_curve_2& cv2,
|
||||
X_monotone_curve_2& c) const
|
||||
{
|
||||
c = boost::apply_visitor(Merge_2_visitor(_traits),cv1.variant(),cv2.variant());
|
||||
c = boost::apply_visitor(Merge_2_visitor(_traits),cv1.variant(),cv2.variant());
|
||||
return;
|
||||
}
|
||||
private:
|
||||
|
|
@ -1155,7 +1155,7 @@ public:
|
|||
: public boost::static_visitor <X_monotone_curve_2>
|
||||
{
|
||||
private:
|
||||
typedef boost::static_visitor <X_monotone_curve_2> Base;
|
||||
typedef boost::static_visitor <X_monotone_curve_2> Base;
|
||||
Traits& _traits;
|
||||
public:
|
||||
Merge_2_visitor(Traits& traits) : _traits(traits), Base() {}
|
||||
|
|
@ -1178,14 +1178,14 @@ public:
|
|||
}
|
||||
X_monotone_curve_2 operator() (const Vertical_segment& cv1,const Vertical_segment& cv2) const
|
||||
{
|
||||
typename Traits::Construct_vertical_segment
|
||||
typename Traits::Construct_vertical_segment
|
||||
construct_vertical_segment = _traits.construct_vertical_segment_object();
|
||||
|
||||
typename Traits::Compare_xy_2
|
||||
typename Traits::Compare_xy_2
|
||||
compare_xy_2 = _traits.compare_xy_2_object();
|
||||
|
||||
Vertical_segment _c;
|
||||
if ((Max_bounded(cv1)) &&
|
||||
if ((Max_bounded(cv1)) &&
|
||||
(Max_bounded(cv2)) &&
|
||||
(compare_xy_2(cv1.max() , cv2.max()) == CGAL::EQUAL))
|
||||
{
|
||||
|
|
@ -1198,7 +1198,7 @@ public:
|
|||
return _c;
|
||||
}
|
||||
|
||||
if ((Min_bounded(cv1)) &&
|
||||
if ((Min_bounded(cv1)) &&
|
||||
(Min_bounded(cv2)) &&
|
||||
(compare_xy_2(cv1.min() , cv2.min()) == CGAL::EQUAL))
|
||||
{
|
||||
|
|
@ -1211,7 +1211,7 @@ public:
|
|||
return _c;
|
||||
}
|
||||
|
||||
if ((Max_bounded(cv1)) &&
|
||||
if ((Max_bounded(cv1)) &&
|
||||
(Min_bounded(cv2)) &&
|
||||
(compare_xy_2(cv1.max() , cv2.min()) == CGAL::EQUAL))
|
||||
{
|
||||
|
|
@ -1270,7 +1270,7 @@ public:
|
|||
{
|
||||
return (boost::apply_visitor(Parameter_space_in_x_2_visitor(_traits,ce),xcv.variant()));
|
||||
}
|
||||
|
||||
|
||||
/*! Obtains the parameter space at a point along the x-axis.
|
||||
* \param p the point.
|
||||
* \return the parameter space at p.
|
||||
|
|
@ -1285,7 +1285,7 @@ public:
|
|||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Arr_parameter_space> Base;
|
||||
Parameter_space_in_x_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
Parameter_space_in_x_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
:_traits(traits), _ce(ce), Base() {}
|
||||
Arr_parameter_space operator()(const Non_vertical_x_curve_2& xcv ) const
|
||||
{
|
||||
|
|
@ -1304,14 +1304,14 @@ public:
|
|||
|
||||
/*! Obtain a Parameter_space_in_x_2 function object */
|
||||
Parameter_space_in_x_2 parameter_space_in_x_2_object() const
|
||||
{
|
||||
return Parameter_space_in_x_2(_traits);
|
||||
{
|
||||
return Parameter_space_in_x_2(_traits);
|
||||
}
|
||||
|
||||
|
||||
/*! A function object that obtains the parameter space of a geometric
|
||||
* entity along the y-axis
|
||||
*/
|
||||
class Parameter_space_in_y_2
|
||||
class Parameter_space_in_y_2
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
|
|
@ -1348,14 +1348,14 @@ public:
|
|||
//{
|
||||
// return ARR_INTERIOR;
|
||||
//}
|
||||
|
||||
|
||||
private:
|
||||
class Parameter_space_in_y_2_visitor
|
||||
: public boost::static_visitor <Arr_parameter_space>
|
||||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Arr_parameter_space> Base;
|
||||
Parameter_space_in_y_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
Parameter_space_in_y_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
:_traits(traits),_ce(ce), Base() {}
|
||||
Arr_parameter_space operator()(const Non_vertical_x_curve_2& xcv ) const
|
||||
{
|
||||
|
|
@ -1393,7 +1393,7 @@ public:
|
|||
* defined (lexicographically) to its right.
|
||||
* \return The relative position of cv1 with respect to cv2 immdiately to
|
||||
* the right of p: SMALLER, LARGER or EQUAL.
|
||||
*/
|
||||
*/
|
||||
Compare_y_at_x_right_2 (Traits& traits) : _traits(traits) {}
|
||||
Comparison_result operator() (const X_monotone_curve_2& cv1,
|
||||
const X_monotone_curve_2& cv2,
|
||||
|
|
@ -1407,27 +1407,27 @@ public:
|
|||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Comparison_result> Base;
|
||||
Compare_y_at_x_right_2_visitor(Traits& traits,const Point_2& p)
|
||||
Compare_y_at_x_right_2_visitor(Traits& traits,const Point_2& p)
|
||||
: _traits(traits), _p(p), Base() {}
|
||||
Comparison_result operator() (const Non_vertical_x_curve_2& cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
{
|
||||
return _traits.compare_y_at_x_right_2_object() (cv1,cv2,_p);
|
||||
}
|
||||
Comparison_result operator() (const Non_vertical_x_curve_2& cv1,
|
||||
const Vertical_segment & cv2) const
|
||||
const Vertical_segment & cv2) const
|
||||
{
|
||||
return CGAL::SMALLER;
|
||||
}
|
||||
Comparison_result operator() (const Vertical_segment & cv1,
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
const Non_vertical_x_curve_2& cv2) const
|
||||
{
|
||||
return CGAL::LARGER;
|
||||
}
|
||||
Comparison_result operator() (const Vertical_segment & cv1,
|
||||
const Vertical_segment & cv2) const
|
||||
const Vertical_segment & cv2) const
|
||||
{
|
||||
return CGAL::EQUAL; //test bug fix
|
||||
return CGAL::EQUAL; //test bug fix
|
||||
}
|
||||
private:
|
||||
Traits& _traits;
|
||||
|
|
@ -1441,32 +1441,32 @@ public:
|
|||
{
|
||||
return Compare_y_at_x_right_2(_traits);
|
||||
}
|
||||
class Compare_x_near_limit_2
|
||||
class Compare_x_near_boundary_2
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
public:
|
||||
Compare_x_near_limit_2 (Traits& traits) : _traits(traits) {}
|
||||
Comparison_result operator()( const X_monotone_curve_2& xcv1,
|
||||
const X_monotone_curve_2& xcv2,
|
||||
Compare_x_near_boundary_2 (Traits& traits) : _traits(traits) {}
|
||||
Comparison_result operator()( const X_monotone_curve_2& xcv1,
|
||||
const X_monotone_curve_2& xcv2,
|
||||
Arr_curve_end ce) const
|
||||
{
|
||||
return (boost::apply_visitor(Compare_x_near_limit_2_visitor(_traits,ce),xcv1.variant(),xcv2.variant()));
|
||||
return (boost::apply_visitor(Compare_x_near_boundary_2_visitor(_traits,ce),xcv1.variant(),xcv2.variant()));
|
||||
}
|
||||
private:
|
||||
class Compare_x_near_limit_2_visitor
|
||||
class Compare_x_near_boundary_2_visitor
|
||||
: public boost::static_visitor <Comparison_result>
|
||||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Comparison_result> Base;
|
||||
Compare_x_near_limit_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
Compare_x_near_boundary_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
:_traits(traits), _ce(ce), Base() {}
|
||||
Comparison_result operator()(const Non_vertical_x_curve_2& xcv1,const Non_vertical_x_curve_2& xcv2 ) const
|
||||
{
|
||||
return _traits.compare_x_near_limit_2_object()(xcv1,xcv2,_ce);
|
||||
return _traits.compare_x_near_boundary_2_object()(xcv1,xcv2,_ce);
|
||||
}
|
||||
Comparison_result operator()(const Non_vertical_x_curve_2& xcv1,const Vertical_segment& xcv2 ) const
|
||||
{
|
||||
{
|
||||
if (_ce == ARR_MIN_END)
|
||||
{
|
||||
CGAL_precondition (xcv2.min_parameter_space() == CGAL::ARR_BOTTOM_BOUNDARY);
|
||||
|
|
@ -1478,7 +1478,7 @@ public:
|
|||
return CGAL::SMALLER;
|
||||
}
|
||||
|
||||
return _traits.compare_x_at_limit_2_object()(xcv2.max(),xcv1,_ce);
|
||||
return _traits.compare_x_on_boundary_2_object()(xcv2.max(),xcv1,_ce);
|
||||
}
|
||||
Comparison_result operator()(const Vertical_segment& xcv1,const Non_vertical_x_curve_2& xcv2 ) const
|
||||
{
|
||||
|
|
@ -1499,56 +1499,56 @@ public:
|
|||
CGAL_precondition (xcv1.min_parameter_space() == CGAL::ARR_BOTTOM_BOUNDARY);
|
||||
else //_ce1 == ARR_MAX_END
|
||||
CGAL_precondition (xcv1.max_parameter_space() == CGAL::ARR_TOP_BOUNDARY);
|
||||
|
||||
|
||||
if (_ce == ARR_MIN_END)
|
||||
CGAL_precondition (xcv2.min_parameter_space() == CGAL::ARR_BOTTOM_BOUNDARY);
|
||||
else //_ce2 == ARR_MAX_END
|
||||
CGAL_precondition (xcv2.max_parameter_space() == CGAL::ARR_TOP_BOUNDARY);
|
||||
|
||||
|
||||
return _traits.compare_x_2_object() (xcv1.min(),xcv2.min());
|
||||
}
|
||||
|
||||
private:
|
||||
Traits& _traits;
|
||||
Arr_curve_end _ce;
|
||||
}; //Compare_x_near_limit_2_visitor
|
||||
}; //Compare_x_near_limit_2
|
||||
}; //Compare_x_near_boundary_2_visitor
|
||||
}; //Compare_x_near_boundary_2
|
||||
|
||||
Compare_x_near_limit_2 compare_x_near_limit_2_object() const
|
||||
Compare_x_near_boundary_2 compare_x_near_boundary_2_object() const
|
||||
{
|
||||
return Compare_x_near_limit_2(_traits);
|
||||
return Compare_x_near_boundary_2(_traits);
|
||||
}
|
||||
|
||||
class Compare_x_at_limit_2
|
||||
class Compare_x_on_boundary_2
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
public:
|
||||
Compare_x_at_limit_2 (Traits& traits) :_traits(traits) {}
|
||||
Compare_x_on_boundary_2 (Traits& traits) :_traits(traits) {}
|
||||
Comparison_result operator()( const Point_2 & p,
|
||||
const X_monotone_curve_2 & xcv,
|
||||
Arr_curve_end ce) const
|
||||
{
|
||||
return (boost::apply_visitor(Compare_x_at_limit_2_visitor_1(_traits,ce,p),xcv.variant()));
|
||||
return (boost::apply_visitor(Compare_x_on_boundary_2_visitor_1(_traits,ce,p),xcv.variant()));
|
||||
}
|
||||
Comparison_result operator()( const X_monotone_curve_2 & xcv1,
|
||||
Arr_curve_end ce1,
|
||||
const X_monotone_curve_2 & xcv2,
|
||||
Arr_curve_end ce2) const
|
||||
{
|
||||
return (boost::apply_visitor(Compare_x_at_limit_2_visitor_2(_traits,ce1,ce2),xcv1.variant(),xcv2.variant()));
|
||||
return (boost::apply_visitor(Compare_x_on_boundary_2_visitor_2(_traits,ce1,ce2),xcv1.variant(),xcv2.variant()));
|
||||
}
|
||||
private:
|
||||
class Compare_x_at_limit_2_visitor_1
|
||||
class Compare_x_on_boundary_2_visitor_1
|
||||
: public boost::static_visitor <Comparison_result>
|
||||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Comparison_result> Base;
|
||||
Compare_x_at_limit_2_visitor_1(Traits& traits,Arr_curve_end ce,const Point_2 & p)
|
||||
Compare_x_on_boundary_2_visitor_1(Traits& traits,Arr_curve_end ce,const Point_2 & p)
|
||||
:_traits(traits), _ce(ce), _p(p), Base() {}
|
||||
Comparison_result operator()(const Non_vertical_x_curve_2& xcv ) const
|
||||
{
|
||||
return _traits.compare_x_at_limit_2_object()(_p,xcv,_ce);
|
||||
return _traits.compare_x_on_boundary_2_object()(_p,xcv,_ce);
|
||||
}
|
||||
Comparison_result operator()(const Vertical_segment& xcv) const
|
||||
{
|
||||
|
|
@ -1562,18 +1562,18 @@ public:
|
|||
Traits& _traits;
|
||||
Point_2 _p;
|
||||
Arr_curve_end _ce;
|
||||
}; //Compare_x_at_limit_2_visitor_1
|
||||
|
||||
class Compare_x_at_limit_2_visitor_2
|
||||
}; //Compare_x_on_boundary_2_visitor_1
|
||||
|
||||
class Compare_x_on_boundary_2_visitor_2
|
||||
: public boost::static_visitor <Comparison_result>
|
||||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Comparison_result> Base;
|
||||
Compare_x_at_limit_2_visitor_2(Traits& traits,Arr_curve_end ce1,Arr_curve_end ce2)
|
||||
Compare_x_on_boundary_2_visitor_2(Traits& traits,Arr_curve_end ce1,Arr_curve_end ce2)
|
||||
:_traits(traits), _ce1(ce1), _ce2(ce2), Base() {}
|
||||
Comparison_result operator()(const Non_vertical_x_curve_2& xcv1,const Non_vertical_x_curve_2& xcv2 ) const
|
||||
{
|
||||
return _traits.compare_x_at_limit_2_object()(xcv1,_ce1,xcv2,_ce2);
|
||||
return _traits.compare_x_on_boundary_2_object()(xcv1,_ce1,xcv2,_ce2);
|
||||
}
|
||||
Comparison_result operator()(const Non_vertical_x_curve_2& xcv1,const Vertical_segment& xcv2 ) const
|
||||
{
|
||||
|
|
@ -1582,7 +1582,7 @@ public:
|
|||
else //_ce2 == ARR_MAX_END
|
||||
CGAL_precondition (xcv2.max_parameter_space() == CGAL::ARR_TOP_BOUNDARY);
|
||||
|
||||
return _traits.compare_x_at_limit_2_object()(xcv2.max(),xcv1,_ce1);
|
||||
return _traits.compare_x_on_boundary_2_object()(xcv2.max(),xcv1,_ce1);
|
||||
}
|
||||
Comparison_result operator()(const Vertical_segment& xcv1,const Non_vertical_x_curve_2& xcv2 ) const
|
||||
{
|
||||
|
|
@ -1591,7 +1591,7 @@ public:
|
|||
else //_ce1 == ARR_MAX_END
|
||||
CGAL_precondition (xcv1.max_parameter_space() == CGAL::ARR_TOP_BOUNDARY);
|
||||
|
||||
return _traits.compare_x_at_limit_2_object()(xcv1.max(),xcv2,_ce2);
|
||||
return _traits.compare_x_on_boundary_2_object()(xcv1.max(),xcv2,_ce2);
|
||||
}
|
||||
Comparison_result operator()(const Vertical_segment& xcv1,const Vertical_segment& xcv2 ) const
|
||||
{
|
||||
|
|
@ -1599,27 +1599,27 @@ public:
|
|||
CGAL_precondition (xcv1.min_parameter_space() == CGAL::ARR_BOTTOM_BOUNDARY);
|
||||
else //_ce1 == ARR_MAX_END
|
||||
CGAL_precondition (xcv1.max_parameter_space() == CGAL::ARR_TOP_BOUNDARY);
|
||||
|
||||
|
||||
if (_ce2 == ARR_MIN_END)
|
||||
CGAL_precondition (xcv2.min_parameter_space() == CGAL::ARR_BOTTOM_BOUNDARY);
|
||||
else //_ce2 == ARR_MAX_END
|
||||
CGAL_precondition (xcv2.max_parameter_space() == CGAL::ARR_TOP_BOUNDARY);
|
||||
|
||||
|
||||
return _traits.compare_x_2_object() (xcv1.min(),xcv2.min());
|
||||
}
|
||||
private:
|
||||
Traits& _traits;
|
||||
Arr_curve_end _ce1,_ce2;
|
||||
}; //Compare_x_at_limit_2_visitor_2
|
||||
}; //Compare_x_at_limit_2
|
||||
}; //Compare_x_on_boundary_2_visitor_2
|
||||
}; //Compare_x_on_boundary_2
|
||||
|
||||
/*! Obtain a Compare_x_at_limit_2 function object */
|
||||
Compare_x_at_limit_2 compare_x_at_limit_2_object() const
|
||||
{ return Compare_x_at_limit_2(_traits); }
|
||||
/*! Obtain a Compare_x_on_boundary_2 function object */
|
||||
Compare_x_on_boundary_2 compare_x_on_boundary_2_object() const
|
||||
{ return Compare_x_on_boundary_2(_traits); }
|
||||
/*! A function object that compares the y-coordinates of arc ends near the
|
||||
* boundary of the parameter space.
|
||||
*/
|
||||
class Compare_y_near_boundary_2
|
||||
class Compare_y_near_boundary_2
|
||||
{
|
||||
private:
|
||||
Traits& _traits;
|
||||
|
|
@ -1646,7 +1646,7 @@ public:
|
|||
{
|
||||
public:
|
||||
typedef boost::static_visitor <Comparison_result> Base;
|
||||
Compare_y_near_boundary_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
Compare_y_near_boundary_2_visitor(Traits& traits,Arr_curve_end ce)
|
||||
:_traits(traits), _ce(ce), Base() {}
|
||||
Comparison_result operator()(const Non_vertical_x_curve_2& xcv1,const Non_vertical_x_curve_2& xcv2 ) const
|
||||
{
|
||||
|
|
@ -1680,7 +1680,7 @@ public:
|
|||
Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const
|
||||
{ return Compare_y_near_boundary_2(_traits); }
|
||||
//@}
|
||||
|
||||
|
||||
/// \name Functor definitions for the Boolean set-operation traits.
|
||||
//@{
|
||||
class Compare_endpoints_xy_2
|
||||
|
|
@ -1751,7 +1751,7 @@ public:
|
|||
}
|
||||
public:
|
||||
template<class OutputIterator>
|
||||
static void re_cast_object_vector(const Object_vector& vec,OutputIterator& oi)
|
||||
static void re_cast_object_vector(const Object_vector& vec,OutputIterator& oi)
|
||||
{
|
||||
for (Object_vector::const_iterator it = vec.begin() ; it != vec.end(); ++it)
|
||||
{
|
||||
|
|
@ -1784,7 +1784,7 @@ public:
|
|||
}
|
||||
else
|
||||
CGAL_precondition(false);
|
||||
|
||||
|
||||
++oi;
|
||||
}
|
||||
return;
|
||||
|
|
@ -1796,4 +1796,3 @@ public:
|
|||
#endif // CGAL_DONT_SUBMIT
|
||||
|
||||
#endif //CGAL_ARR_RATIONAL_ARC_TRAITS_D_1_H
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
// $URL$
|
||||
// $Id$
|
||||
// SPDX-License-Identifier: GPL-3.0+
|
||||
//
|
||||
//
|
||||
//
|
||||
// Author(s) : Ron Wein <wein@post.tau.ac.il>
|
||||
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
#include <CGAL/internal/deprecation_warning.h>
|
||||
|
||||
/*! \file
|
||||
* Definition of the Arr_rational_arc_traits_2 class.
|
||||
* Definition of the Arr_rational_arc_traits_2 class.
|
||||
*/
|
||||
#include <CGAL/config.h>
|
||||
|
||||
|
|
@ -43,15 +43,15 @@ namespace CGAL {
|
|||
* A traits class for maintaining an arrangement of bounded arcs (segments) of
|
||||
* rational functions of arbitrary degree.
|
||||
*
|
||||
* The class is templated with two parameters:
|
||||
* The class is templated with two parameters:
|
||||
* Alg_kernel A geometric kernel, where Alg_kernel::FT is the number type
|
||||
* for the coordinates of arrangement vertices, which are algebraic
|
||||
* numbers (defined by Nt_traits::Algebraic).
|
||||
* Nt_traits A traits class for performing various operations on the integer,
|
||||
* rational and algebraic types.
|
||||
* rational and algebraic types.
|
||||
*/
|
||||
template <class Alg_kernel_, class Nt_traits_>
|
||||
class Arr_rational_arc_traits_2
|
||||
class Arr_rational_arc_traits_2
|
||||
{
|
||||
public:
|
||||
|
||||
|
|
@ -265,7 +265,7 @@ public:
|
|||
);
|
||||
CGAL_precondition ((cv1.left_infinite_in_x() != ARR_INTERIOR ||
|
||||
cv1.left_infinite_in_y() != ARR_INTERIOR ||
|
||||
ker.compare_xy_2_object() (p,
|
||||
ker.compare_xy_2_object() (p,
|
||||
cv1.left()) == LARGER) &&
|
||||
(cv2.left_infinite_in_x() != ARR_INTERIOR ||
|
||||
cv2.left_infinite_in_y() != ARR_INTERIOR ||
|
||||
|
|
@ -275,10 +275,10 @@ public:
|
|||
// Compare the slopes of the two arcs.
|
||||
Comparison_result res;
|
||||
unsigned int mult;
|
||||
|
||||
|
||||
res = cv1.compare_slopes (cv2, p, mult);
|
||||
|
||||
// The comparison result is to the right of p. In case the multiplicity
|
||||
// The comparison result is to the right of p. In case the multiplicity
|
||||
// of the intersection point p is odd, reverse this result.
|
||||
if (mult % 2 == 1)
|
||||
{
|
||||
|
|
@ -329,7 +329,7 @@ public:
|
|||
);
|
||||
CGAL_precondition((cv1.right_infinite_in_x() != ARR_INTERIOR ||
|
||||
cv1.right_infinite_in_y() != ARR_INTERIOR ||
|
||||
ker.compare_xy_2_object() (p,
|
||||
ker.compare_xy_2_object() (p,
|
||||
cv1.right()) == SMALLER) &&
|
||||
(cv2.right_infinite_in_x() != ARR_INTERIOR ||
|
||||
cv2.right_infinite_in_y() != ARR_INTERIOR ||
|
||||
|
|
@ -397,7 +397,7 @@ public:
|
|||
public:
|
||||
|
||||
/*!
|
||||
* Cut the given conic curve (or conic arc) into x-monotone subcurves
|
||||
* Cut the given conic curve (or conic arc) into x-monotone subcurves
|
||||
* and insert them to the given output iterator.
|
||||
* \param cv The curve.
|
||||
* \param oi The output iterator, whose value-type is Object. The returned
|
||||
|
|
@ -520,14 +520,14 @@ public:
|
|||
|
||||
/*! The traits (in case it has state) */
|
||||
const Traits* m_traits;
|
||||
|
||||
|
||||
/*! Constructor
|
||||
* \param traits the traits (in case it has state)
|
||||
*/
|
||||
Merge_2(const Traits* traits) : m_traits(traits) {}
|
||||
|
||||
friend class Arr_rational_arc_traits_2<Kernel>;
|
||||
|
||||
|
||||
public:
|
||||
/*!
|
||||
* Merge two given x-monotone curves into a single curve (segment).
|
||||
|
|
@ -595,7 +595,7 @@ public:
|
|||
/*! Obtain a Parameter_space_in_x_2 function object */
|
||||
Parameter_space_in_x_2 parameter_space_in_x_2_object() const
|
||||
{ return Parameter_space_in_x_2(); }
|
||||
|
||||
|
||||
/*! A function object that obtains the parameter space of a geometric
|
||||
* entity along the y-axis
|
||||
*/
|
||||
|
|
@ -643,7 +643,7 @@ public:
|
|||
/*! A function object that compares the x-limits of arc ends on the
|
||||
* boundary of the parameter space
|
||||
*/
|
||||
class Compare_x_at_limit_2 {
|
||||
class Compare_x_on_boundary_2 {
|
||||
public:
|
||||
/*! Compare the x-coordinate of a point and the x-coordinate of the limit
|
||||
* of a rational arc at its specificed end at y = +/- oo.
|
||||
|
|
@ -655,7 +655,7 @@ public:
|
|||
* \return the comparison result:
|
||||
* SMALLER - x(p) < x(xc, ce);
|
||||
* EQUAL - x(p) = x(xc, ce);
|
||||
* LARGER - x(p) > x(xc, ce).
|
||||
* LARGER - x(p) > x(xc, ce).
|
||||
* \pre p lies in the interior of the parameter space.
|
||||
* \pre the ce end of the curve xcv lies on a boundary, implying that xcv
|
||||
* is either a vertical line or a curve with a vertical asymptote.
|
||||
|
|
@ -697,16 +697,16 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
/*! Obtain a Compare_x_at_limit_2 function object */
|
||||
Compare_x_at_limit_2 compare_x_at_limit_2_object() const
|
||||
{ return Compare_x_at_limit_2(); }
|
||||
|
||||
/*! Obtain a Compare_x_on_boundary_2 function object */
|
||||
Compare_x_on_boundary_2 compare_x_on_boundary_2_object() const
|
||||
{ return Compare_x_on_boundary_2(); }
|
||||
|
||||
/*! A function object that compares the x-coordinates of arc ends near the
|
||||
* boundary of the parameter space
|
||||
*/
|
||||
class Compare_x_near_limit_2 {
|
||||
class Compare_x_near_boundary_2 {
|
||||
public:
|
||||
|
||||
|
||||
/*! Compare the x-coordinates of 2 arcs ends near the boundary of the
|
||||
* parameter space at y = +/- oo.
|
||||
* \param xcv1 the first arc.
|
||||
|
|
@ -730,10 +730,10 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
/*! Obtain a Compare_x_near_limit_2 function object */
|
||||
Compare_x_near_limit_2 compare_x_near_limit_2_object() const
|
||||
{ return Compare_x_near_limit_2(); }
|
||||
|
||||
/*! Obtain a Compare_x_near_boundary_2 function object */
|
||||
Compare_x_near_boundary_2 compare_x_near_boundary_2_object() const
|
||||
{ return Compare_x_near_boundary_2(); }
|
||||
|
||||
|
||||
/*! A function object that compares the y-coordinates of arc ends near the
|
||||
* boundary of the parameter space.
|
||||
|
|
@ -764,10 +764,10 @@ public:
|
|||
{ return Compare_y_near_boundary_2(); }
|
||||
|
||||
//@}
|
||||
|
||||
|
||||
/// \name Functor definitions for the Boolean set-operation traits.
|
||||
//@{
|
||||
|
||||
|
||||
class Compare_endpoints_xy_2
|
||||
{
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// #define CGAL_IDENTIFICATION_XY 2
|
||||
// #define CGAL_SS_VERBOSE 1
|
||||
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
|
|
@ -0,0 +1,381 @@
|
|||
namespace CGAL {
|
||||
|
||||
/*! \ingroup PkgArrangement2TraitsClasses
|
||||
*
|
||||
* The traits class `Arr_geodesic_arc_on_sphere_traits_2` is a model of the
|
||||
* `ArrangementTraits_2` concept. It enables the construction and
|
||||
* maintenance of arrangements of arcs of great circles (also known as
|
||||
* geodesic arcs) embedded on the sphere (centered at the origin). Almost
|
||||
* all operations on arrangements require a kernel that supports exact
|
||||
* predicates. Most operations also require the kernel to support exact
|
||||
* constructions. However, all operations on such arrangements can be
|
||||
* computed efficiently, since all calculations are performed with
|
||||
* rational arithmetic.
|
||||
*
|
||||
* There is an analogy between this class of arrangements and the class of
|
||||
* planar arrangements induced by linear curves (i.e., segments, rays, and
|
||||
* lines), as properties of linear curves in the plane often, but not always,
|
||||
* hold for geodesic arcs on the sphere. For example, given any two
|
||||
* non-antipodal points on the sphere there exists a unique great circle
|
||||
* connecting the two points.
|
||||
*
|
||||
* We use the following parameterization of the unit sphere \f$S =
|
||||
* \phi_S(\Phi)\f$: \f$\Phi = [\alpha, 2\pi + \alpha] \times [-\frac{\pi}{2},
|
||||
* \frac{\pi}{2}]\f$, \f$\phi_S(x, y) = (\cos y \cos x, \sin y \cos x, \sin
|
||||
* x)\f$, where \f$\alpha = atan2(X, Y)\f$. By deafult, \f$X = -1, Y = 0\f$,
|
||||
* which implies \f$\alpha = \pi\f$, and a default parameterization \f$\Phi =
|
||||
* [-\pi, \pi] \times [-\frac{\pi}{2}, \frac{\pi}{2}]\f$. The equator curve,
|
||||
* for example, is given by \f$\gamma(t) = (\pi(2t - 1) + \alpha, 0)\f$, for
|
||||
* \f$t \in [0,1]\f$. This parameterization induces two contraction points
|
||||
* \f$p_s = (0, 0, -1) = \phi_S(y,-\frac{\pi}{2})\f$ and \f$p_n = (0, 0, 1) =
|
||||
* \phi_S(y,\frac{\pi}{2})\f$, referred to as the south and north poles,
|
||||
* respectively, and an identification curve \f$\{\phi_S(\pi +
|
||||
* \alpha,x)\,|\,-\frac{\pi}{2} \leq v \leq \frac{\pi}{2}\}\f$, as
|
||||
* \f$\phi_S(-\pi + \alpha,v) = \phi_S(+\pi + \alpha,v)\f$ for all \f$x\f$
|
||||
* (which coincides with the opposite Prime (Greenwich) Meridian when
|
||||
* \f$\alpha = \pi\f$).
|
||||
|
||||
* \cgalModels `ArrangementTraits_2`
|
||||
* \cgalModels `ArrangementLandmarkTraits_2`
|
||||
* \cgalModels `ArrangementSphericalBoundaryTraits_2`
|
||||
*/
|
||||
|
||||
template <typename Kernel, typename X, typename Y>
|
||||
class Arr_geodesic_arc_on_sphere_traits_2 {
|
||||
public:
|
||||
/*! The `Point_2` class nested within the traits is used to represent a
|
||||
* point on a sphere centered at the origin. The point is in fact a
|
||||
* not-necessarily normalized 3D direction extended with information that
|
||||
* specifies the location of the point pre-image in the parameter space.
|
||||
*
|
||||
* \cgalModels `Assignable`
|
||||
* \cgalModels `DefaultConstructible`
|
||||
* \cgalModels `CopyConstructible`
|
||||
*/
|
||||
class Point_2 {
|
||||
public:
|
||||
/// \name Enumeration types
|
||||
/// @{
|
||||
|
||||
/*! The location type indicates a location in the parameter space.
|
||||
*/
|
||||
enum Location_type {
|
||||
/// Internal to the parameter space.
|
||||
NO_BOUNDARY_LOC = 0,
|
||||
|
||||
/// The bottom side boundary of the parameter space (the south pole).
|
||||
MIN_BOUNDARY_LOC,
|
||||
|
||||
/// The identified left and right side boundaries of the parameter space.
|
||||
MID_BOUNDARY_LOC,
|
||||
|
||||
/// The top side boundary of the parameter space (the north pole).
|
||||
MAX_BOUNDARY_LOC
|
||||
};
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
typedef Kernel::Direction_3 Direction_3;
|
||||
/// @}
|
||||
|
||||
/// \name Creation
|
||||
/// @{
|
||||
|
||||
/*! Constructs a point from a direction and a location.
|
||||
* \param[in] dir the direction.
|
||||
* \param[in] location indicates the location of the point pre-image
|
||||
* in the parameter space.
|
||||
*/
|
||||
Point_2(const Direction_3& dir, Location_type location);
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Operations
|
||||
/// @{
|
||||
|
||||
/*! Set the location of the point pre-image in the parameter space.
|
||||
* \param[in] location the updated location of the point pre-image in
|
||||
* the parameter space.
|
||||
*/
|
||||
void set_location(Location_type location);
|
||||
|
||||
/*! Obtain the location of the point.
|
||||
* \return the location of the point pre-image in the parameter space.
|
||||
*/
|
||||
Location_type location() const;
|
||||
|
||||
/// @}
|
||||
};
|
||||
|
||||
/*! The `X_monotone_curve_2` class nested within the traits is used to
|
||||
* represent an \f$x\f$-monotone geodesic arc on the a sphere centered at
|
||||
* the origin. The pre-image of an \f$x\f$-monotone geodesic arc does not
|
||||
* intersect the identified left and right sides of the boundary of the
|
||||
* parameter space.
|
||||
*
|
||||
* \cgalModels `Assignable`
|
||||
* \cgalModels `DefaultConstructible`
|
||||
* \cgalModels `CopyConstructible`
|
||||
*/
|
||||
class X_monotone_curve_2 {
|
||||
public:
|
||||
/// \name Types
|
||||
/// @{
|
||||
typedef Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>::Point_2 Point_2;
|
||||
/// @}
|
||||
|
||||
/// \name Creation
|
||||
/// @{
|
||||
|
||||
/*! Constructs an \f$x\f$-monotone geodesic arc.
|
||||
* \param[in] source the source point of the arc.
|
||||
* \param[in] target the target point of the arc.
|
||||
* \param[in] normal the normal of the plane that contains the arc.
|
||||
* \param[in] is_vertical is the arc vertical ?
|
||||
* \param[in] is_directed_right is the arc directed from left to right?
|
||||
* \param[in] is_full is the arc a full great circle?
|
||||
* \param[in] is_degenerate is the arc degenerate (single point)?
|
||||
* \param[in] is_empty is the arc empty?
|
||||
* \pre Both endpoint lie on the given plane.
|
||||
*/
|
||||
X_monotone_curve_2(const Point_2& source,
|
||||
const Point_2& target,
|
||||
const Direction_3& normal,
|
||||
bool is_vertical,
|
||||
bool is_directed_right,
|
||||
bool is_full = false,
|
||||
bool is_degenerate = false,
|
||||
bool is_empty = false);
|
||||
|
||||
/*! Construct an \f$x\f$-monotone geodesic arc.
|
||||
* \param[in] normal the normal of the plane containing the arc.
|
||||
* \param[in] source the source-point direction.
|
||||
* \param[in] target the target-point direction.
|
||||
* \pre Both endpoint lie on the given plane.
|
||||
*/
|
||||
X_monotone_curve_2(const Point_2& source,
|
||||
const Point_2& target,
|
||||
const Direction_3& normal);
|
||||
|
||||
/*! Construct a full great-circle.
|
||||
* \param[in] point the endpoint of the full great-circle.
|
||||
* \param[in] normal the normal of the plane containing the arc.
|
||||
* \pre the point lies on the given plane.
|
||||
* \pre the point pre-image lies on the identified left and right sides
|
||||
* of the boundary of the parameter space.
|
||||
*/
|
||||
X_monotone_curve_2(const Point_2& point,
|
||||
const Direction_3& normal);
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Operations
|
||||
/// @{
|
||||
|
||||
/*! Sets the source endpoint.
|
||||
* \param[in] source the updated source endpoint.
|
||||
*/
|
||||
void set_source(const Point_2& source);
|
||||
|
||||
/*! Sets the target endpoint.
|
||||
* \param[in] target the updated target endpoint.
|
||||
*/
|
||||
void set_target(const Point_2& target);
|
||||
|
||||
/*! Sets the normal of the underlying plane.
|
||||
* \param[in] normal the updated normal of the underlying plane.
|
||||
*/
|
||||
void set_normal(const Direction_3& normal);
|
||||
|
||||
/*! Sets the flag that indicates whether the arc is vertical.
|
||||
* \param[in] flag indicates whether the arc pre-image in the parameter
|
||||
* space is vertical.
|
||||
*/
|
||||
void set_is_vertical(bool flag);
|
||||
|
||||
/*! Sets the flag that indicates whether the direction of the arc
|
||||
* pre-image in the parameter space is from left to right.
|
||||
* \param flag indicates whether the arc pre-image in the parameter
|
||||
* space is from left to right.
|
||||
*/
|
||||
void set_is_directed_right(bool flag);
|
||||
|
||||
/*! Sets the flag that indicates whether the arc is a full great circle.
|
||||
* \param[in] flag indicates whether the arc is a full great circle.
|
||||
*/
|
||||
void set_is_full(bool flag);
|
||||
|
||||
/*! Sets the flag that indicates whether the arc degenerates to a point.
|
||||
* \param[in] flag indicates whether the arc degenerates to a point.
|
||||
*/
|
||||
void set_is_degenerate(bool flag);
|
||||
|
||||
/*! Sets the flag that indicates whether the arc is empty.
|
||||
* \param[in] flag indicates whether the arc is empty.
|
||||
*/
|
||||
void set_is_empty(bool flag);
|
||||
|
||||
/*! Obtains the source point.
|
||||
*/
|
||||
const Point_2& source() const;
|
||||
|
||||
/*! Obtains the target point.
|
||||
*/
|
||||
const Point_2& target() const;
|
||||
|
||||
/*! Obtains the normal to the containing plane.
|
||||
*/
|
||||
const Direction_3& normal() const;
|
||||
|
||||
/*! Obtains the (lexicographically) left endpoint direction.
|
||||
*/
|
||||
const Point_2& left() const;
|
||||
|
||||
/*! Obtains the (lexicographically) right endpoint.
|
||||
*/
|
||||
const Point_2& right() const;
|
||||
|
||||
/*! Determines whether the arc is vertical.
|
||||
*/
|
||||
bool is_vertical() const;
|
||||
|
||||
/*! Determines whether the arc is directed lexicographically from left to
|
||||
* right.
|
||||
*/
|
||||
bool is_directed_right() const;
|
||||
|
||||
/*! Determines whether the arc is a great circle.
|
||||
*/
|
||||
bool is_full() const;
|
||||
|
||||
/*! Determines whether the arc is degenerate.
|
||||
*/
|
||||
bool is_degenerate() const;
|
||||
|
||||
/*! Determines whether the arc is empty. */
|
||||
bool is_empty() const;
|
||||
|
||||
/*! Determines whether the arc is a meridian.
|
||||
*/
|
||||
bool is_meridian() const;
|
||||
|
||||
/// @}
|
||||
};
|
||||
|
||||
/*!
|
||||
*/
|
||||
class Curve_2 {
|
||||
public:
|
||||
/// \name Types
|
||||
/// @{
|
||||
typedef Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>::Point_2 Point_2;
|
||||
/// @}
|
||||
|
||||
/// \name Creation
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Operations
|
||||
/// @{
|
||||
/// @}
|
||||
};
|
||||
|
||||
/*!
|
||||
*/
|
||||
class Construct_point_2 {
|
||||
public:
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Operations
|
||||
/// @{
|
||||
/// @}
|
||||
};
|
||||
|
||||
/*! Construction functor of \f$x\f$-monotone geodesic arcs.
|
||||
*
|
||||
* \cgalModels `Assignable`
|
||||
* \cgalModels `CopyConstructible`
|
||||
* \cgalModels `AdaptableUnaryFunction`
|
||||
* \cgalModels `AdaptableBinaryFunction`
|
||||
* \cgalModels `AdaptableTernaryFunction`
|
||||
*/
|
||||
class Construct_x_monotone_curve_2 {
|
||||
public:
|
||||
/// \name Types
|
||||
/// @{
|
||||
typedef Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>::Point_2 Point_2;
|
||||
typedef Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>::X_monotone_curve_2 result_type;
|
||||
typedef Kernel::Direction_3 Direction_3;
|
||||
typedef Direction_3 argument_type;
|
||||
typedef Point_2 first_argument_type;
|
||||
typedef Point_2 second_argument_type;
|
||||
typedef Direction_3 third_argument_type;
|
||||
/// @}
|
||||
|
||||
/// \name Operations
|
||||
/// @{
|
||||
|
||||
/*! Construct the minor geodesic arc from two endpoints. The minor arc
|
||||
* is the one with the smaller angle among the two geodesic arcs with
|
||||
* the given endpoints.
|
||||
* 1. Find out whether the arc is x-monotone.
|
||||
* 2. If it is x-monotone,
|
||||
* 2.1 Find out whether it is vertical, and
|
||||
* 2.2 whether the target is larger than the source (directed right).
|
||||
* The arc is vertical, iff
|
||||
* 1. one of its endpoint direction pierces a pole, or
|
||||
* 2. the projections onto the xy-plane coincide.
|
||||
* \param[in] p the first endpoint.
|
||||
* \param[in] q the second endpoint.
|
||||
* \pre p and q must not coincide.
|
||||
* \pre p and q cannot be antipodal.
|
||||
*/
|
||||
X_monotone_curve_2 operator()(const Point_2& p, const Point_2& q);
|
||||
|
||||
/*! Construct a full great circle from a normal to a plane.
|
||||
* \param normal the normal to the plane containing the great circle.
|
||||
* \pre the plane is not vertical.
|
||||
*/
|
||||
X_monotone_curve_2 operator()(const Direction_3& normal);
|
||||
|
||||
/*! Construct a geodesic arc from two endpoints contained
|
||||
* in a plane.
|
||||
* \param[in] p the first endpoint.
|
||||
* \param[in] q the second endpoint.
|
||||
* \param[in] normal the normal to the plane containing the arc.
|
||||
* \pre Both endpoint lie on the given plane.
|
||||
* \pre Both endpoint lie on the given plane.
|
||||
*/
|
||||
X_monotone_curve_2 operator()(const Point_2& p, const Point_2& q,
|
||||
const Direction_3& normal)
|
||||
/// @} /* end of operations */
|
||||
};
|
||||
|
||||
class Construct_Curve_2 {
|
||||
public:
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Operations
|
||||
/// @{
|
||||
/// @}
|
||||
};
|
||||
|
||||
/*! Returns an instance of `Construct_point_2`.
|
||||
*/
|
||||
Construct_point_2 construct_point_2_object() const;
|
||||
|
||||
/*! Returns an instance of `Construct_x_monotone_curve_2`.
|
||||
*/
|
||||
Construct_x_monotone_curve_2 construct_x_monotone_curve_2_object() const;
|
||||
|
||||
/*! Returns an instance of `Construct_curve_2`.
|
||||
*/
|
||||
Construct_curve_2 construct_curve_2_object() const;
|
||||
};
|
||||
|
||||
} /* end namespace CGAL */
|
||||
|
|
@ -70,7 +70,7 @@ public:
|
|||
/// @{
|
||||
|
||||
/*!
|
||||
constructs an line segment.
|
||||
constructs a line segment.
|
||||
*/
|
||||
Curve_2 (const Segment_2& seg);
|
||||
|
||||
|
|
@ -147,15 +147,15 @@ public:
|
|||
|
||||
Class Trim_2{
|
||||
public:
|
||||
/// \name Creation
|
||||
/// \name Creation
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
Trims the given x-monotone curve to an from src to tgt.
|
||||
\ pre `src` and `tgt` lies on the curve
|
||||
*/
|
||||
\ pre `src` and `tgt` lies on the curve
|
||||
*/
|
||||
|
||||
X_monotone_curve_2(const X_monotone_curve_2& xcv,
|
||||
X_monotone_curve_2(const X_monotone_curve_2& xcv,
|
||||
const Point_2& src,
|
||||
const Point_2& tgt)const
|
||||
}/* end Arr_linear_traits_2::Trim_2 */
|
||||
|
|
|
|||
|
|
@ -0,0 +1,293 @@
|
|||
namespace CGAL {
|
||||
|
||||
/*!
|
||||
\ingroup PkgArrangement2
|
||||
|
||||
\anchor arr_refaos_with_hist
|
||||
|
||||
An object `arr` of the class `Arrangement_on_surface_with_history_2` represents the
|
||||
planar subdivision induced by a set of input curves \f$ \cal C\f$.
|
||||
The arrangement is represented as a doubly-connected edge-list (<span class="textsc">Dcel</span>).
|
||||
As is the case for the `Arrangement_2<Traits,Dcel>`, each <span class="textsc">Dcel</span>
|
||||
vertex is associated with a point and each edge is associated with an
|
||||
\f$ x\f$-monotone curve whose interior is disjoint from all other edges and
|
||||
vertices. Each such \f$ x\f$-monotone curve is a subcurve of some
|
||||
\f$ C \in \cal C\f$ - or may represent an overlap among several curves
|
||||
in \f$ \cal C\f$.
|
||||
|
||||
The `Arrangement_on_surface_with_history_2` class-template extends the `Arrangement_2`
|
||||
class-template by keeping an additional container of input curves
|
||||
representing \f$ \cal C\f$, and by maintaining a cross-mapping between these
|
||||
curves and the arrangement edges they induce. This way it is possible
|
||||
to determine the inducing curve(s) of each arrangement edge. This mapping
|
||||
also allows the traversal of input curves, and the traversal of edges
|
||||
induced by each curve.
|
||||
|
||||
The `Arrangement_on_surface_with_history_2` template has two parameters:
|
||||
<UL>
|
||||
<LI>The `Traits` template-parameter should be instantiated with
|
||||
a model of the `ArrangementGeometry_traits_2` concept. The traits
|
||||
class defines the `Curve_2` type, which represents an input curve.
|
||||
It also defines the types of \f$ x\f$-monotone curves and two-dimensional
|
||||
points, namely `ArrangementGeometry_traits_2::X_monotone_curve_2` and `ArrangementGeometry_traits_2::Point_2`,
|
||||
respectively, and supports basic geometric predicates on them.
|
||||
<LI>The `Dcel` template-parameter should be instantiated with
|
||||
a class that is a model of the `ArrangementDcelWithRebind` concept. The
|
||||
value of this parameter is by default
|
||||
`Arr_default_dcel<Traits>`.
|
||||
</UL>
|
||||
|
||||
\sa `ArrangementDcel`
|
||||
\sa `Arr_default_dcel<Traits>`
|
||||
\sa `ArrangementGeometry_traits_2`
|
||||
\sa `Arrangement_2<Traits,Dcel>`
|
||||
\sa `insertion functions`
|
||||
\sa `removal functions`
|
||||
\sa `overlaying arrangements`
|
||||
|
||||
*/
|
||||
template <typename Geometry_traits_2, typename TopologyTraits>
|
||||
class Arrangement_on_surface_with_history_2 : public Arrangement_on_surface_2<Geometry_traits_2, TopologyTraits> {
|
||||
public:
|
||||
/// \name Types
|
||||
/// @{
|
||||
|
||||
/*! a private type used as an abbreviation of the
|
||||
* `Arrangement_on_surface_with_history_2` type hereafter.
|
||||
*/
|
||||
typedef Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits> Self;
|
||||
|
||||
//! the geometry traits class in use.
|
||||
typedef Geometry_traits_2 Geometry_traits_2;
|
||||
|
||||
//! the topology traits class in use.
|
||||
typedef Geometry_traits_2 Topology_traits;
|
||||
|
||||
//! the <span class="textsc">Dcel</span> representation of the arrangement.
|
||||
typedef typename Topology_traits::Dcel Dcel;
|
||||
|
||||
//! the point type, as defined by the traits class.
|
||||
typedef typename Geometry_traits_2::Point_2 Point_2;
|
||||
|
||||
//! the \f$ x\f$-monotone curve type, as defined by the traits class.
|
||||
typedef typename Geometry_traits_2::X_monotone_curve_2 X_monotone_curve_2;
|
||||
|
||||
//! the curve type, as defined by the traits class.
|
||||
typedef typename Geometry_traits_2::Curve_2 Curve_2;
|
||||
|
||||
/// @}
|
||||
|
||||
/*! \name
|
||||
* In addition, the nested types `Vertex`, `Halfedge` and `Face` are defined,
|
||||
* as well as all handle, iterator and circulator types, as defined by the
|
||||
* `Arrangement_2` class-template.
|
||||
*/
|
||||
/// @{
|
||||
|
||||
//! a handle for an input curve.
|
||||
typedef unspecified_type Curve_handle;
|
||||
|
||||
/*! a bidirectional iterator over the curves that induce the arrangement.
|
||||
* Its value-type is `Curve_2`.
|
||||
*/
|
||||
typedef unspecified_type Curve_iterator;
|
||||
|
||||
/*! an iterator over the edges induced by an input curve. Its value type is
|
||||
* `Halfedge_handle`.
|
||||
*/
|
||||
typedef unspecified_type Induced_edge_iterator;
|
||||
|
||||
/*! an iterator for the curves that originate a given arrangement edge.
|
||||
* Its value type is `Curve_handle`.
|
||||
*/
|
||||
typedef unspecified_type Originating_curve_iterator;
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Creation
|
||||
/// @{
|
||||
|
||||
/*! constructs an empty arrangement containing one unbounded face, which
|
||||
* corresponds to the whole plane.
|
||||
*/
|
||||
Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits>();
|
||||
|
||||
//! copy constructor.
|
||||
Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits>(const Self& other);
|
||||
|
||||
/*! constructs an empty arrangement that uses the given `traits` instance
|
||||
* for performing the geometric predicates.
|
||||
*/
|
||||
Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits>(Geometry_traits_2 *traits);
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Assignment Methods
|
||||
/// @{
|
||||
|
||||
//! assignment operator.
|
||||
Self& operator=(other);
|
||||
|
||||
//! assigns the contents of another arrangement.
|
||||
void assign(const Self& other);
|
||||
|
||||
//! clears the arrangement.
|
||||
void clear ();
|
||||
|
||||
/// @}
|
||||
|
||||
/*! \name Access Functions for Input Curves
|
||||
* See the `Arrangement_2` reference pages for the full list.
|
||||
*/
|
||||
|
||||
/// @{
|
||||
|
||||
//! returns the number of input curves that induce the arrangement.
|
||||
Size number_of_curves() const;
|
||||
|
||||
//! returns the begin-iterator of the curves inducing the arrangement.
|
||||
Curve_iterator curves_begin();
|
||||
|
||||
//! returns the past-the-end iterator of the curves inducing the arrangement.
|
||||
Curve_iterator curves_end();
|
||||
|
||||
//! returns the number of arrangement edges induced by the curve `ch`.
|
||||
Size number_of_induced_edges(Curve_handle ch) const;
|
||||
|
||||
//! returns the begin-iterator of the edges induced by the curve `ch`.
|
||||
Induced_edge_iterator induced_edges_begin(Curve_handle ch) const;
|
||||
|
||||
//! returns the past-the-end iterator of the edges induced by the curve `ch`.
|
||||
Induced_edge_iterator induced_edges_end(Curve_handle ch) const;
|
||||
|
||||
//! returns the number of input curves that originate the edge `e`.
|
||||
Size number_of_originating_curves(Halfedge_handle e) const;
|
||||
|
||||
//! returns the begin-iterator of the curves originating the edge `e`.
|
||||
Originating_curve_iterator originating_curves_begin(Halfedge_handle e) const;
|
||||
|
||||
//! returns the past-the-end iterator of the curves originating the edge `e`.
|
||||
Originating_curve_iterator originating_curves_end(Halfedge_handle e) const;
|
||||
|
||||
/// @}
|
||||
|
||||
/*! \name Modifying Arrangement Edges
|
||||
* The following functions override their counterparts in the
|
||||
* `Arrangement_2` class, as they also maintain the cross-relationships
|
||||
* between the input curves and the edges they induce.
|
||||
*
|
||||
* See the `Arrangement_2` reference pages for the full list of functions
|
||||
* for modifying arrangement vertices
|
||||
*/
|
||||
|
||||
/// @{
|
||||
|
||||
/*! splits the edge `e` into two edges (more precisely, into two halfedge
|
||||
* pairs), at a given split point `p`. The function returns a handle for the
|
||||
* halfedge whose source is the same as `e->source()` and whose target vertex
|
||||
* is the split point.
|
||||
* \pre `p` lies in the interior of the curve associated with `e`.
|
||||
*/
|
||||
Halfedge_handle split_edge(Halfedge_handle e, const Point_2& p);
|
||||
|
||||
/*! merges the edges represented by `e1` and `e2` into a single edge. The
|
||||
* function returns a handle for one of the merged halfedges.
|
||||
* \pre `e1` and `e2` share a common end-vertex, of degree \f$ 2\f$, and the
|
||||
* \f$ x\f$-monotone curves associated with `e1` and `e2` are mergeable
|
||||
* into a single \f$ x\f$-monotone curves.
|
||||
*/
|
||||
Halfedge_handle merge_edge(Halfedge_handle e1, Halfedge_handle e2);
|
||||
|
||||
/*! removes the edge `e` from the arrangement. Since the `e` may be the only
|
||||
* edge incident to its source vertex (or its target vertex), this vertex can
|
||||
* be removed as well. The flags `remove_source` and `remove_target` indicate
|
||||
* whether the endpoints of `e` should be removed, or whether they should be
|
||||
* left as isolated vertices in the arrangement. If the operation causes two
|
||||
* faces to merge, the merged face is returned. Otherwise, the face to which
|
||||
* the edge was incident is returned.
|
||||
*/
|
||||
Face_handle remove_edge(Halfedge_handle e, bool remove_source = true,
|
||||
bool remove_target = true);
|
||||
|
||||
/// @}
|
||||
|
||||
}; /* end Arrangement_on_surface_with_history_2 */
|
||||
|
||||
/*! \ingroup PkgArrangement2Insert
|
||||
*
|
||||
* Inserts the given curve `c` into the arrangement with history `arr`, and
|
||||
* returns a handle to the inserted curve. `c` is subdivided into \f$
|
||||
* x\f$-monotone subcurves (and perhaps isolated points). Each subcurve is in
|
||||
* turn inserted into the arrangement by locating its left endpoint and
|
||||
* computing its zone until reaching the right endpoint.
|
||||
*
|
||||
* The given point-location object `pl` is used to locate the left endpoints of
|
||||
* the \f$ x\f$-monotone curves. By default, the function uses the "walk along
|
||||
* line" point-location strategy - namely an instance of the class
|
||||
* `Arr_walk_along_line_point_location<Arrangement_2<Traits,Dcel> >`.
|
||||
*
|
||||
* \pre If provided, `pl` is attached to the given arrangement `arr`.
|
||||
*/
|
||||
template<typename GeometryTraits_2, typename TopologyTraits,
|
||||
typename PointLocation>
|
||||
typename Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits>::Curve_handle
|
||||
insert (Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits>& arr,
|
||||
const typename Traits::Curve_2& c,
|
||||
const PointLocation& pl = walk_pl);
|
||||
|
||||
/*! \ingroup PkgArrangement2Insert
|
||||
* Aggregately inserts the curves in the range `[first,last)` into the
|
||||
* arrangement with history `arr` using the sweep-line framework.
|
||||
*/
|
||||
template <typename GeometryTraits_2, typename TopologyTraits,
|
||||
typename InputIterator>
|
||||
void insert(Arrangement_on_surface_with_history_2<GeometryTraits_2, TopologyTraits>& arr,
|
||||
InputIterator first, InputIterator last);
|
||||
|
||||
/*! \ingroup PkgArrangement2Funcs
|
||||
*
|
||||
* Removes a given curve from a given arrangement.
|
||||
*
|
||||
* The curve is specified by its handle `ch`, from the arrangement `arr`, by
|
||||
* deleting all the edges it induces. The function returns the number of
|
||||
* deleted edges.
|
||||
*/
|
||||
template <typename GeometryTraits_2, typename TopologyTraits>
|
||||
Size remove_curve(Arrangement_on_surface_with_history_2<GeometryTraits_2, TopologyTraits>& arr,
|
||||
typename Arrangement_on_surface_with_history_2<Geometry_traits_2, TopologyTraits>::Curve_handle ch);
|
||||
|
||||
|
||||
/*! \addtogroup PkgArrangement2Overlay
|
||||
*
|
||||
* Computes the overlay of two arrangements with history `arr1` and `arr2`, and
|
||||
* sets the output arrangement with history `res` to represent the overlaid
|
||||
* arrangement. The function also constructs a consolidated set of curves that
|
||||
* induce `res`. \pre `res` does not refer to either `arr1` or `arr2` (that is,
|
||||
* "self overlay" is not supported).
|
||||
*/
|
||||
template <typename GeometryTraits_2, typename TopologyTraits1,
|
||||
typename TopologyTraits12, typename ResTopologyTraits,
|
||||
typename OverlayTraits>
|
||||
void overlay(const Arrangement_on_surface_with_history_2<GeometryTraits_2, TopologyTraits1>& arr1,
|
||||
const Arrangement_on_surface_with_history_2<GeometryTraits_2, TopologyTraits12>& arr2,
|
||||
Arrangement_on_surface_with_history_2<GeometryTraits_2, ResTopologyTraits>& res,
|
||||
OverlayTraits& ovl_tr);
|
||||
|
||||
|
||||
/*!
|
||||
\addtogroup PkgArrangement2Overlay
|
||||
|
||||
Computes the (simple) overlay of two arrangements with history `arr1`
|
||||
and `arr2`, and sets the output arrangement with history `res` to
|
||||
represent the overlaid arrangement. The function also constructs a
|
||||
consolidated set of curves that induce `res`. It employs the default
|
||||
overlay-traits, which practically does nothing.
|
||||
\pre `res` does not refer to either `arr1` or `arr2` (that is, "self overlay" is not supported).
|
||||
*/
|
||||
template <typename GeometryTraits_2, typename TopologyTraits1,
|
||||
typename TopologyTraits2, typename ResTopologyTraits>
|
||||
void overlay(const Arrangement_on_surface_with_history_2<GeometryTraits_2, TopologyTraits1>& arr1,
|
||||
const Arrangement_on_surface_with_history_2<GeometryTraits_2, TopologyTraits2>& arr2,
|
||||
Arrangement_on_surface_with_history_2<GeometryTraits_2, ResTopologyTraits>& res);
|
||||
|
||||
} /* namespace CGAL */
|
||||
|
|
@ -1,90 +1,88 @@
|
|||
|
||||
namespace CGAL {
|
||||
|
||||
/*!
|
||||
\ingroup PkgArrangement2
|
||||
|
||||
\anchor arr_refarr_with_hist
|
||||
\anchor arr_refarr_with_hist
|
||||
|
||||
An object `arr` of the class `Arrangement_with_history_2` represents the
|
||||
planar subdivision induced by a set of input curves \f$ \cal C\f$.
|
||||
The arrangement is represented as a doubly-connected edge-list (<span class="textsc">Dcel</span>).
|
||||
As is the case for the `Arrangement_2<Traits,Dcel>`, each <span class="textsc">Dcel</span>
|
||||
vertex is associated with a point and each edge is associated with an
|
||||
\f$ x\f$-monotone curve whose interior is disjoint from all other edges and
|
||||
vertices. Each such \f$ x\f$-monotone curve is a subcurve of some
|
||||
\f$ C \in \cal C\f$ - or may represent an overlap among several curves
|
||||
in \f$ \cal C\f$.
|
||||
An object `arr` of the class `Arrangement_with_history_2` represents the
|
||||
planar subdivision induced by a set of input curves \f$ \cal C\f$.
|
||||
The arrangement is represented as a doubly-connected edge-list (<span class="textsc">Dcel</span>).
|
||||
As is the case for the `Arrangement_2<Traits,Dcel>`, each <span class="textsc">Dcel</span>
|
||||
vertex is associated with a point and each edge is associated with an
|
||||
\f$ x\f$-monotone curve whose interior is disjoint from all other edges and
|
||||
vertices. Each such \f$ x\f$-monotone curve is a subcurve of some
|
||||
\f$ C \in \cal C\f$ - or may represent an overlap among several curves
|
||||
in \f$ \cal C\f$.
|
||||
|
||||
The `Arrangement_with_history_2` class-template extends the `Arrangement_2`
|
||||
class-template by keeping an additional container of input curves
|
||||
representing \f$ \cal C\f$, and by maintaining a cross-mapping between these
|
||||
curves and the arrangement edges they induce. This way it is possible
|
||||
to determine the inducing curve(s) of each arrangement edge. This mapping
|
||||
also allows the traversal of input curves, and the traversal of edges
|
||||
induced by each curve.
|
||||
The `Arrangement_with_history_2` class-template extends the `Arrangement_2`
|
||||
class-template by keeping an additional container of input curves
|
||||
representing \f$ \cal C\f$, and by maintaining a cross-mapping between these
|
||||
curves and the arrangement edges they induce. This way it is possible
|
||||
to determine the inducing curve(s) of each arrangement edge. This mapping
|
||||
also allows the traversal of input curves, and the traversal of edges
|
||||
induced by each curve.
|
||||
|
||||
The `Arrangement_with_history_2` template has two parameters:
|
||||
<UL>
|
||||
<LI>The `Traits` template-parameter should be instantiated with
|
||||
a model of the `ArrangementTraits_2` concept. The traits
|
||||
class defines the `Curve_2` type, which represents an input curve.
|
||||
It also defines the types of \f$ x\f$-monotone curves and two-dimensional
|
||||
points, namely `ArrangementTraits_2::X_monotone_curve_2` and `ArrangementTraits_2::Point_2`,
|
||||
respectively, and supports basic geometric predicates on them.
|
||||
<LI>The `Dcel` template-parameter should be instantiated with
|
||||
a class that is a model of the `ArrangementDcelWithRebind` concept. The
|
||||
value of this parameter is by default
|
||||
`Arr_default_dcel<Traits>`.
|
||||
</UL>
|
||||
The `Arrangement_with_history_2` template has two parameters:
|
||||
<UL>
|
||||
<LI>The `Traits` template-parameter should be instantiated with
|
||||
a model of the `ArrangementTraits_2` concept. The traits
|
||||
class defines the `Curve_2` type, which represents an input curve.
|
||||
It also defines the types of \f$ x\f$-monotone curves and two-dimensional
|
||||
points, namely `ArrangementTraits_2::X_monotone_curve_2` and `ArrangementTraits_2::Point_2`,
|
||||
respectively, and supports basic geometric predicates on them.
|
||||
<LI>The `Dcel` template-parameter should be instantiated with
|
||||
a class that is a model of the `ArrangementDcelWithRebind` concept. The
|
||||
value of this parameter is by default
|
||||
`Arr_default_dcel<Traits>`.
|
||||
</UL>
|
||||
|
||||
\sa `ArrangementDcel`
|
||||
\sa `Arr_default_dcel<Traits>`
|
||||
\sa `ArrangementTraits_2`
|
||||
\sa `Arrangement_2<Traits,Dcel>`
|
||||
\sa `insertion functions`
|
||||
\sa `removal functions`
|
||||
\sa `overlaying arrangements`
|
||||
\sa `ArrangementDcel`
|
||||
\sa `Arr_default_dcel<Traits>`
|
||||
\sa `ArrangementTraits_2`
|
||||
\sa `Arrangement_2<Traits,Dcel>`
|
||||
\sa `insertion functions`
|
||||
\sa `removal functions`
|
||||
\sa `overlaying arrangements`
|
||||
|
||||
*/
|
||||
template< typename Traits, typename Dcel >
|
||||
class Arrangement_with_history_2 : public Arrangement_2<Traits,Dcel> {
|
||||
template <typename Traits, typename Dcel>
|
||||
class Arrangement_with_history_2 : public Arrangement_2<Traits, Dcel> {
|
||||
public:
|
||||
|
||||
/// \name Types
|
||||
/// \name Types
|
||||
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
a private type used as an abbreviation of the `Arrangement_with_history_2` type hereafter.
|
||||
*/
|
||||
typedef Arrangement_with_history_2<Traits_2,Dcel> Self;
|
||||
a private type used as an abbreviation of the `Arrangement_with_history_2` type hereafter.
|
||||
*/
|
||||
typedef Arrangement_with_history_2<Traits_2,Dcel> Self;
|
||||
|
||||
/*!
|
||||
the traits class in use.
|
||||
*/
|
||||
typedef unspecified_type Traits_2;
|
||||
the traits class in use.
|
||||
*/
|
||||
typedef unspecified_type Traits_2;
|
||||
|
||||
/*!
|
||||
the <span class="textsc">Dcel</span> representation of the arrangement.
|
||||
*/
|
||||
typedef unspecified_type Dcel;
|
||||
the <span class="textsc">Dcel</span> representation of the arrangement.
|
||||
*/
|
||||
typedef unspecified_type Dcel;
|
||||
|
||||
/*!
|
||||
the point type, as defined by the traits class.
|
||||
*/
|
||||
typedef typename Traits_2::Point_2 Point_2;
|
||||
the point type, as defined by the traits class.
|
||||
*/
|
||||
typedef typename Traits_2::Point_2 Point_2;
|
||||
|
||||
/*!
|
||||
the \f$ x\f$-monotone curve type, as defined by the traits class.
|
||||
*/
|
||||
typedef typename Traits_2::X_monotone_curve_2 X_monotone_curve_2;
|
||||
the \f$ x\f$-monotone curve type, as defined by the traits class.
|
||||
*/
|
||||
typedef typename Traits_2::X_monotone_curve_2 X_monotone_curve_2;
|
||||
|
||||
/*!
|
||||
the curve type, as defined by the traits class.
|
||||
*/
|
||||
typedef typename Traits_2::Curve_2 Curve_2;
|
||||
|
||||
the curve type, as defined by the traits class.
|
||||
*/
|
||||
typedef typename Traits_2::Curve_2 Curve_2;
|
||||
|
||||
/// @}
|
||||
|
||||
|
|
@ -97,73 +95,73 @@ In addition, the nested types `Vertex`, `Halfedge` and `Face` are defined, as we
|
|||
|
||||
|
||||
/*!
|
||||
a handle for an input curve.
|
||||
*/
|
||||
typedef unspecified_type Curve_handle;
|
||||
a handle for an input curve.
|
||||
*/
|
||||
typedef unspecified_type Curve_handle;
|
||||
|
||||
/*!
|
||||
a bidirectional iterator over the
|
||||
curves that induce the arrangement. Its value-type is
|
||||
`Curve_2`.
|
||||
*/
|
||||
typedef unspecified_type Curve_iterator;
|
||||
a bidirectional iterator over the
|
||||
curves that induce the arrangement. Its value-type is
|
||||
`Curve_2`.
|
||||
*/
|
||||
typedef unspecified_type Curve_iterator;
|
||||
|
||||
/*!
|
||||
an iterator over the edges induced by an input curve.
|
||||
Its value type is `Halfedge_handle`.
|
||||
*/
|
||||
typedef unspecified_type Induced_edge_iterator;
|
||||
an iterator over the edges induced by an input curve.
|
||||
Its value type is `Halfedge_handle`.
|
||||
*/
|
||||
typedef unspecified_type Induced_edge_iterator;
|
||||
|
||||
/*!
|
||||
an iterator for the curves that originate a given arrangement edge.
|
||||
Its value type is `Curve_handle`.
|
||||
*/
|
||||
typedef unspecified_type Originating_curve_iterator;
|
||||
an iterator for the curves that originate a given arrangement edge.
|
||||
Its value type is `Curve_handle`.
|
||||
*/
|
||||
typedef unspecified_type Originating_curve_iterator;
|
||||
|
||||
/// @}
|
||||
/// @}
|
||||
|
||||
/// \name Creation
|
||||
/// \name Creation
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
constructs an empty arrangement containing one unbounded face,
|
||||
which corresponds to the
|
||||
whole plane.
|
||||
*/
|
||||
Arrangement_with_history_2<Traits, Dcel>();
|
||||
constructs an empty arrangement containing one unbounded face,
|
||||
which corresponds to the
|
||||
whole plane.
|
||||
*/
|
||||
Arrangement_with_history_2<Traits, Dcel>();
|
||||
|
||||
/*!
|
||||
copy constructor.
|
||||
*/
|
||||
Arrangement_with_history_2<Traits, Dcel>(const Self& other);
|
||||
copy constructor.
|
||||
*/
|
||||
Arrangement_with_history_2<Traits, Dcel>(const Self& other);
|
||||
|
||||
/*!
|
||||
constructs an empty arrangement that uses the given `traits`
|
||||
instance for performing the geometric predicates.
|
||||
*/
|
||||
Arrangement_with_history_2<Traits, Dcel>(Traits_2 *traits);
|
||||
constructs an empty arrangement that uses the given `traits`
|
||||
instance for performing the geometric predicates.
|
||||
*/
|
||||
Arrangement_with_history_2<Traits, Dcel>(Traits_2 *traits);
|
||||
|
||||
/// @}
|
||||
/// @}
|
||||
|
||||
/// \name Assignment Methods
|
||||
/// \name Assignment Methods
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
assignment operator.
|
||||
*/
|
||||
Self& operator= (other);
|
||||
assignment operator.
|
||||
*/
|
||||
Self& operator= (other);
|
||||
|
||||
/*!
|
||||
assigns the contents of another arrangement.
|
||||
*/
|
||||
void assign (const Self& other);
|
||||
assigns the contents of another arrangement.
|
||||
*/
|
||||
void assign (const Self& other);
|
||||
|
||||
/*!
|
||||
clears the arrangement.
|
||||
*/
|
||||
void clear ();
|
||||
clears the arrangement.
|
||||
*/
|
||||
void clear ();
|
||||
|
||||
/// @}
|
||||
/// @}
|
||||
|
||||
/*! \name Access Functions for Input Curves
|
||||
|
||||
|
|
@ -173,58 +171,58 @@ See the `Arrangement_2` reference pages for the full list.
|
|||
/// @{
|
||||
|
||||
/*!
|
||||
returns the number of input curves that induce the arrangement.
|
||||
*/
|
||||
Size number_of_curves() const;
|
||||
returns the number of input curves that induce the arrangement.
|
||||
*/
|
||||
Size number_of_curves() const;
|
||||
|
||||
/*!
|
||||
returns the begin-iterator of the curves inducing the arrangement.
|
||||
*/
|
||||
Curve_iterator curves_begin();
|
||||
returns the begin-iterator of the curves inducing the arrangement.
|
||||
*/
|
||||
Curve_iterator curves_begin();
|
||||
|
||||
/*!
|
||||
returns the past-the-end iterator of the curves inducing the arrangement.
|
||||
*/
|
||||
Curve_iterator curves_end();
|
||||
returns the past-the-end iterator of the curves inducing the arrangement.
|
||||
*/
|
||||
Curve_iterator curves_end();
|
||||
|
||||
/*!
|
||||
returns the number of arrangement edges induced by the curve `ch`.
|
||||
*/
|
||||
Size number_of_induced_edges (Curve_handle ch) const;
|
||||
returns the number of arrangement edges induced by the curve `ch`.
|
||||
*/
|
||||
Size number_of_induced_edges (Curve_handle ch) const;
|
||||
|
||||
/*!
|
||||
returns the begin-iterator of the edges induced by the curve `ch`.
|
||||
*/
|
||||
Induced_edge_iterator
|
||||
induced_edges_begin (Curve_handle ch) const;
|
||||
returns the begin-iterator of the edges induced by the curve `ch`.
|
||||
*/
|
||||
Induced_edge_iterator
|
||||
induced_edges_begin (Curve_handle ch) const;
|
||||
|
||||
/*!
|
||||
returns the past-the-end iterator of the edges induced by the curve `ch`.
|
||||
*/
|
||||
Induced_edge_iterator
|
||||
induced_edges_end (Curve_handle ch) const;
|
||||
returns the past-the-end iterator of the edges induced by the curve `ch`.
|
||||
*/
|
||||
Induced_edge_iterator
|
||||
induced_edges_end (Curve_handle ch) const;
|
||||
|
||||
/*!
|
||||
returns the number of input curves that originate the edge `e`.
|
||||
*/
|
||||
Size number_of_originating_curves (Halfedge_handle e) const;
|
||||
returns the number of input curves that originate the edge `e`.
|
||||
*/
|
||||
Size number_of_originating_curves (Halfedge_handle e) const;
|
||||
|
||||
/*!
|
||||
returns the begin-iterator of the curves originating the edge `e`.
|
||||
*/
|
||||
Originating_curve_iterator
|
||||
originating_curves_begin (Halfedge_handle e) const;
|
||||
returns the begin-iterator of the curves originating the edge `e`.
|
||||
*/
|
||||
Originating_curve_iterator
|
||||
originating_curves_begin (Halfedge_handle e) const;
|
||||
|
||||
/*!
|
||||
returns the past-the-end iterator of the curves originating the edge
|
||||
`e`.
|
||||
*/
|
||||
Originating_curve_iterator
|
||||
originating_curves_end (Halfedge_handle e) const;
|
||||
returns the past-the-end iterator of the curves originating the edge
|
||||
`e`.
|
||||
*/
|
||||
Originating_curve_iterator
|
||||
originating_curves_end (Halfedge_handle e) const;
|
||||
|
||||
/// @}
|
||||
/// @}
|
||||
|
||||
/*! \name Modifying Arrangement Edges
|
||||
/*! \name Modifying Arrangement Edges
|
||||
|
||||
The following functions override their counterparts in the
|
||||
`Arrangement_2` class, as they also maintain the cross-relationships
|
||||
|
|
@ -237,37 +235,37 @@ for modifying arrangement vertices
|
|||
/// @{
|
||||
|
||||
/*!
|
||||
splits the edge `e` into two edges (more precisely, into two halfedge
|
||||
pairs), at a given split point `p`.
|
||||
The function returns a handle for the halfedge whose source is the same
|
||||
as `e->source()` and whose target vertex is the split point.
|
||||
\pre `p` lies in the interior of the curve associated with `e`.
|
||||
*/
|
||||
Halfedge_handle split_edge (Halfedge_handle e,
|
||||
const Point_2& p);
|
||||
splits the edge `e` into two edges (more precisely, into two halfedge
|
||||
pairs), at a given split point `p`.
|
||||
The function returns a handle for the halfedge whose source is the same
|
||||
as `e->source()` and whose target vertex is the split point.
|
||||
\pre `p` lies in the interior of the curve associated with `e`.
|
||||
*/
|
||||
Halfedge_handle split_edge (Halfedge_handle e,
|
||||
const Point_2& p);
|
||||
|
||||
/*!
|
||||
merges the edges represented by `e1` and `e2` into
|
||||
a single edge.
|
||||
The function returns a handle for one of the merged halfedges.
|
||||
\pre `e1` and `e2` share a common end-vertex, of degree \f$ 2\f$, and the \f$ x\f$-monotone curves associated with `e1` and `e2` are mergeable into a single \f$ x\f$-monotone curves.
|
||||
*/
|
||||
Halfedge_handle merge_edge (Halfedge_handle e1,
|
||||
Halfedge_handle e2);
|
||||
merges the edges represented by `e1` and `e2` into
|
||||
a single edge.
|
||||
The function returns a handle for one of the merged halfedges.
|
||||
\pre `e1` and `e2` share a common end-vertex, of degree \f$ 2\f$, and the \f$ x\f$-monotone curves associated with `e1` and `e2` are mergeable into a single \f$ x\f$-monotone curves.
|
||||
*/
|
||||
Halfedge_handle merge_edge (Halfedge_handle e1,
|
||||
Halfedge_handle e2);
|
||||
|
||||
/*!
|
||||
removes the edge `e` from the arrangement. Since the `e` may
|
||||
be the only edge incident to its source vertex (or its target vertex),
|
||||
this vertex can be removed as well. The flags `remove_source` and
|
||||
`remove_target` indicate whether the endpoints of `e` should be
|
||||
removed, or whether they should be left as isolated vertices in the
|
||||
arrangement.
|
||||
If the operation causes two faces to merge, the merged face is returned.
|
||||
Otherwise, the face to which the edge was incident is returned.
|
||||
*/
|
||||
Face_handle remove_edge(Halfedge_handle e,
|
||||
bool remove_source = true,
|
||||
bool remove_target = true);
|
||||
removes the edge `e` from the arrangement. Since the `e` may
|
||||
be the only edge incident to its source vertex (or its target vertex),
|
||||
this vertex can be removed as well. The flags `remove_source` and
|
||||
`remove_target` indicate whether the endpoints of `e` should be
|
||||
removed, or whether they should be left as isolated vertices in the
|
||||
arrangement.
|
||||
If the operation causes two faces to merge, the merged face is returned.
|
||||
Otherwise, the face to which the edge was incident is returned.
|
||||
*/
|
||||
Face_handle remove_edge(Halfedge_handle e,
|
||||
bool remove_source = true,
|
||||
bool remove_target = true);
|
||||
|
||||
/// @}
|
||||
|
||||
|
|
@ -310,11 +308,11 @@ void insert(Arrangement_with_history_2<Traits,Dcel>& arr,
|
|||
/*!
|
||||
\ingroup PkgArrangement2Funcs
|
||||
|
||||
Removes a given curve from a given arrangement.
|
||||
Removes a given curve from a given arrangement.
|
||||
|
||||
The curve is specified by its handle `ch`, from
|
||||
the arrangement `arr`, by deleting all the edges it induces. The
|
||||
function returns the number of deleted edges.
|
||||
The curve is specified by its handle `ch`, from
|
||||
the arrangement `arr`, by deleting all the edges it induces. The
|
||||
function returns the number of deleted edges.
|
||||
|
||||
*/
|
||||
template <class Traits, class Dcel>
|
||||
|
|
@ -356,4 +354,3 @@ template<typename Traits, typename Dcel1, typename Dcel2,
|
|||
Arrangement_with_history_2<Traits,ResDcel>& res);
|
||||
|
||||
} /* namespace CGAL */
|
||||
|
||||
|
|
|
|||
|
|
@ -1,69 +0,0 @@
|
|||
namespace ArrTraits {
|
||||
/*!
|
||||
\ingroup PkgArrangement2ConceptsFunctionObjects
|
||||
\cgalConcept
|
||||
|
||||
\cgalRefines AdaptableFunctor
|
||||
|
||||
\cgalHasModel ArrangementOpenBoundaryTraits_2::Compare_x_at_limit_2
|
||||
|
||||
*/
|
||||
|
||||
class CompareXAtLimit_2 {
|
||||
public:
|
||||
|
||||
/// \name Operations
|
||||
/// A model of this concept must provide:
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
Given a point `p`, an \f$ x\f$-monotone curve `xcv`, and an
|
||||
enumeration `ce` that specifies either the minimum or the
|
||||
maximum end of the curve where the curve has a vertical asymptote,
|
||||
compares the \f$ x\f$-coordinate of `p` and the \f$ x\f$-coordinate of the
|
||||
limit of the curve at its specificed end. The variable `xcv`
|
||||
identifies the parametric curve \f$ C(t) = (X(t),Y(t))\f$ defined over an
|
||||
open or half-open interval with endpoints \f$ 0\f$ and \f$ 1\f$. The
|
||||
enumeration `ce` identifies an open end \f$ d \in\{0,1\}\f$ of \f$ C\f$.
|
||||
Formally, compares the \f$ x\f$-coordinate of `p` and
|
||||
\f$ \lim_{t \rightarrow d} X(t)\f$. Returns `SMALLER`, `EQUAL`, or
|
||||
`LARGER` accordingly.
|
||||
\pre `parameter_space_in_y_2`(`xcv`, `ce`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
\pre If the parameter space is unbounded, \f$ C\f$ has a vertical asymptote at its \f$ d\f$-end; that is, `parameter_space_in_x_2`(`xcv`, `ce`) = `ARR_INTERIOR`.
|
||||
*/
|
||||
Comparison_result operator()(const ArrTraits::Point_2& p,
|
||||
const ArrTraits::X_monotone_curve_2& xcv,
|
||||
Arr_curve_end ce);
|
||||
|
||||
/*!
|
||||
Given two \f$ x\f$-monotone curves `xcv1` and `xcv2` and two
|
||||
indices `ce1` and `ce2` that specify either the minimum
|
||||
or the maximum ends of `xcv1` and `xcv2`, respectively,
|
||||
where the curves have vertical asymptotes, compares the
|
||||
\f$ x\f$-coordinates of the limits of the curves at their specificed
|
||||
ends. The variables `xcv1` and `xcv2` identify the
|
||||
parametric curves \f$ C_1(t) = (X_1(t),Y_1(t))\f$ and
|
||||
\f$ C_2(t) = (X_2(t),Y_2(t))\f$, respectively, defined over open or
|
||||
half-open intervals with endpoints \f$ 0\f$ and \f$ 1\f$. The indices
|
||||
`ce1` and `ce2` identify open ends \f$ d_1 \in\{0,1\}\f$ and
|
||||
\f$ d_2 \in\{0,1\}\f$ of \f$ C_1\f$ and \f$ C_2\f$, respectively. Formally,
|
||||
compares \f$ \lim_{t \rightarrow d_1} X_1(t)\f$ and
|
||||
\f$ \lim_{t \rightarrow d_2} X_2(t)\f$. Returns `SMALLER`, `EQUAL`,
|
||||
or `LARGER` accordingly.
|
||||
\pre `parameter_space_in_y_2`(`xcv1`, `ce1`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
\pre `parameter_space_in_y_2`(`xcv2`, `ce2`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
\pre If the parameter space is unbounded, \f$ C_1\f$ has a vertical asymptote at its respective end; that is,
|
||||
`parameter_space_in_x_2`(`xcv1`, `ce1`) = `ARR_INTERIOR`.
|
||||
\pre If the parameter space is unbounded, \f$ C_2\f$ has a vertical asymptote at its respective end; that is,
|
||||
`parameter_space_in_x_2`(`xcv2`, `ce2`) = `ARR_INTERIOR`.
|
||||
*/
|
||||
Comparison_result operator()(const ArrTraits::X_monotone_curve_2& xcv1,
|
||||
Arr_curve_end ce1,
|
||||
const ArrTraits::X_monotone_curve_2& xcv2,
|
||||
Arr_curve_end ce2);
|
||||
|
||||
/// @}
|
||||
|
||||
}; /* end ArrTraits::CompareXAtLimit_2 */
|
||||
|
||||
}
|
||||
|
|
@ -3,13 +3,13 @@ namespace ArrTraits {
|
|||
\ingroup PkgArrangement2ConceptsFunctionObjects
|
||||
\cgalConcept
|
||||
|
||||
\cgalRefines AdaptableTernaryFunction
|
||||
\cgalRefines AdaptableTernaryFunction
|
||||
|
||||
\cgalHasModel ArrangementOpenBoundaryTraits_2::Compare_x_near_limit_2
|
||||
\cgalHasModel ArrangementOpenBoundaryTraits_2::Compare_x_near_boundary_2
|
||||
|
||||
*/
|
||||
|
||||
class CompareXNearLimit_2 {
|
||||
class CompareXNearBoundary_2 {
|
||||
public:
|
||||
|
||||
/// \name Operations
|
||||
|
|
@ -17,29 +17,29 @@ public:
|
|||
/// @{
|
||||
|
||||
/*!
|
||||
Given two \f$ x\f$-monotone curves `xcv1` and `xcv2` and an
|
||||
enumeration `ce` that specifies either the minimum ends or the
|
||||
maximum ends of the curves where the curves have a vertical
|
||||
asymptote, compares the \f$ x\f$-coordinate of the curves near their
|
||||
respective ends. Returns `SMALLER`, `EQUAL`, or `LARGER`
|
||||
accordingly. More precisely, compares the \f$ x\f$-coordinates of the
|
||||
horizontal projection of a point \f$ p\f$ onto `xcv1` and `xcv2`.
|
||||
If `xcv1` and `xcv2` approach the bottom boundary-side, \f$ p\f$
|
||||
is located far to the bottom, such that the result is invariant
|
||||
under a translation of \f$ p\f$ farther to the bottom. If `xcv1`
|
||||
and `xcv2` approach the top boundary-side, \f$ p\f$ is located far
|
||||
to the top in a similar manner.
|
||||
\pre The \f$ x\f$-coordinates of the limits of the curves at their respective ends are equal. That is,
|
||||
`compare_x_at_limit_2`(`xcv1`, `xcv2`, `ce`) = `EQUAL`.
|
||||
\pre `parameter_space_in_y_2`(`xcv1`, `ce`) = `parameter_space_in_y_2`(`xcv2`, `ce`).
|
||||
\pre `parameter_space_in_y_2`(`xcv1`, `ce`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
*/
|
||||
Comparison_result operator()(const ArrTraits::X_monotone_curve_2& xcv1,
|
||||
const ArrTraits::X_monotone_curve_2& xcv2,
|
||||
Arr_curve_end ce);
|
||||
Given two \f$ x\f$-monotone curves `xcv1` and `xcv2` and an
|
||||
enumeration `ce` that specifies either the minimum ends or the
|
||||
maximum ends of the curves where the curves have a vertical
|
||||
asymptote, compares the \f$ x\f$-coordinate of the curves near their
|
||||
respective ends. Returns `SMALLER`, `EQUAL`, or `LARGER`
|
||||
accordingly. More precisely, compares the \f$ x\f$-coordinates of the
|
||||
horizontal projection of a point \f$ p\f$ onto `xcv1` and `xcv2`.
|
||||
If `xcv1` and `xcv2` approach the bottom boundary-side, \f$ p\f$
|
||||
is located far to the bottom, such that the result is invariant
|
||||
under a translation of \f$ p\f$ farther to the bottom. If `xcv1`
|
||||
and `xcv2` approach the top boundary-side, \f$ p\f$ is located far
|
||||
to the top in a similar manner.
|
||||
\pre The \f$ x\f$-coordinates of the limits of the curves at their respective ends are equal. That is,
|
||||
`compare_x_at_limit_2`(`xcv1`, `xcv2`, `ce`) = `EQUAL`.
|
||||
\pre `parameter_space_in_y_2`(`xcv1`, `ce`) = `parameter_space_in_y_2`(`xcv2`, `ce`).
|
||||
\pre `parameter_space_in_y_2`(`xcv1`, `ce`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
*/
|
||||
Comparison_result operator()(const ArrTraits::X_monotone_curve_2& xcv1,
|
||||
const ArrTraits::X_monotone_curve_2& xcv2,
|
||||
Arr_curve_end ce);
|
||||
|
||||
/// @}
|
||||
|
||||
}; /* end ArrTraits::CompareXNearLimit_2 */
|
||||
}; /* end ArrTraits::CompareXNearBoundary_2 */
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
namespace ArrTraits {
|
||||
/*!
|
||||
\ingroup PkgArrangement2ConceptsFunctionObjects
|
||||
\cgalConcept
|
||||
|
||||
\cgalRefines AdaptableFunctor
|
||||
|
||||
\cgalHasModel ArrangementOpenBoundaryTraits_2::Compare_x_on_boundary_2
|
||||
|
||||
*/
|
||||
|
||||
class CompareXOnBoundary_2 {
|
||||
public:
|
||||
|
||||
/// \name Operations
|
||||
/// A model of this concept must provide:
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
Given a point `p`, an \f$ x\f$-monotone curve `xcv`, and an
|
||||
enumeration `ce` that specifies either the minimum or the
|
||||
maximum end of the curve where the curve has a vertical asymptote,
|
||||
compares the \f$ x\f$-coordinate of `p` and the \f$ x\f$-coordinate of the
|
||||
limit of the curve at its specificed end. The variable `xcv`
|
||||
identifies the parametric curve \f$ C(t) = (X(t),Y(t))\f$ defined over an
|
||||
open or half-open interval with endpoints \f$ 0\f$ and \f$ 1\f$. The
|
||||
enumeration `ce` identifies an open end \f$ d \in\{0,1\}\f$ of \f$ C\f$.
|
||||
Formally, compares the \f$ x\f$-coordinate of `p` and
|
||||
\f$ \lim_{t \rightarrow d} X(t)\f$. Returns `SMALLER`, `EQUAL`, or
|
||||
`LARGER` accordingly.
|
||||
\pre `parameter_space_in_y_2`(`xcv`, `ce`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
\pre If the parameter space is unbounded, \f$ C\f$ has a vertical asymptote at its \f$ d\f$-end; that is, `parameter_space_in_x_2`(`xcv`, `ce`) = `ARR_INTERIOR`.
|
||||
*/
|
||||
Comparison_result operator()(const ArrTraits::Point_2& p,
|
||||
const ArrTraits::X_monotone_curve_2& xcv,
|
||||
Arr_curve_end ce);
|
||||
|
||||
/*!
|
||||
Given two \f$ x\f$-monotone curves `xcv1` and `xcv2` and two
|
||||
indices `ce1` and `ce2` that specify either the minimum
|
||||
or the maximum ends of `xcv1` and `xcv2`, respectively,
|
||||
where the curves have vertical asymptotes, compares the
|
||||
\f$ x\f$-coordinates of the limits of the curves at their specificed
|
||||
ends. The variables `xcv1` and `xcv2` identify the
|
||||
parametric curves \f$ C_1(t) = (X_1(t),Y_1(t))\f$ and
|
||||
\f$ C_2(t) = (X_2(t),Y_2(t))\f$, respectively, defined over open or
|
||||
half-open intervals with endpoints \f$ 0\f$ and \f$ 1\f$. The indices
|
||||
`ce1` and `ce2` identify open ends \f$ d_1 \in\{0,1\}\f$ and
|
||||
\f$ d_2 \in\{0,1\}\f$ of \f$ C_1\f$ and \f$ C_2\f$, respectively. Formally,
|
||||
compares \f$ \lim_{t \rightarrow d_1} X_1(t)\f$ and
|
||||
\f$ \lim_{t \rightarrow d_2} X_2(t)\f$. Returns `SMALLER`, `EQUAL`,
|
||||
or `LARGER` accordingly.
|
||||
\pre `parameter_space_in_y_2`(`xcv1`, `ce1`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
\pre `parameter_space_in_y_2`(`xcv2`, `ce2`) \f$ \neq\f$ `ARR_INTERIOR`.
|
||||
\pre If the parameter space is unbounded, \f$ C_1\f$ has a vertical asymptote at its respective end; that is,
|
||||
`parameter_space_in_x_2`(`xcv1`, `ce1`) = `ARR_INTERIOR`.
|
||||
\pre If the parameter space is unbounded, \f$ C_2\f$ has a vertical asymptote at its respective end; that is,
|
||||
`parameter_space_in_x_2`(`xcv2`, `ce2`) = `ARR_INTERIOR`.
|
||||
*/
|
||||
Comparison_result operator()(const ArrTraits::X_monotone_curve_2& xcv1,
|
||||
Arr_curve_end ce1,
|
||||
const ArrTraits::X_monotone_curve_2& xcv2,
|
||||
Arr_curve_end ce2);
|
||||
|
||||
/// @}
|
||||
|
||||
}; /* end ArrTraits::CompareXOnBoundary_2 */
|
||||
|
||||
}
|
||||
|
|
@ -3,9 +3,9 @@ namespace ArrTraits {
|
|||
\ingroup PkgArrangement2ConceptsFunctionObjects
|
||||
\cgalConcept
|
||||
|
||||
\cgalRefines Functor
|
||||
\cgalRefines Functor
|
||||
|
||||
\cgalHasModel ArrangementXMonotoneTraits_2::Intersect_2
|
||||
\cgalHasModel ArrangementXMonotoneTraits_2::Intersect_2
|
||||
|
||||
*/
|
||||
|
||||
|
|
@ -16,21 +16,30 @@ public:
|
|||
/// A model of this concept must provide:
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
computes the intersections of `xc1` and `xc2` and
|
||||
inserts them <I>in an ascending lexicographic \f$ xy\f$-order</I> into the
|
||||
output iterator `oi`. The value-type of `Output_iterator` is
|
||||
`CGAL::Object`, where each `Object` wraps either a
|
||||
`pair<ArrTraits::Point_2,ArrTraits::Multiplicity>` object, which
|
||||
represents an intersection point with its multiplicity (in case the
|
||||
multiplicity is undefined or unknown, it should be set to \f$ 0\f$) or an
|
||||
`ArrTraits::X_monotone_curve_2` object, representing an
|
||||
overlapping subcurve of `xc1` and `xc2`. The operator
|
||||
returns a past-the-end iterator for the output sequence.
|
||||
*/
|
||||
Output_iterator operator()(ArrTraits::X_monotone_curve_2 xc1,
|
||||
ArrTraits::X_monotone_curve_2 xc2,
|
||||
Output_iterator& oi);
|
||||
/*! computes the intersections of `xc1` and `xc2` and writes them <I>in an
|
||||
* ascending lexicographic \f$ xy\f$-order</I> into the output iterator
|
||||
* `oi`. The type of a value written into `oi` must be convertible to
|
||||
* `CGAL::Object`. The value itself wraps either a value of type
|
||||
* `pair<ArrTraits::Point_2,ArrTraits::Multiplicity>` or a value of type
|
||||
* `ArrTraits::X_monotone_curve_2`. A value of of the former type represents an
|
||||
* intersection point with its multiplicity; in case the multiplicity is
|
||||
* undefined or unknown, it should be set to \f$ 0\f$). A value of the latter
|
||||
* type representing an overlapping subcurve of `xc1` and `xc2`. The operator
|
||||
* returns a past-the-end iterator for the output sequence.
|
||||
*
|
||||
* A special case may occur when the parameter space of the surface, the
|
||||
* arrangement is embedded on, is identified on the left and right sides of the
|
||||
* boundary. An intersection point that lies on the identification curve,
|
||||
* between two \f$X\f$-monotone curves that intersect at their left and right
|
||||
* ends must be ignored. Consider two \f$X\f$-monotone curves that intersect at
|
||||
* their left and right ends, respectively, at a point \f$p\f$ that lies on the
|
||||
* identification curve. If, for example, the number of intersections between
|
||||
* these two curves is greater than 1, the order of intersections is
|
||||
* non-deterministic.
|
||||
*/
|
||||
Output_iterator operator()(ArrTraits::X_monotone_curve_2 xc1,
|
||||
ArrTraits::X_monotone_curve_2 xc2,
|
||||
Output_iterator& oi);
|
||||
|
||||
/// @}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@ point.
|
|||
\cgalHasModel `CGAL::Arr_polyline_traits_2<SegmentTraits_2>`
|
||||
\cgalHasModel `CGAL::Arr_rational_function_traits_2<AlgebraicKernel_d_1>`
|
||||
|
||||
\sa ArrangementConstructXMonotoneCurveTraits_2`,
|
||||
ArrangementXMonotoneTraits_2`, and
|
||||
\sa `ArrangementConstructXMonotoneCurveTraits_2`,
|
||||
`ArrangementXMonotoneTraits_2`, and
|
||||
`ArrangementTraits_2`
|
||||
*/
|
||||
class ArrangementApproximateTraits_2 {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* `ArrangementBottomSideTraits_2` is an abstract concept. It generalizes all
|
||||
* concepts that handle curves that either reach or approach the bottom boundary
|
||||
* side of the parameter space.
|
||||
*
|
||||
* \cgalRefines `ArrangementHorizontalSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementLeftSideTraits_2`,
|
||||
* `ArrangementRightSideTraits_2`, and
|
||||
* `ArrangementTopSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementBottomSideTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementClosedBottomTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is closed
|
||||
* on the left side and curves inserted into the arrangement are expected to
|
||||
* reach this boundary side. A model of this concept can handle curves that
|
||||
* reach the left boundary side when it is closed.
|
||||
*
|
||||
* \cgalRefines `ArrangementBottomSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementClosedLeftTraits_2`,
|
||||
* `ArrangementClosedRightTraits_2`,
|
||||
* `ArrangementClosedTopTraits_2`,
|
||||
* `ArrangementOpenBottomTraits_2`,
|
||||
* `ArrangementContractedBottomTraits_2`, and
|
||||
* `ArrangementIdentifiedBottomTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementClosedBottomTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_closed_side_tag`.
|
||||
typedef unspecified_type Bottom_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementClosedLeftTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is closed on
|
||||
* the left side and curves inserted into the arrangement are expected to reach
|
||||
* this boundary side. A model of this concept can handle curves that reach the
|
||||
* left boundary side when it is closed.
|
||||
|
||||
* \cgalRefines `ArrangementLeftSideTraits_2`
|
||||
|
||||
\sa `ArrangementClosedRightTraits_2`,
|
||||
`ArrangementClosedBottomTraits_2`,
|
||||
`ArrangementClosedTopTraits_2`,
|
||||
`ArrangementOpenLeftTraits_2`,
|
||||
`ArrangementContractedLeftTraits_2`, and
|
||||
`ArrangementIdentifiedLeftTraits_2`,
|
||||
*/
|
||||
|
||||
class ArrangementClosedLeftTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
/*! Must be convertible to `Arr_closed_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Left_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementClosedRightTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is closed on
|
||||
* the right side and curves inserted into the arrangement are expected to reach
|
||||
* this boundary side. A model of this concept can handle curves that reach the
|
||||
* right boundary side when it is closed.
|
||||
*
|
||||
* \cgalRefines `ArrangementRightSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementClosedLeftTraits_2`,
|
||||
* `ArrangementClosedBottomTraits_2`,
|
||||
* `ArrangementClosedTopTraits_2`,
|
||||
* `ArrangementOpenRightTraits_2`,
|
||||
* `ArrangementContractedRightTraits_2`, and
|
||||
* `ArrangementIdentifiedRightTraits_2`,
|
||||
*/
|
||||
|
||||
class ArrangementClosedRightTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_closed_side_tag`.
|
||||
typedef unspecified_type Right_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementClosedTopTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is closed on
|
||||
* the top side and curves inserted into the arrangement are expected to reach
|
||||
* this boundary side. A model of this concept can handle curves that reach the
|
||||
* top boundary side when it is closed.
|
||||
*
|
||||
* \cgalRefines `ArrangementTopSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementClosedLeftTraits_2`,
|
||||
* `ArrangementClosedRightTraits_2`,
|
||||
* `ArrangementClosedBottomTraits_2`,
|
||||
* `ArrangementOpenTopTraits_2`,
|
||||
* `ArrangementContractedTopTraits_2`, and
|
||||
* `ArrangementIdentifiedTopTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementClosedTopTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_closed_side_tag`.
|
||||
typedef unspecified_type Top_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementContractedBottomTraits_2` must be used
|
||||
* when the parameter space of the surface, the arrangement is embedded on, is
|
||||
* contracted on the bottom side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the bottom boundary side when it is contracted.
|
||||
*
|
||||
* \cgalRefines `ArrangementBottomSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementContractedLeftTraits_2`,
|
||||
* `ArrangementContractedRightTraits_2`,
|
||||
* `ArrangementContractedTopTraits_2`,
|
||||
* `ArrangementClosedBottomTraits_2`,
|
||||
* `ArrangementContractedBottomTraits_2`, and
|
||||
* `ArrangementIdentifiedBottomTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementContractedBottomTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_contracted_side_tag`.
|
||||
typedef unspecified_type Bottom_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementContractedLeftTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is
|
||||
* contracted on the left side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the left boundary side when it is contracted.
|
||||
*
|
||||
* \cgalRefines `ArrangementLeftSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementContractedRightTraits_2`,
|
||||
* `ArrangementContractedBottomTraits_2`,
|
||||
* `ArrangementContractedTopTraits_2`,
|
||||
* `ArrangementOpenLeftTraits_2`,
|
||||
* `ArrangementClosedLeftTraits_2`, and
|
||||
* `ArrangementIdentifiedLeftTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementContractedLeftTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_contracted_side_tag`.
|
||||
typedef unspecified_type Left_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementContractedRightTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is
|
||||
* contracted on the right side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the right boundary side when it is contracted.
|
||||
*
|
||||
* \cgalRefines `ArrangementRightSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementContractedLeftTraits_2`,
|
||||
* `ArrangementContractedBottomTraits_2`,
|
||||
* `ArrangementContractedTopTraits_2`,
|
||||
* `ArrangementOpenRightTraits_2`,
|
||||
* `ArrangementClosedRightTraits_2`, and
|
||||
* `ArrangementIdentifiedRightTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementContractedRightTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_contracted_side_tag`.
|
||||
typedef unspecified_type Right_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementContractedTopTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is
|
||||
* contracted on the top side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the top boundary side when it is contracted.
|
||||
*
|
||||
* \cgalRefines `ArrangementTopSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementContractedLeftTraits_2`,
|
||||
* `ArrangementContractedRightTraits_2`,
|
||||
* `ArrangementContractedBottomTraits_2`,
|
||||
* `ArrangementOpenTopTraits_2`,
|
||||
* `ArrangementSlosedTopTraits_2`, and
|
||||
* `ArrangementIdentifiedTopTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementContractedTopTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_contracted_side_tag`.
|
||||
typedef unspecified_type Top_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* `ArrangementHorizontalSideTraits_2` is an abstract concept. It generalizes all
|
||||
* concepts that handle curves that either reach or approach either the bottom
|
||||
* or top sizeds of the boundary of the parameter space.
|
||||
*
|
||||
* \cgalRefines `ArrangementBasicTraits_2`
|
||||
*
|
||||
* \cgalHasModel `CGAL::Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>`
|
||||
*
|
||||
* \sa `ArrangementVerticalSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementHorizontalSideTraits_2 {
|
||||
public:
|
||||
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// models the concept `ArrTraits::ParameterSpaceInX_2`.
|
||||
typedef unspecified_type Parameter_space_in_x_2;
|
||||
|
||||
/// models the concept `ArrTraits::CompareXOnBoundary_2`.
|
||||
typedef unspecified_type Compare_x_on_boundary_2;
|
||||
|
||||
/// models the concept `ArrTraits::CompareXNearBoundary_2`.
|
||||
typedef unspecified_type Compare_x_near_boundary_2;
|
||||
/// @}
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
Parameter_space_in_x_2 parameter_space_in_x_2_object() const;
|
||||
Compare_x_on_boundary_2 compare_x_on_boundary_2_object() const;
|
||||
Compare_x_near_boundary_2 compare_x_near_boundary_2_object() const;
|
||||
/// @}
|
||||
|
||||
}; /* end ArrangementHorizontalSideTraits_2 */
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementIdentifiedBottomTraits_2` must be used
|
||||
* when the parameter space of the surface, the arrangement is embedded on, is
|
||||
* identified on the bottom side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the bottom boundary side when it is identified.
|
||||
*
|
||||
* \cgalRefines `ArrangementBottomSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementIdentifiedRightTraits_2`,
|
||||
* `ArrangementIdentifiedBottomTraits_2`,
|
||||
* `ArrangementIdentifiedTopTraits_2`,
|
||||
* `ArrangementOpenBottomTraits_2`,
|
||||
* `ArrangementClosedBottomTraits_2`, and
|
||||
* `ArrangementConstractedBottomTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementIdentifiedBottomTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_identified_side_tag`.
|
||||
typedef unspecified_type Bottom_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementIdentifiedLeftTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is
|
||||
* identified on the left side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the left boundary side when it is identified.
|
||||
*
|
||||
* \cgalRefines `ArrangementLeftSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementIdentifiedRightTraits_2`,
|
||||
* `ArrangementIdentifiedBottomTraits_2`,
|
||||
* `ArrangementIdentifiedTopTraits_2`,
|
||||
* `ArrangementOpenLeftTraits_2`,
|
||||
* `ArrangementClosedLeftTraits_2`, and
|
||||
* `ArrangementConstractedLeftTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementIdentifiedLeftTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_identified_side_tag`.
|
||||
typedef unspecified_type Left_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementIdentifiedRightTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is
|
||||
* identified on the right side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the right boundary side when it is identified.
|
||||
*
|
||||
* \cgalRefines `ArrangementRightSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementIdentifiedLeftTraits_2`,
|
||||
* `ArrangementIdentifiedBottomTraits_2`,
|
||||
* `ArrangementIdentifiedTopTraits_2`,
|
||||
* `ArrangementOpenRightTraits_2`,
|
||||
* `ArrangementClosedRightTraits_2`, and
|
||||
* `ArrangementConstractedRightTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementIdentifiedRightTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_identified_side_tag`.
|
||||
typedef unspecified_type Right_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementIdentifiedTopTraits_2` must be used when
|
||||
* the parameter space of the surface, the arrangement is embedded on, is
|
||||
* identified on the top side and curves inserted into the arrangement are
|
||||
* expected to reach this boundary side. A model of this concept can handle
|
||||
* curves that reach the top boundary side when it is identified.
|
||||
*
|
||||
* \cgalRefines `ArrangementTopSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementIdentifiedLeftTraits_2`,
|
||||
* `ArrangementIdentifiedRightTraits_2`,
|
||||
* `ArrangementIdentifiedBottomTraits_2`,
|
||||
* `ArrangementOpenTopTraits_2`,
|
||||
* `ArrangementClosedTopTraits_2`, and
|
||||
* `ArrangementConstractedTopTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementIdentifiedTopTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_identified_side_tag`.
|
||||
typedef unspecified_type Top_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* `ArrangementLeftSideTraits_2` is an abstract concept. It generalizes all
|
||||
* concepts that handle curves that either reach or approach the left boundary
|
||||
* side of the parameter space.
|
||||
*
|
||||
* \cgalRefines `ArrangementVerticalSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementRightSideTraits_2`,
|
||||
* `ArrangementBottomSideTraits_2`, and
|
||||
* `ArrangementTopSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementLeftSideTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementOpenBottomTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is open on
|
||||
* the bottom side and curves inserted into the arrangement are expected to
|
||||
* reach this boundary side. A model of this concept can handle curves that
|
||||
* reach the bottom boundary side when it is open.
|
||||
*
|
||||
* \cgalRefines `ArrangementBottomSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementOpenLeftTraits_2`,
|
||||
* `ArrangementOpenRightTraits_2`,
|
||||
* `ArrangementOpenTopTraits_2`,
|
||||
* `ArrangementClosedBottomTraits_2`,
|
||||
* `ArrangementContractedBottomTraits_2`, and
|
||||
* `ArrangementIdentifiedBottomTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementOpenBottomTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_open_side_tag`.
|
||||
typedef unspecified_type Bottom_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -1,167 +1,163 @@
|
|||
|
||||
/*!
|
||||
\ingroup PkgArrangement2ConceptsTraits
|
||||
\cgalConcept
|
||||
|
||||
Several predicates are required to handle \f$ x\f$-monotone curves that
|
||||
approach infinity and thus approach the boundary of the parameter
|
||||
space. These predicates are sufficient to handle not only curves
|
||||
embedded in an unbounded parameter space, but also curves embedded
|
||||
in a bounded parameter space with open boundaries. Models of the
|
||||
concept `ArrangementOpenBoundaryTraits_2` handle curves that approach the boundary of a
|
||||
parameter space. This concept refines the concept
|
||||
`ArrangementBasicTraits_2`. The arrangement template
|
||||
instantiated with a traits class that models this concept can handle
|
||||
\f$ x\f$-monotone curves that are unbounded in any direction. The concept
|
||||
`ArrangementOpenBoundaryTraits_2`, nontheless, also supports planar \f$ x\f$-monotone curves
|
||||
that reach the boundary of an open yet bounded parameter space.
|
||||
|
||||
An \f$ x\f$-monotone curve may be <I>closed</I>, in which case its endpoints
|
||||
are representable as `Point_2` objects, or <I>open</I> at the
|
||||
boundary of the parameter space. It can have one open end and one
|
||||
closed end (e.g., a ray). The nature of the \f$ x\f$-monotone curves,
|
||||
whether they are expected to be closed or not at any one of the four
|
||||
boundary-sides, is conveyed through the definition of the four nested
|
||||
types `Left_side_category`, `Right_side_category`,
|
||||
`Bottom_side_category`, and `Top_side_category`. If some curves
|
||||
handled by a model of the concept `ArrangementOpenBoundaryTraits_2` are expected to be open
|
||||
on the left, the nested type `Left_side_category` must be convertible
|
||||
to `CGAL::Arr_open_side_tag`. Similarly, if some curves handled by the
|
||||
concept are expected to be open on the right, open at the bottom, or
|
||||
open at the top, the corresponding nested type must be convertible to
|
||||
`CGAL::Arr_open_side_tag`. A model of the concept `ArrangementOpenBoundaryTraits_2` must have
|
||||
all the four categories convertible to
|
||||
`CGAL::Arr_open_side_tag`.\cgalFootnote{We intend to introduce more concepts that require only a subset of the categories to be convertible to `Arr_open_side_tag`.} In this case the <span class="textsc">Dcel</span> of the arrangement
|
||||
instantiated with the model is initialized with an implicit bounding
|
||||
rectangle. When the parameter space is bounded, it is the exact
|
||||
geometric embedding of the implicit bounding rectangle.
|
||||
|
||||
\cgalRefines `ArrangementBasicTraits_2`
|
||||
|
||||
\cgalHasModel `CGAL::Arr_linear_traits_2<Kernel>`
|
||||
\cgalHasModel `CGAL::Arr_rational_function_traits_2<AlgebraicKernel_d_1>`
|
||||
\cgalHasModel `CGAL::Arr_algebraic_segment_traits_2<Coefficient>`
|
||||
\cgalHasModel `CGAL::Arr_curve_data_traits_2<Tr,XData,Mrg,CData,Cnv>`
|
||||
\cgalHasModel `CGAL::Arr_consolidated_curve_data_traits_2<Traits,Data>`
|
||||
|
||||
\sa `ArrangementBasicTraits_2`
|
||||
\sa `ArrangementXMonotoneTraits_2`
|
||||
\sa `ArrangementLandmarkTraits_2`
|
||||
\sa `ArrangementTraits_2`
|
||||
|
||||
*/
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* Several predicates are required to handle \f$ x\f$-monotone curves that
|
||||
* approach infinity and thus approach the boundary of the parameter
|
||||
* space. These predicates are sufficient to handle not only curves embedded in
|
||||
* an unbounded parameter space, but also curves embedded in a bounded parameter
|
||||
* space with open boundaries. Models of the concept
|
||||
* `ArrangementOpenBoundaryTraits_2` handle curves that approach the boundary of
|
||||
* a parameter space. This concept refines the concept
|
||||
* `ArrangementBasicTraits_2`. The arrangement template instantiated with a
|
||||
* traits class that models this concept can handle \f$ x\f$-monotone curves
|
||||
* that are unbounded in any direction. The concept
|
||||
* `ArrangementOpenBoundaryTraits_2`, nontheless, also supports planar \f$
|
||||
* x\f$-monotone curves that reach the boundary of an open yet bounded parameter
|
||||
* space.
|
||||
*
|
||||
* An \f$ x\f$-monotone curve may be <I>closed</I>, in which case its endpoints
|
||||
* are representable as `Point_2` objects, or <I>open</I> at the boundary of the
|
||||
* parameter space. It can have one open end and one closed end (e.g., a
|
||||
* ray). The nature of the \f$ x\f$-monotone curves, whether they are expected
|
||||
* to be closed or not at any one of the four boundary-sides, is conveyed
|
||||
* through the definition of the four nested types `Left_side_category`,
|
||||
* `Right_side_category`, `Bottom_side_category`, and `Top_side_category`. If
|
||||
* some curves handled by a model of the concept
|
||||
* `ArrangementOpenBoundaryTraits_2` are expected to be open on the left, the
|
||||
* nested type `Left_side_category` must be convertible to
|
||||
* `Arr_open_side_tag`. Similarly, if some curves handled by the concept are
|
||||
* expected to be open on the right, open at the bottom, or open at the top, the
|
||||
* corresponding nested type must be convertible to `Arr_open_side_tag`. A model
|
||||
* of the concept `ArrangementOpenBoundaryTraits_2` must have all the four
|
||||
* categories convertible to `Arr_open_side_tag`.\cgalFootnote{We intend to
|
||||
* introduce more concepts that require only a subset of the categories to be
|
||||
* convertible to `Arr_open_side_tag`.} In this case the <span
|
||||
* class="textsc">Dcel</span> of the arrangement instantiated with the model is
|
||||
* initialized with an implicit bounding rectangle. When the parameter space is
|
||||
* bounded, it is the exact geometric embedding of the implicit bounding
|
||||
* rectangle.
|
||||
*
|
||||
* \cgalRefines `ArrangementBasicTraits_2`
|
||||
*
|
||||
* \cgalHasModel `CGAL::Arr_linear_traits_2<Kernel>`
|
||||
* \cgalHasModel `CGAL::Arr_rational_function_traits_2<AlgebraicKernel_d_1>`
|
||||
* \cgalHasModel `CGAL::Arr_algebraic_segment_traits_2<Coefficient>`
|
||||
* \cgalHasModel `CGAL::Arr_curve_data_traits_2<Tr,XData,Mrg,CData,Cnv>`
|
||||
* \cgalHasModel `CGAL::Arr_consolidated_curve_data_traits_2<Traits,Data>`
|
||||
*
|
||||
* \sa `ArrangementBasicTraits_2`
|
||||
* \sa `ArrangementXMonotoneTraits_2`
|
||||
* \sa `ArrangementLandmarkTraits_2`
|
||||
* \sa `ArrangementTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementOpenBoundaryTraits_2 {
|
||||
public:
|
||||
|
||||
/// \name Categories
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Left_side_category;
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Left_side_category;
|
||||
|
||||
/*!
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Bottom_side_category;
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Bottom_side_category;
|
||||
|
||||
/*!
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Top_side_category;
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Top_side_category;
|
||||
|
||||
/*!
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Right_side_category;
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::ParameterSpaceInX_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the left or the right sides (the `Left_side_category`
|
||||
or the `Right_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Parameter_space_in_x_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::CompareYNearBoundary_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the left or the right sides (the `Left_side_category`
|
||||
or the `Right_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Compare_y_near_boundary_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::ParameterSpaceInY_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the bottom or the top sides (the `Bottom_side_category`
|
||||
or the `Top_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Parameter_space_in_y_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::CompareXAtLimit_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the bottom or the top sides (the `Bottom_side_category`
|
||||
or the `Top_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Compare_x_at_limit_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::CompareXNearLimit_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the bottom or the top sides (the `Bottom_side_category`
|
||||
or the `Top_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Compare_x_near_limit_2;
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Parameter_space_in_x_2 parameter_space_in_x_2_object() const;
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const;
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Parameter_space_in_y_2 parameter_space_in_y_2_object() const;
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Compare_x_at_limit_2 compare_x_at_limit_2_object() const;
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Compare_x_near_limit_2 compare_x_near_limit_2_object() const;
|
||||
Must be convertible to either `CGAL::Arr_oblivious_side_tag` or
|
||||
`CGAL::Arr_open_side_tag`.
|
||||
*/
|
||||
typedef unspecified_type Right_side_category;
|
||||
|
||||
/// @}
|
||||
|
||||
}; /* end ArrangementOpenBoundaryTraits_2 */
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::ParameterSpaceInX_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the left or the right sides (the `Left_side_category`
|
||||
or the `Right_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Parameter_space_in_x_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::CompareYNearBoundary_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the left or the right sides (the `Left_side_category`
|
||||
or the `Right_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Compare_y_near_boundary_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::ParameterSpaceInY_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the bottom or the top sides (the `Bottom_side_category`
|
||||
or the `Top_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Parameter_space_in_y_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::CompareXAtLimit_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the bottom or the top sides (the `Bottom_side_category`
|
||||
or the `Top_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Compare_x_at_limit_2;
|
||||
|
||||
/*!
|
||||
models the concept `ArrTraits::CompareXNearLimit_2`.
|
||||
Required only if the traits class supports unbounded curves that
|
||||
approach the bottom or the top sides (the `Bottom_side_category`
|
||||
or the `Top_side_category` categories are convertible to
|
||||
`CGAL::Arr_open_side_tag`).
|
||||
*/
|
||||
typedef unspecified_type Compare_x_near_limit_2;
|
||||
|
||||
/// @}
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Parameter_space_in_x_2 parameter_space_in_x_2_object() const;
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const;
|
||||
|
||||
/*!
|
||||
|
||||
*/
|
||||
Parameter_space_in_y_2 parameter_space_in_y_2_object() const;
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
}; /* end ArrangementOpenBoundaryTraits_2 */
|
||||
|
|
|
|||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementOpenLeftTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is open on
|
||||
* the left side and curves inserted into the arrangement are expected to reach
|
||||
* this boundary side. A model of this concept can handle curves that reach the
|
||||
* left boundary side when it is open.
|
||||
*
|
||||
* \cgalRefines `ArrangementLeftSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementOpenRightTraits_2`,
|
||||
* `ArrangementOpenBottomTraits_2`,
|
||||
* `ArrangementOpenTopTraits_2`,
|
||||
* `ArrangementClosedLeftTraits_2`,
|
||||
* `ArrangementContractedLeftTraits_2`, and
|
||||
* `ArrangementIdentifiedLeftTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementOpenLeftTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_open_side_tag`.
|
||||
typedef unspecified_type Left_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementOpenRightTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is open on
|
||||
* the right side and curves inserted into the arrangement are expected to reach
|
||||
* this boundary side. A model of this concept can handle curves that reach the
|
||||
* right boundary side when it is open.
|
||||
*
|
||||
* \cgalRefines `ArrangementRightSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementOpenLeftTraits_2`,
|
||||
* `ArrangementOpenBottomTraits_2`,
|
||||
* `ArrangementOpenTopTraits_2`,
|
||||
* `ArrangementClosedRightTraits_2`,
|
||||
* `ArrangementContractedRightTraits_2`, and
|
||||
* `ArrangementIdentifiedRightTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementOpenRightTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_open_side_tag`.
|
||||
typedef unspecified_type Right_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* A model of the concept `ArrangementOpenTopTraits_2` must be used when the
|
||||
* parameter space of the surface, the arrangement is embedded on, is open on
|
||||
* the top side and curves inserted into the arrangement are expected to reach
|
||||
* this boundary side. A model of this concept can handle curves that reach the
|
||||
* top boundary side when it is open.
|
||||
*
|
||||
* \cgalRefines `ArrangementTopSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementOpenLeftTraits_2`,
|
||||
* `ArrangementOpenRightTraits_2`,
|
||||
* `ArrangementOpenBottomTraits_2`,
|
||||
* `ArrangementClosedTopTraits_2`,
|
||||
* `ArrangementContractedTopTraits_2`, and
|
||||
* `ArrangementIdentifiedTopTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementOpenTopTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
|
||||
//! Must be convertible to `Arr_open_side_tag`.
|
||||
typedef unspecified_type Top_side_category;
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* `ArrangementRightSideTraits_2` is an abstract concept. It generalizes all
|
||||
* concepts that handle curves that either reach or approach the right boundary
|
||||
* side of the parameter space.
|
||||
*
|
||||
* \cgalRefines `ArrangementVerticalSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementLeftSideTraits_2`,
|
||||
* `ArrangementBottomSideTraits_2`, and
|
||||
* `ArrangementTopSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementRightSideTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* Models of the concept `ArrangementSphericalBoundaryTraits_2` handle curves on
|
||||
* a sphere or a surface that is topological equivalent to a sphere. The sphere
|
||||
* is oriented in such a way that the boundary of the rectangular parameter
|
||||
* space, the sphere is the mapping of which, is identified on the left and
|
||||
* right sides and contracted at the top and bottom sides. In other words,
|
||||
*
|
||||
* \cgalRefines `ArrangementBasicTraits_2`
|
||||
* \cgalRefines `ArrangementIdentifiedLeftTraits_2`
|
||||
* \cgalRefines `ArrangementIdentifiedRightTraits_2`
|
||||
* \cgalRefines `ArrangementContractedBottomTraits_2`
|
||||
* \cgalRefines `ArrangementContractedTopTraits_2`
|
||||
* \cgalRefines
|
||||
*
|
||||
* \cgalHasModel `CGAL::Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>`
|
||||
*
|
||||
* \sa `ArrangementOpenBoundaryTraits_2`
|
||||
* \sa `ArrangementBasicTraits_2`
|
||||
* \sa `ArrangementIdentifiedLeftTraits_2`
|
||||
* \sa `ArrangementIdentifiedRightTraits_2`
|
||||
* \sa `ArrangementContractedBottomTraits_2`
|
||||
* \sa `ArrangementContractedTopTraits_2`
|
||||
* \sa `ArrangementHorizontalSideTraits_2`
|
||||
* \sa `ArrangementVerticalSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementSphericalBoundaryTraits_2 {
|
||||
public:
|
||||
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
}; /* end ArrangementSphericalBoundaryTraits_2 */
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* `ArrangementTopSideTraits_2` is an abstract concept. It generalizes all
|
||||
* concepts that handle curves that either reach or approach the top boundary
|
||||
* side of the parameter space.
|
||||
*
|
||||
* \cgalRefines `ArrangementHorizontalSideTraits_2`
|
||||
*
|
||||
* \sa `ArrangementLeftSideTraits_2`,
|
||||
* `ArrangementRightSideTraits_2`, and
|
||||
* `ArrangementBottomSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementTopSideTraits_2 {
|
||||
public:
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
/// @}
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
/*!
|
||||
* \ingroup PkgArrangement2ConceptsTraits
|
||||
* \cgalConcept
|
||||
*
|
||||
* `ArrangementVerticalSideTraits_2` is an abstract concept. It generalizes all
|
||||
* concepts that handle curves that either reach or approach either the left
|
||||
* or right sizeds of the boundary of the parameter space.
|
||||
*
|
||||
* \cgalRefines `ArrangementBasicTraits_2`
|
||||
*
|
||||
* \cgalHasModel `CGAL::Arr_geodesic_arc_on_sphere_traits_2<Kernel, X, Y>`
|
||||
*
|
||||
* \sa `ArrangementVerticalSideTraits_2`
|
||||
*/
|
||||
|
||||
class ArrangementVerticalSideTraits_2 {
|
||||
public:
|
||||
|
||||
/// \name Categories
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Types
|
||||
/// @{
|
||||
/// @}
|
||||
|
||||
/// \name Functor Types
|
||||
/// @{
|
||||
|
||||
/// models the concept `ArrTraits::ParameterSpaceInX_2`.
|
||||
typedef unspecified_type Parameter_space_in_y_2;
|
||||
|
||||
/// models the concept `ArrTraits::CompareXOnBoundary_2`.
|
||||
typedef unspecified_type Compare_y_on_boundary_2;
|
||||
|
||||
/// models the concept `ArrTraits::CompareXNearBoundary_2`.
|
||||
typedef unspecified_type Compare_y_near_boundary_2;
|
||||
/// @}
|
||||
|
||||
/// \name Accessing Functor Objects
|
||||
/// @{
|
||||
Parameter_space_in_y_2 parameter_space_in_y_2_object() const;
|
||||
Compare_y_on_boundary_2 compare_y_on_boundary_2_object() const;
|
||||
Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const;
|
||||
/// @}
|
||||
|
||||
}; /* end ArrangementHorizontalSideTraits_2 */
|
||||
|
|
@ -111,13 +111,36 @@ implemented as peripheral classes or as free (global) functions.
|
|||
- `ArrangementLandmarkTraits_2`
|
||||
- `ArrangementXMonotoneTraits_2`
|
||||
- `ArrangementTraits_2`
|
||||
- `ArrangementHorizontalSideTraits_2`
|
||||
- `ArrangementVerticalSideTraits_2`
|
||||
- `ArrangementOpenBoundaryTraits_2`
|
||||
- `ArrangementSphericalBoundaryTraits_2`
|
||||
- `ArrangementInputFormatter`
|
||||
- `ArrangementOutputFormatter`
|
||||
- `ArrangementWithHistoryInputFormatter`
|
||||
- `ArrangementWithHistoryOutputFormatter`
|
||||
- `ArrangementPointLocation_2`
|
||||
- `ArrangementVerticalRayShoot_2`
|
||||
- `ArrangementOpenLeftTraits_2`
|
||||
- `ArrangementOpenRightTraits_2`
|
||||
- `ArrangementOpenBottomTraits_2`
|
||||
- `ArrangementOpenTopTraits_2`
|
||||
- `ArrangementClosedLeftTraits_2`
|
||||
- `ArrangementClosedRightTraits_2`
|
||||
- `ArrangementClosedBottomTraits_2`
|
||||
- `ArrangementClosedTopTraits_2`
|
||||
- `ArrangementContractedLeftTraits_2`
|
||||
- `ArrangementContractedRightTraits_2`
|
||||
- `ArrangementContractedBottomTraits_2`
|
||||
- `ArrangementContractedTopTraits_2`
|
||||
- `ArrangementIdentifiedLeftTraits_2`
|
||||
- `ArrangementIdentifiedRightTraits_2`
|
||||
- `ArrangementIdentifiedBottomTraits_2`
|
||||
- `ArrangementIdentifiedTopTraits_2`
|
||||
- `ArrangementLeftSideTraits_2`
|
||||
- `ArrangementRightSideTraits_2`
|
||||
- `ArrangementBottomSideTraits_2`
|
||||
- `ArrangementTopSideTraits_2`
|
||||
|
||||
## Geometric Object Concepts ##
|
||||
|
||||
|
|
@ -138,8 +161,8 @@ implemented as peripheral classes or as free (global) functions.
|
|||
- `ArrTraits::Equal_2`
|
||||
- `ArrTraits::ParameterSpaceInX_2`
|
||||
- `ArrTraits::ParameterSpaceInY_2`
|
||||
- `ArrTraits::CompareXAtLimit_2`
|
||||
- `ArrTraits::CompareXNearLimit_2`
|
||||
- `ArrTraits::CompareXOnBoundary_2`
|
||||
- `ArrTraits::CompareXNearBoundary_2`
|
||||
- `ArrTraits::CompareYNearBoundary_2`
|
||||
- `ArrTraits::Intersect_2`
|
||||
- `ArrTraits::Split_2`
|
||||
|
|
@ -151,10 +174,13 @@ implemented as peripheral classes or as free (global) functions.
|
|||
|
||||
## Classes ##
|
||||
|
||||
|
||||
- `CGAL::Arrangement_on_surface_2<GeometryTraits_2,TopologyTraits>`
|
||||
- `CGAL::Arrangement_on_surface_with_history_2<GeometryTraits_2,TopologyTraits>`
|
||||
- `CGAL::Arrangement_2<Traits,Dcel>`
|
||||
- `CGAL::Arrangement_with_history_2<Traits,Dcel>`
|
||||
- `CGAL::Arr_accessor<Arrangement>`
|
||||
- `CGAL::Arr_observer<Arrangement>`
|
||||
- `CGAL::Arrangement_with_history_2<Traits,Dcel>`
|
||||
- `CGAL::Arrangement_2::Vertex`
|
||||
- `CGAL::Arrangement_2::Halfedge`
|
||||
- `CGAL::Arrangement_2::Face`
|
||||
|
|
@ -174,6 +200,7 @@ implemented as peripheral classes or as free (global) functions.
|
|||
- `CGAL::Arr_rational_function_traits_2<AlgebraicKernel_d_1>`
|
||||
- `CGAL::Arr_Bezier_curve_traits_2<RatKernel,AlgKernel,NtTraits>`
|
||||
- `CGAL::Arr_algebraic_segment_traits_2<Coefficient>`
|
||||
- `CGAL::Arr_geodesic_arc_on_sphere_traits_2<Kernel>`
|
||||
- `CGAL::Arr_curve_data_traits_2<Tr,XData,Mrg,CData,Cnv>`
|
||||
- `CGAL::Arr_consolidated_curve_data_traits_2<Traits,Data>`
|
||||
- `CGAL::Arr_text_formatter<Arrangement>`
|
||||
|
|
|
|||
|
Before Width: | Height: | Size: 5.6 KiB After Width: | Height: | Size: 22 KiB |
|
Before Width: | Height: | Size: 8.5 KiB After Width: | Height: | Size: 28 KiB |
|
Before Width: | Height: | Size: 14 KiB After Width: | Height: | Size: 14 KiB |
|
After Width: | Height: | Size: 2.2 KiB |
|
After Width: | Height: | Size: 10 KiB |
|
After Width: | Height: | Size: 9.4 KiB |
|
After Width: | Height: | Size: 8.7 KiB |
|
After Width: | Height: | Size: 9.9 KiB |
|
After Width: | Height: | Size: 9.5 KiB |
|
Before Width: | Height: | Size: 5.0 KiB |
|
Before Width: | Height: | Size: 5.8 KiB |
|
Before Width: | Height: | Size: 928 B After Width: | Height: | Size: 3.6 KiB |
|
Before Width: | Height: | Size: 12 KiB After Width: | Height: | Size: 11 KiB |
|
After Width: | Height: | Size: 4.4 KiB |
|
After Width: | Height: | Size: 6.2 KiB |
|
After Width: | Height: | Size: 3.9 KiB |
|
After Width: | Height: | Size: 14 KiB |
|
After Width: | Height: | Size: 7.4 KiB |
|
Before Width: | Height: | Size: 1.8 KiB After Width: | Height: | Size: 4.3 KiB |
|
After Width: | Height: | Size: 3.8 KiB |
|
After Width: | Height: | Size: 11 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 5.9 KiB |
|
After Width: | Height: | Size: 13 KiB |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 3.9 KiB |
|
Before Width: | Height: | Size: 10 KiB After Width: | Height: | Size: 25 KiB |
|
After Width: | Height: | Size: 7.3 KiB |
|
Before Width: | Height: | Size: 1.8 KiB |
|
|
@ -0,0 +1,16 @@
|
|||
\documentclass[12pt]{standalone}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\psset{treevshift=0,unit=1em,xunit=2em,yunit=1em,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\jtree[everylabel=\sl,xunit=70pt,arrows=->]
|
||||
\! = {\psframebox{\concept{ArrangementBasicTraits\_2}}}
|
||||
<vert>[scaleby=0 1.6]{\psframebox{\concept{ArrangementXMonotoneTraits\_2}}}@axmt !axmt
|
||||
.
|
||||
\!axmt = <vert>[scaleby=0 1.6]{\psframebox{\concept{ArrangementTraits\_2}}}@at !at
|
||||
.
|
||||
\endjtree
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\end{document}
|
||||
|
|
@ -0,0 +1,652 @@
|
|||
% ======== Font ===============================================================
|
||||
\usepackage[T1]{fontenc}
|
||||
\usepackage{lmodern}
|
||||
\usepackage{slantsc}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{amsfonts}
|
||||
\usepackage[english]{babel}
|
||||
\usepackage[latin1]{inputenc}
|
||||
\usepackage{pifont}
|
||||
|
||||
% ======== Math ===============================================================
|
||||
\usepackage{amsmath,amscd,amsthm}
|
||||
\usepackage{empheq}
|
||||
|
||||
% ======== pdf, url and hyperlink =============================================
|
||||
% \usepackage{url}
|
||||
\usepackage{hyperref}
|
||||
\usepackage[hyphenbreaks]{breakurl}
|
||||
|
||||
% ======== Tables =============================================================
|
||||
\usepackage{multirow}
|
||||
\usepackage{multicol}
|
||||
\usepackage{tabularx}
|
||||
|
||||
% ======== Listings ===========================================================
|
||||
\usepackage{alltt}
|
||||
\usepackage{listings}
|
||||
\usepackage{mdwlist}
|
||||
|
||||
% ======== Graphics ===========================================================
|
||||
\usepackage{graphicx}
|
||||
\usepackage{etex}
|
||||
% \usepackage{pst-all}
|
||||
\usepackage{pstricks,pst-node,pst-tree,pst-text,pst-3d,pst-plot,pst-eucl}
|
||||
\usepackage{pst-xkey,pst-jtree}
|
||||
\usepackage{pst-lens}
|
||||
\usepackage{colordvi}
|
||||
% The tikz package loads the graphicx package, so no need to load it again.
|
||||
% Trying to load it with different options will cause the "Option
|
||||
% clash" error. Use \PassOptionsToPackage{<options>}{graphicx} before
|
||||
% loading tikz to pass any additional options to the internally loaded
|
||||
% graphicx.
|
||||
\usepackage{tikz}
|
||||
\usepackage{pgfplots}
|
||||
\usepackage{mathptmx}
|
||||
\usetikzlibrary{calc,patterns,decorations.pathmorphing,decorations.markings,matrix,fit,decorations.pathreplacing,arrows,automata,positioning,shapes,chains,spy}
|
||||
%\usetikzlibrary{quotes,angles,graph}
|
||||
\usetikzlibrary{intersections,through,backgrounds}
|
||||
\usepackage{tikz-3dplot}
|
||||
\tikzset{%
|
||||
invisible/.style={opacity=0},
|
||||
only/.code args={<#1>#2}{\only<#1>{\pgfkeysalso{#2}}},
|
||||
alt/.code args={<#1>#2#3}{\alt<#1>{\pgfkeysalso{#2}}{\pgfkeysalso{#3}}},
|
||||
temporal/.code args={<#1>#2#3#4}{%
|
||||
\temporal<#1>{\pgfkeysalso{#2}}{\pgfkeysalso{#3}}{\pgfkeysalso{#4}}},
|
||||
point/.style={circle,inner sep=1.5pt,minimum size=1.5pt,draw,fill=#1},
|
||||
point/.default=red
|
||||
}
|
||||
\makeatletter
|
||||
\def\nodesDef{\@ifnextchar[{\@nodesDefWith}{\@nodesDefWithout}}
|
||||
\def\@nodesDefWith[#1]#2{\foreach \c in #2 { \node[point=#1] (n\c) at (\c) {}; }}
|
||||
\def\@nodesDefWithout#1{\foreach \c in #1 { \node[point] (n\c) at (\c) {}; }}
|
||||
\makeatother
|
||||
% #1 --- list of points
|
||||
% #2 --- list of segments
|
||||
% #3 --- first point
|
||||
% #4 --- draw color
|
||||
% #5 --- fill color
|
||||
\newcommand{\directedPolygon}[5]{
|
||||
\fill[#4] (#3) \foreach \pa/\pb in #2 {-- (\pb)};
|
||||
\nodesDef{#1}
|
||||
\foreach \pa/\pb in #2 {
|
||||
\draw[thick,#5,->,>=stealth] (n\pa) -- (n\pb);
|
||||
};
|
||||
}
|
||||
%
|
||||
% ======== Miscellaneous ======================================================
|
||||
\usepackage{fancybox}
|
||||
\usepackage{calc}
|
||||
\usepackage{xspace}
|
||||
% \usepackage{picins}
|
||||
\usepackage[absolute,overlay]{textpos}
|
||||
\usepackage{ifthen}
|
||||
\usepackage{etoolbox}
|
||||
%
|
||||
|
||||
%\usepackage{pgfpages}
|
||||
%\pgfpagesuselayout{4 on 1}[letterpaper,border shrink=5mm,landscape]
|
||||
%\pgfpagesuselayout{4 on 1}[a4paper,landscape]
|
||||
|
||||
% ======== DO NOT MOVE - Reset awkward values changed by pst-jtree ============
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
%
|
||||
% ======== Figures ============================================================
|
||||
\DeclareGraphicsExtensions{.png}
|
||||
\DeclareGraphicsExtensions{.jpg}
|
||||
% \DeclareGraphicsRule{.png}{eps}{.bb}{`convert -compress JPEG #1 eps2:-}
|
||||
\DeclareGraphicsRule{.png}{eps}{.bb}{`convert #1 eps2:-}
|
||||
\DeclareGraphicsRule{.jpg}{eps}{.bb}{`convert #1 eps2:-}
|
||||
%
|
||||
% ======== Bibliography =======================================================
|
||||
\newcommand{\etalchar}[1]{$^{#1}$}
|
||||
%
|
||||
% ======== colors =============================================================
|
||||
\definecolor{lightred}{rgb}{1,0.8,0.8}
|
||||
\definecolor{lightblue}{rgb}{0.8,0.8,1}
|
||||
\definecolor{mediumred}{rgb}{1,0.5,0.5}
|
||||
\definecolor{mediumblue}{rgb}{0.5,0.5,1}
|
||||
\definecolor{darkred}{rgb}{0.5,0,0}
|
||||
\definecolor{darkblue}{rgb}{0,0,0.5}
|
||||
\definecolor{darkcyan}{rgb}{0,0.5,0.5}
|
||||
\definecolor{lightcyan}{rgb}{0.5,1,1}
|
||||
\definecolor{lightyellow}{rgb}{0.9,0.9,0.7}
|
||||
\definecolor{olivegreen}{rgb}{.42,.55,.14}
|
||||
\definecolor{seagreen}{rgb}{.18,.54,.34}
|
||||
|
||||
\newrgbcolor{lessthan}{1 0.2 0.2}
|
||||
\newrgbcolor{equal}{1 1 0.2}
|
||||
\newrgbcolor{greaterthan}{0.2 0.2 1}
|
||||
|
||||
\newrgbcolor{pcolor}{0.7 0.3 0.1}
|
||||
\newrgbcolor{qcolor}{0 0 1}
|
||||
\newrgbcolor{mscolor}{0.5 0.5 0}
|
||||
%
|
||||
\definecolor{polyALightColor}{rgb}{0.75,0.75,1}
|
||||
\definecolor{polyBLightColor}{rgb}{1,0.8,0.3}
|
||||
\definecolor{polyCLightColor}{rgb}{1,1,0.25}
|
||||
\definecolor{polyDLightColor}{rgb}{1,1,0.75}
|
||||
|
||||
\definecolor{polyAColor}{rgb}{0.5,0.7,1}
|
||||
\definecolor{polyBColor}{rgb}{1,0.72,0.225}
|
||||
\definecolor{polyCColor}{rgb}{0.8,0.9,0.2}
|
||||
\definecolor{polyDColor}{rgb}{0.8,0.8,0.6}
|
||||
|
||||
\definecolor{polyADarkColor}{rgb}{0.2,0.4,0.67}
|
||||
\definecolor{polyBDarkColor}{rgb}{0.67,0.4,0.12}
|
||||
\definecolor{polyCDarkColor}{rgb}{0.53,0.6,0.13}
|
||||
\definecolor{polyDDarkColor}{rgb}{0.53,0.53,0.4}
|
||||
|
||||
\definecolor{polyABDarkColor}{rgb}{0.5,0.35,0.4}
|
||||
|
||||
\definecolor{crossColor}{rgb}{1,0,0.5}
|
||||
|
||||
\newrgbcolor{hot_color}{1 0 0}
|
||||
\newrgbcolor{nonactive_color}{0.7 0.7 0.7}
|
||||
\newrgbcolor{discovered}{0 0 0}
|
||||
\newrgbcolor{active_color}{0 0 1}
|
||||
|
||||
\definecolor{obstacle}{rgb}{0.9,0.2,0.1}
|
||||
\definecolor{robot1}{rgb}{0.1,0.4,0.9}
|
||||
\definecolor{robot2}{rgb}{0.4,0.1,0.9}
|
||||
\definecolor{minksum0}{rgb}{0.8,0.9,0.2}
|
||||
|
||||
\newrgbcolor{annulus-color}{0.000 0.690 0.000}
|
||||
\newrgbcolor{in-color}{0.9 0 0} %% {0.000 0.490 0.000}
|
||||
\newrgbcolor{out-color}{0 0 0.9} % {0.690 0.000 0.690}
|
||||
\newrgbcolor{inout-color}{0.000 0.490 0.000}
|
||||
\newrgbcolor{circles-color}{0.690 0.000 0.69}
|
||||
%
|
||||
% ======== Theorems ===========================================================
|
||||
%% \newtheorem{observation}[theorem]{Observation}
|
||||
%% \newtheorem{proposition}[theorem]{Proposition}
|
||||
%% \newtheorem{application}[theorem]{Application}
|
||||
%
|
||||
% ======== general macros =====================================================
|
||||
\def\gf{\textsc{Geometry Factory}}
|
||||
\def\inria{\textsc{INRIA}}
|
||||
\def\mpi{\textsc{MPII}}
|
||||
\newcommand{\bez}{B{\'e}zier}
|
||||
\newcommand{\unitsphere}{\ensuremath{{\mathbb S}^2}}
|
||||
\newcommand{\Rtwo}{\ensuremath{\reals \rule{0.3mm}{0mm}^2}\xspace} % R^2
|
||||
\newcommand{\Rthree}{\ensuremath{\reals \rule{0.3mm}{0mm}^3}\xspace} % R^3
|
||||
\newcommand{\Rd}{\ensuremath{\reals \rule{0.3mm}{0mm}^d}\xspace} % R^d
|
||||
\newcommand{\Rx}[1]{\ensuremath{\reals \rule{0.3mm}{0mm} ^ {#1}}\xspace} % R^x
|
||||
\newcommand{\SOd}[1]{\ensuremath{{\mathbb S} \rule{0.3mm}{0mm} ^ {#1}}}
|
||||
\newcommand{\SOtwo}{\SOd{2}\xspace}
|
||||
\newcommand{\R}{\ensuremath{\mathbb{R}}} %
|
||||
\newcommand{\Z}{\ensuremath{\mathbb{Z}}} %
|
||||
\newcommand{\Expect}{{\rm I\kern-.3em E}}
|
||||
|
||||
\def\eps{{\epsilon}}
|
||||
\newcommand{\mindia}[1]{\ensuremath{{\mathcal M}(#1)}}
|
||||
\newcommand{\distance}[2]{\ensuremath{\rho(#1, #2)}}
|
||||
\newcommand{\distancesqr}[2]{\ensuremath{\rho^2(#1, #2)}}
|
||||
\newcommand{\bisector}[2]{\ensuremath{B(#1, #2)}}
|
||||
\newcommand{\cpp}{{C}{\tt ++}}
|
||||
\newcommand{\windows}{\textsc{Windows}}
|
||||
\newcommand{\unix}{\textsc{Unix}}
|
||||
\newcommand{\linux}{\textsc{Linux}}
|
||||
\newcommand{\cygwin}{\textsc{Cygwin}}
|
||||
\newcommand{\stl}{\textsc{Stl}}
|
||||
\newcommand{\cgal}{\textsc{Cgal}}
|
||||
\newcommand{\cmake}{\textsc{CMake}}
|
||||
\newcommand{\gmp}{\textsc{Gmp}}
|
||||
\newcommand{\gnu}{\textsc{Gnu}}
|
||||
\newcommand{\mpfr}{\textsc{Mpfr}}
|
||||
\newcommand{\core}{\textsc{Core}}
|
||||
\newcommand{\boost}{\textsc{Boost}}
|
||||
\newcommand{\qt}{\textsc{Qt}}
|
||||
\newcommand{\leda}{\textsc{Leda}}
|
||||
\newcommand{\vlsi}{\textsc{Vlsi}}
|
||||
\newcommand{\dcel}{\textsc{Dcel}}
|
||||
\newcommand{\ccb}{\textsc{Ccb}}
|
||||
\newcommand{\parms}{{\rm I\!\hspace{-0.025em} P}}
|
||||
\newcommand{\reals}{{\rm I\!\hspace{-0.025em} R}}
|
||||
\newcommand{\redpart}{{\sc \textcolor{red}{$R$}}}
|
||||
\newcommand{\greenpart}{{\sc \textcolor{green}{$G$}}}
|
||||
\newcommand{\bluepart}{{\sc \textcolor{blue}{$B$}}}
|
||||
\newcommand{\purplepart}{{\sc \textcolor{magenta}{$P$}}}
|
||||
\newcommand{\yellowpart}{{\sc \textcolor{orange}{$Y$}}}
|
||||
\newcommand{\turquoisepart}{{\sc \textcolor{cyan}{$T$}}}
|
||||
\newcommand{\kdtree}{\textsc{Kd}-tree}
|
||||
\newcommand{\kdtrees}{\textsc{Kd}-trees}
|
||||
\newcommand{\bgl}{\textsc{Bgl}}
|
||||
|
||||
\newcommand{\sgmo}{{\bf SGM}}
|
||||
\newcommand{\cgmo}{{\bf CGM}}
|
||||
\newcommand{\ngmo}{{\bf NGM}}
|
||||
\newcommand{\ch}{{\bf CH}}
|
||||
\newcommand{\Fuku}{{\bf Fuk}}
|
||||
|
||||
\def\concept#1{\textsf{\it #1}}
|
||||
|
||||
\def\calA{{\cal A}}
|
||||
\def\calC{{\cal C}}
|
||||
\def\calG{{\cal G}}
|
||||
\def\calI{{\cal I}}
|
||||
\def\calJ{{\cal J}}
|
||||
\def\calK{{\cal K}}
|
||||
\def\calL{{\cal L}}
|
||||
\def\calM{{\cal M}}
|
||||
\def\calP{{\cal P}}
|
||||
\def\calS{{\cal S}}
|
||||
\def\calT{{\cal T}}
|
||||
\def\calU{{\cal U}}
|
||||
|
||||
% ======== Macros for Voronoi =================================================
|
||||
\newcommand{\distsym}{\ensuremath{\rho}\xspace}
|
||||
\newcommand{\mobius}{M\"o\-bi\-us\xspace}
|
||||
\newcommand{\region}{\ensuremath{{Reg}}}
|
||||
\newcommand{\vor}[1]{\ensuremath{Vor_\distsym(#1)}}
|
||||
\newcommand{\FPFS}{Far\-thest-Point Far\-thest-Site}
|
||||
%
|
||||
% ======== Macros for English =================================================
|
||||
\newcommand{\ie}{i.\,e.,\xspace}
|
||||
\newcommand{\eg}{e.\,g.,\xspace}
|
||||
\newcommand{\etal}{{et~al}.\xspace}
|
||||
\newcommand{\Wlog}{w.\,l.\,o.\,g.\xspace}
|
||||
\newcommand{\apriori}{{\it a~priori}}
|
||||
%
|
||||
% ======== Listings ===========================================================
|
||||
\newlength{\ccBaseWidth}\setlength{\ccBaseWidth}{\textwidth/72}
|
||||
\lstset{%
|
||||
language=C++,%
|
||||
% basewidth=\ccBaseWidth,
|
||||
keywordstyle=\color{blue},commentstyle=\color{red}%
|
||||
}
|
||||
\def\myLstinline#1{\lstinline[columns=fixed]{#1}}
|
||||
%
|
||||
% ======== html ===============================================================
|
||||
\newrgbcolor{hrefcolor}{0.2 0.2 0.6}
|
||||
\def\hrefc#1#2{\href{#1}{\textcolor{hrefcolor}{#2}}}
|
||||
%
|
||||
% ======== PS Tricks ==========================================================
|
||||
\SpecialCoor
|
||||
%
|
||||
\def\myxunit{1}
|
||||
\def\myyunit{1}
|
||||
\def\arrset#1{\psset{unit=#1cm}\def\myxunit{#1}\def\myyunit{#1}}
|
||||
\def\vertexradius{2pt}
|
||||
\def\crossradius{0.15}
|
||||
%
|
||||
\def\arrCross(#1,#2){
|
||||
\psline[linewidth=0.75pt,linecolor=crossColor]
|
||||
(!#1 \crossradius\space \myxunit\space div sub #2)
|
||||
(!#1 \crossradius\space \myxunit\space div add #2)
|
||||
\psline[linewidth=0.75pt,linecolor=crossColor]
|
||||
(!#1 #2 \crossradius\space \myyunit\space div sub)
|
||||
(!#1 #2 \crossradius\space \myyunit\space div add)
|
||||
}
|
||||
\def\arrCrossVertex(#1)#2{
|
||||
\arrCross(#1)
|
||||
\pnode(#1){#2}
|
||||
}
|
||||
\def\arrEmptyVertex(#1)#2{
|
||||
\pscircle*[linecolor=white](#1){\vertexradius}
|
||||
\cnode[linewidth=0.5pt](#1){\vertexradius}{#2}
|
||||
}
|
||||
\def\arrColorVertex(#1)#2#3{
|
||||
\pscircle*[linecolor=#3](#1){\vertexradius}
|
||||
\cnode[linewidth=0.5pt](#1){\vertexradius}{#2}
|
||||
}
|
||||
\def\arrRedVertex(#1)#2{\arrColorVertex(#1){#2}{red}}
|
||||
\def\arrCyanVertex(#1)#2{\arrColorVertex(#1){#2}{cyan}}
|
||||
\def\arrGreenVertex(#1)#2{\arrColorVertex(#1){#2}{green}}
|
||||
\def\arrOliveGreenVertex(#1)#2{\arrColorVertex(#1){#2}{olivegreen}}
|
||||
\def\arrBlueVertex(#1)#2{\arrColorVertex(#1){#2}{blue}}
|
||||
\def\arrGrayVertex(#1)#2{\arrColorVertex(#1){#2}{gray}}
|
||||
\def\arrPurpleVertex(#1)#2{\arrColorVertex(#1){#2}{purple}}
|
||||
|
||||
\def\arrMainVertex(#1)#2{\arrRedVertex(#1){#2}}
|
||||
\def\arrMinorVertex(#1)#2{\arrCyanVertex(#1){#2}}
|
||||
|
||||
\def\arrlvertex[#1](#2)#3#4{
|
||||
\arrMainVertex(#2){#3}
|
||||
\uput[#1]{0}(#2){#4}
|
||||
}
|
||||
\def\arrLabeledColorVertex[#1](#2)#3#4#5{
|
||||
\arrColorVertex(#2){#3}{#4}
|
||||
\uput[#1]{0}(#2){#5}
|
||||
}
|
||||
\def\arrp[#1](#2)#3{\arrlvertex[#1](#2){#3}{$p_{#3}$}}
|
||||
\def\arrv[#1](#2)#3{\arrlvertex[#1](#2){#3}{$v_{#3}$}}
|
||||
\def\arru[#1](#2)#3{\arrlvertex[#1](#2){#3}{$u_{#3}$}}
|
||||
\def\nsarraxes(#1)(#2)(#3){\psaxes*[linecolor=black,linewidth=0.25pt,labels=none]{->}(#1)(#2)(#3)}
|
||||
\def\arraxes(#1)(#2)(#3){\hspace{-3pt}\nsarraxes(#1)(#2)(#3)}
|
||||
\def\arrIntersect{
|
||||
/arrDict 10 dict def
|
||||
arrDict begin
|
||||
/arrIntersect {
|
||||
/arrIntersectDict 14 dict def
|
||||
arrIntersectDict begin
|
||||
/x1 exch def
|
||||
/y1 exch def
|
||||
/x2 exch def
|
||||
/y2 exch def
|
||||
/x3 exch def
|
||||
/y3 exch def
|
||||
/x4 exch def
|
||||
/y4 exch def
|
||||
/dx43 x4 x3 sub def
|
||||
/dy43 y4 y3 sub def
|
||||
/dx13 x1 x3 sub def
|
||||
/dy13 y1 y3 sub def
|
||||
/dx21 x2 x1 sub def
|
||||
/dy21 y2 y1 sub def
|
||||
dx43 dy13 mul dy43 dx13 mul sub
|
||||
dy43 dx21 mul dx43 dy21 mul sub
|
||||
div dup dx21 mul x1 add exch dy21 mul y1 add
|
||||
end
|
||||
} bind def
|
||||
end
|
||||
}
|
||||
\def\arrColorIntersectionVertex(#1,#2)(#3,#4)(#5,#6)(#7,#8){
|
||||
\def\ArgI{{#1}}%
|
||||
\def\ArgII{{#2}}%
|
||||
\def\ArgIII{{#3}}%
|
||||
\def\ArgIV{{#4}}%
|
||||
\def\ArgV{{#5}}%
|
||||
\def\ArgVI{{#6}}%
|
||||
\def\ArgVII{{#7}}%
|
||||
\def\ArgVIII{{#8}}%
|
||||
\arrColorIntersectionVertexRelay
|
||||
}
|
||||
\def\arrColorIntersectionVertexRelay#1#2{
|
||||
\arrColorVertex(!\arrIntersect\space
|
||||
arrDict begin \ArgVIII \ArgVII \ArgVI \ArgV \ArgIV \ArgIII \ArgII \ArgI arrIntersect end
|
||||
){#1}{#2}
|
||||
}
|
||||
\def\arrEmptyIntersectionVertex(#1,#2)(#3,#4)(#5,#6)(#7,#8)#9{
|
||||
\arrEmptyVertex(!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
){#9}
|
||||
}
|
||||
\def\arrMainIntersectionVertex(#1,#2)(#3,#4)(#5,#6)(#7,#8)#9{
|
||||
\arrMainVertex(!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
){#9}
|
||||
}
|
||||
\def\arrCrossIntersectionVertex(#1,#2)(#3,#4)(#5,#6)(#7,#8)#9{
|
||||
\psline[linewidth=0.75pt,linecolor=crossColor](!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
\crossradius\space \myyunit\space div sub
|
||||
)(!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
\crossradius\space \myyunit\space div add
|
||||
)
|
||||
\psline[linewidth=0.75pt,linecolor=crossColor](!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
exch \crossradius\space \myxunit\space div sub exch
|
||||
)(!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
exch \crossradius\space \myxunit\space div add exch
|
||||
)
|
||||
\pnode(!\arrIntersect\space
|
||||
arrDict begin #8 #7 #6 #5 #4 #3 #2 #1 arrIntersect end
|
||||
){#2}
|
||||
}
|
||||
\def\arrTriangle(#1,#2)(#3,#4)(#5,#6)(#7,#8){
|
||||
\def\ArgI{{#1}}%
|
||||
\def\ArgII{{#2}}%
|
||||
\def\ArgIII{{#3}}%
|
||||
\def\ArgIV{{#4}}%
|
||||
\def\ArgV{{#5}}%
|
||||
\def\ArgVI{{#6}}%
|
||||
\def\ArgVII{{#7}}%
|
||||
\def\ArgVIII{{#8}}%
|
||||
\arrTriangleRelayA
|
||||
}
|
||||
\def\arrTriangleRelayA(#1,#2)(#3,#4)#5{
|
||||
\def\ArgIX{{#1}}%
|
||||
\def\ArgX{{#2}}%
|
||||
\def\ArgXI{{#3}}%
|
||||
\def\ArgXII{{#4}}%
|
||||
\pspolygon*[linecolor=#5]
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgVIII \ArgVII \ArgVI \ArgV \ArgIV \ArgIII \ArgII \ArgI arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgXII \ArgXI \ArgX \ArgIX \ArgVIII \ArgVII \ArgVI \ArgV arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgIV \ArgIII \ArgII \ArgI \ArgXII \ArgXI \ArgX \ArgIX arrIntersect
|
||||
end
|
||||
)
|
||||
}
|
||||
\def\arrPolygon(#1,#2)(#3,#4)(#5,#6)(#7,#8){
|
||||
\def\ArgI{{#1}}%
|
||||
\def\ArgII{{#2}}%
|
||||
\def\ArgIII{{#3}}%
|
||||
\def\ArgIV{{#4}}%
|
||||
\def\ArgV{{#5}}%
|
||||
\def\ArgVI{{#6}}%
|
||||
\def\ArgVII{{#7}}%
|
||||
\def\ArgVIII{{#8}}%
|
||||
\arrpolygonRelayA
|
||||
}
|
||||
\def\arrpolygonRelayA(#1,#2)(#3,#4)(#5,#6)(#7,#8){
|
||||
\def\ArgIX{{#1}}%
|
||||
\def\ArgX{{#2}}%
|
||||
\def\ArgXI{{#3}}%
|
||||
\def\ArgXII{{#4}}%
|
||||
\def\ArgXIII{{#5}}%
|
||||
\def\ArgXIV{{#6}}%
|
||||
\def\ArgXV{{#7}}%
|
||||
\def\ArgXVI{{#8}}%
|
||||
\arrpolygonRelayB
|
||||
}
|
||||
\def\arrpolygonRelayB#1{
|
||||
\pspolygon*[linecolor=#1]
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgVIII \ArgVII \ArgVI \ArgV \ArgIV \ArgIII \ArgII \ArgI arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgXII \ArgXI \ArgX \ArgIX \ArgVIII \ArgVII \ArgVI \ArgV arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgXVI \ArgXV \ArgXIV \ArgXIII \ArgXII \ArgXI \ArgX \ArgIX arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgIV \ArgIII \ArgII \ArgI \ArgXVI \ArgXV \ArgXIV \ArgXIII arrIntersect
|
||||
end
|
||||
)
|
||||
}
|
||||
\def\arrPentagon(#1,#2)(#3,#4)(#5,#6)(#7,#8){
|
||||
\def\ArgI{{#1}}%
|
||||
\def\ArgII{{#2}}%
|
||||
\def\ArgIII{{#3}}%
|
||||
\def\ArgIV{{#4}}%
|
||||
\def\ArgV{{#5}}%
|
||||
\def\ArgVI{{#6}}%
|
||||
\def\ArgVII{{#7}}%
|
||||
\def\ArgVIII{{#8}}%
|
||||
\arrPentagonRelayA
|
||||
}
|
||||
\def\arrPentagonRelayA(#1,#2)(#3,#4)(#5,#6)(#7,#8){
|
||||
\def\ArgIX{{#1}}%
|
||||
\def\ArgX{{#2}}%
|
||||
\def\ArgXI{{#3}}%
|
||||
\def\ArgXII{{#4}}%
|
||||
\def\ArgXIII{{#5}}%
|
||||
\def\ArgXIV{{#6}}%
|
||||
\def\ArgXV{{#7}}%
|
||||
\def\ArgXVI{{#8}}%
|
||||
\arrPentagonRelayB
|
||||
}
|
||||
\def\arrPentagonRelayB(#1,#2)(#3,#4)#5{
|
||||
\def\ArgXVII{{#1}}%
|
||||
\def\ArgXVIII{{#2}}%
|
||||
\def\ArgXIX{{#3}}%
|
||||
\def\ArgXX{{#4}}%
|
||||
\pspolygon*[linecolor=#5]
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgVIII \ArgVII \ArgVI \ArgV \ArgIV \ArgIII \ArgII \ArgI arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgXII \ArgXI \ArgX \ArgIX \ArgVIII \ArgVII \ArgVI \ArgV arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgXVI \ArgXV \ArgXIV \ArgXIII \ArgXII \ArgXI \ArgX \ArgIX arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgXX \ArgXIX \ArgXVIII \ArgXVII \ArgXVI \ArgXV \ArgXIV \ArgXIII arrIntersect
|
||||
end
|
||||
)
|
||||
(!\arrIntersect\space
|
||||
arrDict begin
|
||||
\ArgIV \ArgIII \ArgII \ArgI \ArgXX \ArgXIX \ArgXVIII \ArgXVII arrIntersect
|
||||
end
|
||||
)
|
||||
}
|
||||
\def\arredge#1#2{
|
||||
\ncline[linewidth=0.5pt,linecolor=blue]{#1}{#2}
|
||||
\ncline[linewidth=0.25pt,offset=3pt]{->}{#1}{#2}
|
||||
\ncline[linewidth=0.25pt,offset=3pt]{->}{#2}{#1}
|
||||
}
|
||||
%
|
||||
\def\smallfilledsquare{\pspolygon*[linecolor=white](0,0)(0.1,0)(0.1,0.1)(0,0.1)}
|
||||
\def\smallsquare{\pspolygon(0,0)(0.1,0)(0.1,0.1)(0,0.1)}
|
||||
%
|
||||
% ======== macros for package names ===========================================
|
||||
\newcommand{\cgalPackage}[1]{{\emph{#1}}}
|
||||
\newcommand{\iiDArrangementsPackage}{\cgalPackage{2D Arrangements}}
|
||||
\newcommand{\iiDIntersectionofCurvesPackage}{\cgalPackage{2D Intersection of Curves}}
|
||||
\newcommand{\iiDSnapRoundingPackage}{\cgalPackage{2D Snap Rounding}}
|
||||
\newcommand{\EnvelopesofCurvesiniiDPackage}{\cgalPackage{Envelopes of Curves in 2D}}
|
||||
\newcommand{\EnvelopesofSurfacesiniiiDPackage}{\cgalPackage{Envelopes of Surfaces in 3D}}
|
||||
\newcommand{\iiDMinkowskiSumsPackage}{\cgalPackage{2D Minkowski Sums}}
|
||||
\newcommand{\iiDRegularizedBooleanSetOperationsPackage}{\cgalPackage{2D Regularized Boolean Set-Operations}}
|
||||
\newcommand{\iiDPolygonsPackage}{\cgalPackage{2D Polygons}}
|
||||
\newcommand{\iiDBooleanOperationsonNefPolygonsPackage}{\cgalPackage{2D Boolean Operations on Nef Polygons}}
|
||||
\newcommand{\iiDBooleanOperationsonNefPolygonsEmbeddedontheSpherePackage}{\cgalPackage{2D Boolean Operations on Nef Polygons Embedded on the Sphere}}
|
||||
\newcommand{\iiiDBooleanOperationsonNefPolyhedraPackage}{\cgalPackage{3D Boolean Operations on Nef Polyhedra}}
|
||||
%
|
||||
% =============================================================================
|
||||
%
|
||||
\newenvironment{FramedVerb}%
|
||||
{\VerbatimEnvironment
|
||||
\begin{Sbox}\begin{minipage}{\textwidth}\begin{Verbatim}}%
|
||||
{\end{Verbatim}\end{minipage}\end{Sbox}
|
||||
\setlength{\fboxsep}{8pt}\fbox{\TheSbox}}
|
||||
|
||||
\newenvironment{fminipage}%
|
||||
{\begin{Sbox}\begin{minipage}}%
|
||||
{\end{minipage}\end{Sbox}\fbox{\TheSbox}}
|
||||
|
||||
\newrgbcolor{c1}{0.1 0.1 0.5}
|
||||
\newrgbcolor{c2}{0.2 0.0 0.5}
|
||||
\newrgbcolor{c3}{0.0 0.2 0.5}
|
||||
\newrgbcolor{xpcolor}{1 0.5 0} % intersection point color
|
||||
\newrgbcolor{epcolor}{0 0 0.8} % endpoint color
|
||||
\newrgbcolor{fpcolor}{0 0.8 0} % ficticious point color
|
||||
\newrgbcolor{fccolor}{0 0.5 0} % ficticious curve color
|
||||
|
||||
\newenvironment{packed-enum}{
|
||||
\begin{enumerate}
|
||||
%\setlength{\topsep}{0pt}
|
||||
%\setlength{\partopsep}{0pt}
|
||||
\setlength{\itemsep}{0pt}
|
||||
%\setlength{\parsep}{0pt}
|
||||
\setlength{\rightmargin}{0pt}
|
||||
%\setlength{\listparindent}{0pt}
|
||||
%\setlength{\itemindent}{0pt}
|
||||
%\setlength{\labelsep}{0pt}
|
||||
%\setlength{\labelwidth}{0pt}
|
||||
%%\makelabel{label}
|
||||
\setlength{\leftmargin}{\labelwidth+\labelsep}
|
||||
}{\end{enumerate}}
|
||||
%
|
||||
% ======= acolumns ============================================================
|
||||
\usepackage{environ}% Required for \NewEnviron, i.e. to read the whole body of the environment
|
||||
\makeatletter
|
||||
\newcounter{acolumn}% Number of current column
|
||||
\newlength{\acolumnmaxheight}% Maximum column height
|
||||
|
||||
% `column` replacement to measure height
|
||||
\newenvironment{@acolumn}[1]{%
|
||||
\stepcounter{acolumn}%
|
||||
\begin{lrbox}{\@tempboxa}%
|
||||
\begin{minipage}{#1}%
|
||||
}{%
|
||||
\end{minipage}
|
||||
\end{lrbox}
|
||||
\@tempdimc=\dimexpr\ht\@tempboxa+\dp\@tempboxa\relax
|
||||
% Save height of this column:
|
||||
\expandafter\xdef\csname acolumn@height@\roman{acolumn}\endcsname{\the\@tempdimc}%
|
||||
% Save maximum height
|
||||
\ifdim\@tempdimc>\acolumnmaxheight
|
||||
\global\acolumnmaxheight=\@tempdimc
|
||||
\fi
|
||||
}
|
||||
|
||||
% `column` wrapper which sets the height beforehand
|
||||
\newenvironment{@@acolumn}[1]{%
|
||||
\stepcounter{acolumn}%
|
||||
% The \autoheight macro contains a \vspace macro with the maximum height minus the natural column height
|
||||
\edef\autoheight{\noexpand\vspace*{\dimexpr\acolumnmaxheight-\csname acolumn@height@\roman{acolumn}\endcsname\relax}}%
|
||||
% Call original `column`:
|
||||
\orig@column{#1}%
|
||||
}{%
|
||||
\endorig@column
|
||||
}
|
||||
|
||||
% Save orignal `column` environment away
|
||||
\let\orig@column\column
|
||||
\let\endorig@column\endcolumn
|
||||
|
||||
% `columns` variant with automatic height adjustment
|
||||
\NewEnviron{acolumns}[1][]{%
|
||||
% Init vars:
|
||||
\setcounter{acolumn}{0}%
|
||||
\setlength{\acolumnmaxheight}{0pt}%
|
||||
\def\autoheight{\vspace*{0pt}}%
|
||||
% Set `column` environment to special measuring environment
|
||||
\let\column\@acolumn
|
||||
\let\endcolumn\end@acolumn
|
||||
\BODY% measure heights
|
||||
% Reset counter for second processing round
|
||||
\setcounter{acolumn}{0}%
|
||||
% Set `column` environment to wrapper
|
||||
\let\column\@@acolumn
|
||||
\let\endcolumn\end@@acolumn
|
||||
% Finally process columns now for real
|
||||
\begin{columns}[#1]%
|
||||
\BODY
|
||||
\end{columns}%
|
||||
}
|
||||
\makeatother
|
||||
%
|
||||
% ======== Tikz museful macros==================================================
|
||||
% Usage \arcThroughThoPoints[options]{center}{p}{q};
|
||||
\newcommand{\arcThroughThoPoints}[4][]{
|
||||
\coordinate (center) at (#2);
|
||||
\draw[#1]
|
||||
let \p1=($(#3)-(center)$),
|
||||
\p2=($(#4)-(center)$),
|
||||
\n0={veclen(\p1)}, % Radius
|
||||
\n1={atan2(\x1,\y1)}, % angles
|
||||
\n2={atan2(\x2,\y2)},
|
||||
\n3={\n2>\n1?\n2:\n2+360}
|
||||
in (#3) arc(\n1:\n3:\n0);
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
\documentclass[12pt]{standalone}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\psset{treevshift=0,unit=1em,xunit=2em,yunit=1em,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\jtree[everylabel=\sl,xunit=70pt,arrows=->]
|
||||
\! = {\psframebox{\concept{ArrangementBasicTraits\_2}}}
|
||||
<left>[scaleby=1.2 1.6]{\psframebox{\concept{ArrangementApproximateTraits\_2}}}@aat !aat
|
||||
^<right>[scaleby=1.8 1.6]{\psframebox{\concept{ArrangementConstructXMonotoneCurveTraits\_2}}}@acxmct !acxmct
|
||||
.
|
||||
\!aat = <right>[scaleby=1.2 1.6]{\psframebox{\concept{ArrangementLandmarkTraits\_2}}}@alt !alt
|
||||
.
|
||||
\ncline{acxmct:b}{alt:t}
|
||||
\endjtree
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\end{document}
|
||||
|
After Width: | Height: | Size: 3.8 KiB |
|
|
@ -0,0 +1,16 @@
|
|||
\documentclass[12pt]{standalone}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\psset{treevshift=0,unit=1em,xunit=2em,yunit=1em,everytree={},etcratio=.75,triratio=.5}
|
||||
\jtree[everylabel=\sl,xunit=70pt,arrows=->]
|
||||
\! = {\psframebox{\concept{ArrangementLeftSideTraits\_2}}}
|
||||
<4wideleft>[scaleby=2.44 1]{\psframebox{\concept{ArrangementOpenLeftTraits\_2}}}@ult !ult
|
||||
^<left>[scaleby=1.37 1]{\psframebox{\concept{ArrangemenClosedLeftTraits\_2}}}@urt !urt
|
||||
^<right>[scaleby=1.11 1]{\psframebox{\concept{ArrangemenContractedLeftTraits\_2}}}@ubt !ubt
|
||||
^<4wideright>[scaleby=2.44 1]{\psframebox{\concept{ArrangemenIdentifiedLeftTraits\_2}}}@utt !utt
|
||||
.
|
||||
\endjtree
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\end{document}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
# latex ws.tex
|
||||
# dvips -E ws.dvi -o
|
||||
# epstool --bbox --copy ws.ps ws.eps
|
||||
# ps2pdf -dEPSCrop ws.eps ws.pdf
|
||||
|
||||
TARGETS = simple_arr.pdf
|
||||
|
||||
.DEFAULT_GOAL = all
|
||||
.PHONY: all clean
|
||||
|
||||
all: $(TARGETS)
|
||||
|
||||
%.dvi: %.tex
|
||||
latex $<
|
||||
|
||||
%.ps: %.dvi
|
||||
dvips -E $< -o
|
||||
|
||||
%.eps: %.ps
|
||||
epstool --bbox --copy $< $@
|
||||
|
||||
%.pdf: %.eps
|
||||
ps2pdf -dEPSCrop $< $@
|
||||
|
||||
clean:
|
||||
rm -f $(DOCUMENTS)
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
\documentclass[12pt]{standalone}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\psset{treevshift=0,unit=1em,xunit=2em,yunit=1em,everytree={},etcratio=.75,triratio=.5}
|
||||
\jtree[everylabel=\sl,xunit=70pt,arrows=->]
|
||||
\! = {}
|
||||
<4wideleft>[scaleby=2.35 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangementOpenLeftTraits\_2}}}@ult !ult
|
||||
^<left>[scaleby=1.21 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangemenOpenRightTraits\_2}}}@urt !urt
|
||||
^<right>[scaleby=1.18 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangemenOpenBottomTraits\_2}}}@ubt !ubt
|
||||
^<4wideright>[scaleby=2.35 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangemenOpenTopTraits\_2}}}@utt !utt
|
||||
.
|
||||
\!ult = <4wideright>[scaleby=2.10 1]{\psframebox{\concept{ArrangementOpenBoundaryTraits\_2}}}@ut !ut
|
||||
.
|
||||
\ncline{urt:b}{ut:t}
|
||||
\ncline{ubt:b}{ut:t}
|
||||
\ncline{utt:b}{ut:t}
|
||||
\endjtree
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\end{document}
|
||||
|
After Width: | Height: | Size: 3.8 KiB |
|
|
@ -0,0 +1,20 @@
|
|||
\documentclass[12pt]{standalone}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\psset{treevshift=0,unit=1em,xunit=2em,yunit=1em,everytree={},etcratio=.75,triratio=.5}
|
||||
\jtree[everylabel=\sl,xunit=70pt,arrows=->]
|
||||
\! = {}
|
||||
<left>[scaleby=2.31 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangementVerticalSideTraits\_2}}}@vst !vst
|
||||
^<right>[scaleby=2.31 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangemenHorizontalSideTraits\_2}}}@hst !hst
|
||||
.
|
||||
\!hst = <left>[scaleby=1.15 1]{\psframebox{\concept{ArrangementBottomSideTraits\_2}}}@bst !bst
|
||||
^<right>[scaleby=1.15 1]{\psframebox{\concept{ArrangementTopSideTraits\_2}}}@tst !tst
|
||||
.
|
||||
\!vst = <left>[scaleby=1.12 1]{\psframebox{\concept{ArrangementLeftSideTraits\_2}}}@lst !lst
|
||||
^<right>[scaleby=1.12 1]{\psframebox{\concept{ArrangementRightSideTraits\_2}}}@rst !rst
|
||||
.
|
||||
\endjtree
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\end{document}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
\documentclass[11pt]{article}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\arrset{1}%
|
||||
\pspicture[](-3.1,-0.725)(3.1,1.709)
|
||||
%
|
||||
\pscustom[linecolor=blue,linewidth=0pt,fillstyle=hlines,hatchcolor=orange,hatchsep=2pt,hatchwidth=1pt]{%
|
||||
\psplot{-2}{0}{0 x x mul x mul add x x mul add x 4 mul sub 1 add 8 div}
|
||||
\psplot{0}{-2}{0 x x mul x mul sub x x mul add x 4 mul add 1 add 8 div}
|
||||
}
|
||||
%
|
||||
\pscustom[linecolor=blue,linewidth=0pt,fillstyle=vlines,hatchcolor=orange,hatchsep=2pt,hatchwidth=1pt]{
|
||||
\psplot{0}{2}{0 x x mul x mul add x x mul add x 4 mul sub 1 add 8 div}
|
||||
\psplot{2}{0}{0 x x mul x mul sub x x mul add x 4 mul add 1 add 8 div}
|
||||
}
|
||||
%
|
||||
\psplot[linecolor=blue]{-2.5}{3}{0 x x mul x mul sub x x mul add x 4 mul add 1 add 8 div}
|
||||
\psplot[linecolor=blue]{-3}{2.5}{0 x x mul x mul add x x mul add x 4 mul sub 1 add 8 div}
|
||||
%
|
||||
\arrMainVertex(-3,-0.625){1}
|
||||
\arrMainVertex( 3,-0.625){2}
|
||||
\arrMainVertex(-2.5,1.609){3}
|
||||
\arrMainVertex( 2.5,1.609){4}
|
||||
\arrEmptyVertex(-2,0.625){x1}
|
||||
\arrEmptyVertex( 2,0.625){x2}
|
||||
\arrEmptyVertex(0,0.125){x3}
|
||||
\rput(-2.5,1){\textcolor{blue}{$C_1$}}
|
||||
\rput(-2.9,0.15){\textcolor{blue}{$C_2$}}
|
||||
\rput(-1,0.3){\boldmath{$f_1$}}
|
||||
\rput(1,0.3){\boldmath{$f_2$}}
|
||||
\endpspicture
|
||||
\end{document}
|
||||
|
After Width: | Height: | Size: 4.3 KiB |
|
|
@ -0,0 +1,21 @@
|
|||
\documentclass[12pt]{standalone}
|
||||
\input{header}
|
||||
\pagestyle{empty}
|
||||
\begin{document}
|
||||
\psset{treevshift=0,unit=1em,xunit=2em,yunit=1em,everytree={},etcratio=.75,triratio=.5}
|
||||
\jtree[everylabel=\sl,xunit=70pt,arrows=->]
|
||||
\! = {}
|
||||
<4wideleft>[scaleby=2.73 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangementIdentifiedLeftTraits\_2}}}@ult !ult
|
||||
^<left>[scaleby=1.47 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangementIdentifiedRightTraits\_2}}}@urt !urt
|
||||
^<right>[scaleby=1.31 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangementContractedBottomTraits\_2}}}@ubt !ubt
|
||||
^<4wideright>[scaleby=2.73 0,arrows=-,linestyle=none]{\psframebox{\concept{ArrangementContractedTopTraits\_2}}}@utt !utt
|
||||
.
|
||||
\!ult = <4wideright>[scaleby=2.4 1]{\psframebox{\concept{ArrangementSphericalBoundaryTraits\_2}}}@ut !ut
|
||||
.
|
||||
\ncline{urt:b}{ut:t}
|
||||
\ncline{ubt:b}{ut:t}
|
||||
\ncline{utt:b}{ut:t}
|
||||
\endjtree
|
||||
\psset{treevshift=0,unit=1cm,xunit=1cm,yunit=1cm,everytree={},
|
||||
etcratio=.75,triratio=.5}
|
||||
\end{document}
|
||||
|
|
@ -22,9 +22,11 @@ if ( CGAL_FOUND )
|
|||
create_single_source_cgal_program( "${cppfile}" )
|
||||
endforeach()
|
||||
|
||||
if (CMAKE_COMPILER_IS_GNUCXX)
|
||||
add_definitions(-std=c++11)
|
||||
endif()
|
||||
else()
|
||||
|
||||
message(STATUS "This program requires the CGAL library, and will not be compiled.")
|
||||
|
||||
endif()
|
||||
|
||||
message(STATUS "This program requires the CGAL library, and will not be compiled.")
|
||||
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -1,8 +1,6 @@
|
|||
//! \file examples/Arrangement_on_surface_2/polycurve_geodesic.cpp
|
||||
// Constructing an arrangement of polygeodesics.
|
||||
|
||||
#define CGAL_IDENTIFICATION_XY 2
|
||||
|
||||
#include <vector>
|
||||
#include <list>
|
||||
|
||||
|
|
@ -33,18 +31,23 @@ typedef CGAL::Arrangement_on_surface_2<Segment_traits_2, Topol_segment_traits_2>
|
|||
|
||||
int main()
|
||||
{
|
||||
Point_2 p1(0, 1, -1);
|
||||
Point_2 p2(-11, 7, -7);
|
||||
Point_2 p3(-1, 0, 0);
|
||||
Point_2 p4(-11, 7, 7);
|
||||
Point_2 p5(-1, 1, 1);
|
||||
|
||||
Segment_traits_2 seg_traits;
|
||||
Segment_traits_2::Construct_point_2 ctr_p =
|
||||
seg_traits.construct_point_2_object();
|
||||
Segment_traits_2::Construct_x_monotone_curve_2 ctr_seg =
|
||||
seg_traits.construct_x_monotone_curve_2_object();
|
||||
|
||||
Point_2 p1 = ctr_p(0, 1, -1);
|
||||
Point_2 p2 = ctr_p(-11, 7, -7);
|
||||
Point_2 p3 = ctr_p(-1, 0, 0);
|
||||
Point_2 p4 = ctr_p(-11, 7, 7);
|
||||
Point_2 p5 = ctr_p(-1, 1, 1);
|
||||
|
||||
Segment_arr seg_arr(&seg_traits);
|
||||
X_seg_curve_2 seg_cv1(p1, p2);
|
||||
X_seg_curve_2 seg_cv2(p2, p3);
|
||||
X_seg_curve_2 seg_cv3(p3, p4);
|
||||
X_seg_curve_2 seg_cv4(p4, p5);
|
||||
X_seg_curve_2 seg_cv1 = ctr_seg(p1, p2);
|
||||
X_seg_curve_2 seg_cv2 = ctr_seg(p2, p3);
|
||||
X_seg_curve_2 seg_cv3 = ctr_seg(p3, p4);
|
||||
X_seg_curve_2 seg_cv4 = ctr_seg(p4, p5);
|
||||
|
||||
insert(seg_arr, seg_cv1);
|
||||
insert(seg_arr, seg_cv2);
|
||||
|
|
|
|||