function_objects_polynomial_circular.h

很多二维 三维几何计算算法 C++ 类库

      return (a.rep().left());
    }

    qualified_result_type operator() (const Line_arc_2 & a) const
    {
      return (a.rep().left());
    }

  };

  template <class CK>
  class Construct_circular_max_vertex_2: Has_qrt
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Line_arc_2                Line_arc_2;
    typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;

  public:

    typedef Circular_arc_point_2 result_type;
    typedef const result_type &  qualified_result_type;
    typedef Arity_tag<1>         Arity;
    
    qualified_result_type operator() (const Circular_arc_2 & a) const
    {
//       if (a.rep().Cache_minmax == 's')
// 	return (a.rep().source());
//       if (a.rep().Cache_minmax == 't')
// 	return (a.rep().target());
      return (a.rep().right());
    }

    qualified_result_type operator() (const Line_arc_2 & a) const
    {
      return (a.rep().right());
    }

  };

  template <class CK>
  class Construct_circular_source_vertex_2: Has_qrt
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Line_arc_2                Line_arc_2;
    typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;

  public:

    typedef Circular_arc_point_2 result_type;
    typedef const result_type &  qualified_result_type;
    typedef Arity_tag<1>         Arity;    
    
    qualified_result_type operator() (const Circular_arc_2 & a) const
    { return a.rep().source(); }

    qualified_result_type operator() (const Line_arc_2 & a) const
    { return a.rep().source();}

  };


  template <class CK>
  class Construct_circular_target_vertex_2: Has_qrt
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Line_arc_2                Line_arc_2;
    typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;

  public:

    typedef Circular_arc_point_2 result_type;
    typedef const result_type &  qualified_result_type;
    typedef Arity_tag<1>         Arity;
   
    qualified_result_type operator() (const Circular_arc_2 & a) const
    { return a.rep().target();}

    qualified_result_type operator() (const Line_arc_2 & a) const
    { return a.rep().target();}

  };

  template <class CK>
  class Is_x_monotone_2
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Line_arc_2                Line_arc_2;

  public:

    typedef bool         result_type;
    typedef Arity_tag<1> Arity;
    
    result_type operator() (const Circular_arc_2 & a) const
    {
      return (a.rep().is_x_monotone());
    }

    result_type operator() (const Line_arc_2 & a) const
    {
      return (a.rep().is_x_monotone());
    }

  };

  template <class CK>
  class Is_y_monotone_2
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Line_arc_2                Line_arc_2;

  public:

    typedef bool         result_type;
    typedef Arity_tag<1> Arity;
    
    result_type operator() (const Circular_arc_2 & a) const
    {
      return (a.rep().is_y_monotone());
    }

    result_type operator() (const Line_arc_2 & a) const
    {
      return (a.rep().is_y_monotone());
    }

  };


  template <class CK>
  class On_upper_part_2
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;

  public:

    typedef bool         result_type;
    typedef Arity_tag<1> Arity;

    result_type operator() (const Circular_arc_2 & a) const
    {
      return (a.rep().on_upper_part());
    }
  };

  template <class CK>
  class Construct_supporting_circle_2: Has_qrt
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Circle_2                  Circle_2;

  public:

    typedef Circle_2             result_type;
    typedef const result_type &  qualified_result_type;
    typedef Arity_tag<1>         Arity;
    
    qualified_result_type operator() (const Circular_arc_2 & a) const
    {
      return (a.rep().supporting_circle());
    }
  };
  
  
  template <class CK>
  class Construct_supporting_line_2: Has_qrt
  {
    typedef typename CK::Line_arc_2            Line_arc_2;
    typedef typename CK::Line_2                Line_2;
    typedef typename CK::Circle_2              Circle_2;

  public:

    typedef Line_2               result_type;
    typedef const result_type &  qualified_result_type;
    typedef Arity_tag<1>         Arity;
    
    qualified_result_type operator() (const Line_arc_2 & a) const
    {
      return (a.rep().supporting_line());
    }
  };

  template <class CK>
  class Construct_bbox_2
#ifndef CGAL_CFG_MATCHING_BUG_6
    : public CK::Linear_kernel::Construct_bbox_2
#endif
  {
    typedef typename CK::Circular_arc_2            Circular_arc_2;
    typedef typename CK::Circular_arc_point_2      Circular_arc_point_2;
    typedef typename CK::Line_arc_2                Line_arc_2;
    typedef typename CK::Circle_2                  Circle_2;

  public:

    typedef CGAL::Bbox_2 result_type;
    typedef Arity_tag<1> Arity;    

#ifndef CGAL_CFG_MATCHING_BUG_6
    using CK::Linear_kernel::Construct_bbox_2::operator();
#else
    typedef typename  CK::Linear_kernel LK;
    typedef typename LK::Construct_bbox_2 LK_Construct_bbox_2;
    typedef typename LK::Point_2    Point_2;
    typedef typename LK::Segment_2  Segment_2;
    typedef typename LK::Triangle_2 Triangle_2;
    typedef typename LK::Iso_rectangle_2 Iso_rectangle_2;

    result_type operator() (const Circle_2 & a) const
    {
      return LK_Construct_bbox_2()(a);
    }

    result_type operator() (const Point_2 & a) const
    {
      return LK_Construct_bbox_2()(a);
    }

    result_type operator() (const Segment_2 & a) const
    {
      return LK_Construct_bbox_2()(a);
    }

    result_type operator() (const Triangle_2 & a) const
    {
      return LK_Construct_bbox_2()(a);
    }

    result_type operator() (const Iso_rectangle_2 & a) const
    {
      return LK_Construct_bbox_2()(a);
    }

#endif

    result_type operator() (const Circular_arc_point_2 & a) const
    {
      return a.rep().bbox();
    }

    result_type operator() (const Circular_arc_2 & a) const
    {
      return a.rep().bbox();
    }

    result_type operator() (const Line_arc_2 & a) const
    {
      return a.rep().bbox();
    }

  };

  template <class CK>
  class Bounded_side_2
#ifndef CGAL_CFG_MATCHING_BUG_6
    : public CK::Linear_kernel::Bounded_side_2
#endif
  {
    typedef typename CK::Circle_2              Circle_2;
    typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;

  public:
    typedef typename CK::Linear_kernel::Bounded_side    result_type;
    typedef Arity_tag< 2 >              Arity;

#ifndef CGAL_CFG_MATCHING_BUG_6
    using CK::Linear_kernel::Bounded_side_2::operator();
#else 
    typedef typename  CK::Linear_kernel  LK;
    typedef typename LK::Bounded_side_2  LK_Bounded_side_2;    
    typedef typename LK::Triangle_2      Triangle_2;
    typedef typename LK::Iso_rectangle_2 Iso_rectangle_2;
    typedef typename CK::Circle_2        Circle_2;


    result_type
    operator()( const Circle_2& c, const Point_2& p) const
    { return LK_Bounded_side_2()(c,p); }

    result_type
    operator()( const Triangle_2& t, const Point_2& p) const
    { return LK_Bounded_side_2()(t,p); }

    result_type
    operator()( const Iso_rectangle_2& r, const Point_2& p) const
    { return LK_Bounded_side_2()(r,p); }
#endif

    result_type
    operator()(const Circle_2& c, const Circular_arc_point_2& p) const
    { return bounded_side<CK>(c,p); }

  };

  template <class CK>
  class Has_on_bounded_side_2
#ifndef CGAL_CFG_MATCHING_BUG_6
    : public CK::Linear_kernel::Has_on_bounded_side_2
#endif
  {
    typedef typename CK::Circle_2              Circle_2;
    typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;

  public:
    typedef bool result_type;
    typedef Arity_tag< 2 >               Arity;

#ifndef CGAL_CFG_MATCHING_BUG_6
    using CK::Linear_kernel::Has_on_bounded_side_2::operator();
#else
    typedef typename  CK::Linear_kernel  LK;
    typedef typename LK::Has_on_bounded_side_2  LK_Has_on_bounded_side_2;    
    typedef typename LK::Triangle_2      Triangle_2;
    typedef typename LK::Iso_rectangle_2 Iso_rectangle_2;
    typedef typename CK::Circle_2        Circle_2;


    result_type
    operator()( const Circle_2& c, const Point_2& p) const
    { return LK_Has_on_bounded_side_2()(c,p); }

    result_type
    operator()( const Triangle_2& t, const Point_2& p) const
    { return LK_Has_on_bounded_side_2()(t,p); }

    result_type
    operator()( const Iso_rectangle_2& r, const Point_2& p) const
    { return LK_Has_on_bounded_side_2()(r,p); }
#endif

    result_type
    operator()(const Circle_2& c, const Circular_arc_point_2& p) const
    { return CK().bounded_side_2_object()(c,p) == ON_BOUNDED_SIDE; }

  };

  template <class CK>
  class Has_on_unbounded_side_2
#ifndef CGAL_CFG_MATCHING_BUG_6
    : public CK::Linear_kernel::Has_on_unbounded_side_2
#endif
  {
    typedef typename CK::Circle_2              Circle_2;
    typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;

  public:
    typedef bool result_type;
    typedef Arity_tag< 2 >               Arity;

#ifndef CGAL_CFG_MATCHING_BUG_6
    using CK::Linear_kernel::Has_on_unbounded_side_2::operator();
#else
    typedef typename  CK::Linear_kernel  LK;
    typedef typename LK::Has_on_unbounded_side_2  LK_Has_on_unbounded_side_2;    
    typedef typename LK::Triangle_2      Triangle_2;
    typedef typename LK::Iso_rectangle_2 Iso_rectangle_2;
    typedef typename CK::Circle_2        Circle_2;


    result_type
    operator()( const Circle_2& c, const Point_2& p) const
    { return LK_Has_on_unbounded_side_2()(c,p); }

    result_type
    operator()( const Triangle_2& t, const Point_2& p) const
    { return LK_Has_on_unbounded_side_2()(t,p); }

    result_type
    operator()( const Iso_rectangle_2& r, const Point_2& p) const
    { return LK_Has_on_unbounded_side_2()(r,p); }
#endif

    result_type
    operator()(const Circle_2& c, const Circular_arc_point_2& p) const
    { return CK().bounded_side_2_object()(c,p) == ON_UNBOUNDED_SIDE; }

  };

  template <class CK>
  class Orientation_2
#ifndef CGAL_CFG_MATCHING_BUG_6
    : public CK::Linear_kernel::Orientation_2
#endif
  {
    typedef typename CK::Circular_arc_point_2       Circular_arc_point_2;

  public:
    typedef typename CK::Linear_kernel::Orientation   result_type;
    typedef Arity_tag< 3 >            Arity;

#ifndef CGAL_CFG_MATCHING_BUG_6
    using CK::Linear_kernel::Orientation_2::operator();
#else
    typedef typename  CK::Linear_kernel  LK;
    typedef typename LK::Orientation_2 LK_Orientation_2;
    typedef typename LK::Point_2 Point_2;
    typedef typename LK::Vector_2 Vector_2;
    typedef typename LK::Circle_2 Circle_2;

    result_type
    operator()(const Point_2& p, const Point_2& q, const Point_2& r) const
    { return LK_Orientation_2()(p,q, r); }


    result_type
    operator()(const Vector_2& u, const Vector_2& v) const
    { return LK_Orientation_2()(u,v); }

    result_type
    operator()(const Circle_2& c) const
    { return LK_Orientation_2()(c); }
#endif

    result_type
    operator()(const Circular_arc_point_2& p, 
               const Circular_arc_point_2& q, 
               const Circular_arc_point_2& r) const
    { return orientation<CK>(p,q,r); }
  };

  template <class CK>
  class Collinear_2
#ifndef CGAL_CFG_MATCHING_BUG_6
    : public CK::Linear_kernel::Collinear_2
#endif
  {
    typedef typename CK::Circular_arc_point_2       Circular_arc_point_2;

  public:
    typedef typename CK::Linear_kernel::Collinear_2::result_type   result_type;
    typedef Arity_tag< 3 >            Arity;

#ifndef CGAL_CFG_MATCHING_BUG_6
    using CK::Linear_kernel::Collinear_2::operator();
#else
    typedef typename CK::Linear_kernel  LK;
    typedef typename LK::Collinear_2 LK_Collinear_2;
    typedef typename LK::Point_2        Point_2;

    result_type
    operator()(const Point_2& p, const Point_2& q, const Point_2& r) const
    { return LK_Collinear_2()(p, q, r); }
#endif

    // PRE CONDITION: 
    // The coordinates of P, Q, R have to have the same 
    // delta or (beta == 0 || delta == 0)
    // We cannot code this pre condition because
    // if Root_of_2 is interval_nt "beta", "delta" mean nothing
    result_type
    operator()(const Circular_arc_point_2& p, 
               const Circular_arc_point_2& q, 
               const Circular_arc_point_2& r) const
    { return orientation<CK>(p,q,r) == COLLINEAR; }
  };

} // namespace CircularFunctors
} // namespace CGAL

#endif // CGAL_CIRCULAR_KERNEL_FUNCTION_OBJECTS_POLYNOMIAL_CIRCULAR_H