读《An Adaptable and Extensible Geometry Kernel》

利用Curiously Recurring Template Pattern替代虚函数

详细内容可以参考[1]。这里单纯列举出相关的代码示例：

// 使用继承的方式实现不同图形的绘制
class Shape
{
public:
    Shape() {}
    virtual ~Shape() {}
    virtual void Draw() = 0；
};

class Triangle : public Shape
{
public:
    Triangle() {}
    ~Triangle() {}

    void Draw() { cout << "Draw a Triangle" << endl; }
};

class Rectangle : public Shape
{
public:
    Rectangle() {}
    ~Rectangle() {}

    void Draw() { cout << "Draw a Rectangle" << endl; }
};

// 利用Curiously Recurring Template Pattern
template <typename Derived>
class Shape
{
public:
    void Draw()
    {
        return static_cast<Derived*>(this)->Draw();
    }
};
 
class Triangle : public Shape<Triangle>
{
public:
    void Draw() { cout << "Draw a Triangle" << endl; }
};
 
class Rectangle : public Shape<Rectangle>
{
public:
    void Draw() { cout << "Draw a Rectangle" << endl; }
};

为什么需要Kernel

通过Kernel需要解决的主要问题是代码的适配性和可扩展性。那为什么可以提高适配性和可扩展性可以在后续的内容中得到答案。

Kernel的概念和架构

常见的数据结构和算法的设计，数据结构为独立的类，算法为全局或类的成员函数。示例如下：

K::Point_2   p(0,1), q(1,-4);   // 数据结构
K::Line_2    line(p,q);

if (less_xy_2(p, q)) { ... }    // 算法成员函数

几何Kernel包含需要操作的类型，以及针对这些类型的操作。Kernel会将上述相关的内容进行打包处理。示例如下:

K k;
K::Construct_line_2  c_line = k.construct_line_2_object();
K::Less_xy_2         less_xy = k.less_xy_2_object();
K::Point_2           p(0,1), q(1,-4);
K::Line_2            line = c_line(p, q);

if (less_xy(p, q)) { ... }

Kernel将数据结构和算法相关的细节放到了内部。整体的架构可以分为三层，Kernel， Geometric Primitives，Numeric Primitives，具体如下：

Kernel的实现

第一版本

template <class K> struct MyPoint { };
template <class K> struct MyLine { };
template <class K> struct MyConstruct { };
template <class K> struct MyLess { };

struct Kernel {
    typedef MyPoint<Kernel> Point_2;
    typedef MyLine<Kernel> Line_2;
    typedef MyConstruct<Kernel> Construct_line_2;
    typedef MyLess<Kernel> Less_xy_2;
};

// Generate new Kernel
template <class K> struct NewPoint { };
template <class K> struct MyLeftTurn { };
struct New_kernel : public Kernel {
    typedef NewPoint<New_kernel> Point_2;
    typedef MyLeftTurn<New_kernel> Left_turn_2;
};

int main()
{
    New_kernel::Point_2 p, q;
    New_kernel::Construct_line_2 construct_line_2;
    New_kernel::Line_2 l = construct_line_2(p, q);
    return 0;
}

测试环境可以见： https://ideone.com/MrXCDD

编译错误为：

prog.cpp: In function ‘int main()’:
prog.cpp:28:49: error: no match for call to ‘(Kernel::Construct_line_2 {aka MyConstruct<Kernel>}) (New_kernel::Point_2&, New_kernel::Point_2&)’
     New_kernel::Line_2 l = construct_line_2(p, q);

从编译错误中可见，New_kernel::Construct_line_2其实调用的是MyConstruct<Kernel>的实现，而我们想要的调用是MyConstruct<New_kernel>。依赖关系见下图：

这个版本中另一个隐含的问题是，循环引用的问题，具体如下：

template <class K> struct P {
    typedef K::A B;
};

struct Kernel {
    typedef P<Kernel>::B B;
    typedef int A;
};

为了解决上面的问题，进行了第二版本的改进。

第二版本

为了降低不同Kernel之间的关联性，引入Kernel_base，具体如下：

template <class K> struct MyPoint { };
template <class K> struct MyLine { };
template <class K> struct MyConstruct { };
template <class K> struct MyLess { };

template <class K>
struct Kernel_base {
    typedef MyPoint<K> Point_2;
    typedef MyLine<K> Line_2;
    typedef MyConstruct<K> Construct_line_2;
    typedef MyLess<K> Less_xy_2;
};

struct Kernel : public Kernel_base<Kernel> { };

// Generate new Kernel
template <class K> struct NewPoint { };
template <class K> struct MyLeftTurn { };

template<class K>
struct New_kernel_base : public Kernel_base<K> {
    typedef NewPoint<K> Point_2;
    typedef MyLeftTurn<K> Left_turn_2;
};

struct New_kernel : public New_kernel_base<New_kernel> {};

int main()
{
    New_kernel::Point_2 p, q;
    New_kernel::Construct_line_2 construct_line_2;
    New_kernel::Line_2 l = construct_line_2(p, q);
    return 0;
}

测试环境可以见：https://ideone.com/40wOCa

编译错误如下：

prog.cpp: In function ‘int main()’:
prog.cpp:35:49: error: no match for call to ‘(Kernel_base<New_kernel>::Construct_line_2 {aka MyConstruct<New_kernel>}) (New_kernel_base<New_kernel>::Point_2&, New_kernel_base<New_kernel>::Point_2&)’
     New_kernel::Line_2 l = construct_line_2(p, q);
                                                 ^

从编译结果中可得，Construct_line_2对应的New_kernel正是我们所预期的。接下来需要解决的问题是，construct_line_2并不是可以调用的函数。调整后kernel之间的依赖关系如下：

第三版本

该版本中，利用函数对象来处理操作逻辑。

template <class K> struct MyPoint { };
template <class K> struct MyLine { };
template <class K> struct MyConstruct { 
    typedef typename K::Line_2 Line_2;
    typedef typename K::Point_2 Point_2;

    Line_2 operator() (Point_2, Point_2) const
    {
        return Line_2();
    }
};

template <class K> struct MyLess {
    typedef typename K::Point_2 Point_2;

    bool operator() (Point_2, Point_2) const
    {
        return true;
    }
};

template <class K>
struct Kernel_base {
    typedef MyPoint<K> Point_2;
    typedef MyLine<K> Line_2;
    typedef MyConstruct<K> Construct_line_2;
    typedef MyLess<K> Less_xy_2;
    Construct_line_2 construct_line_2_object();
    Less_xy_2        less_xy_2_object();
};

struct Kernel : public Kernel_base<Kernel> { };

// Generate new Kernel
template <class K> struct NewPoint { };
template <class K> struct MyLeftTurn { };

template<class K>
struct New_kernel_base : public Kernel_base<K> {
    typedef NewPoint<K> Point_2;
    typedef MyLeftTurn<K> Left_turn_2;
};

struct New_kernel : public New_kernel_base<New_kernel> {};

int main()
{
    New_kernel::Point_2 p, q;
    New_kernel::Construct_line_2 construct_line_2;
    New_kernel::Line_2 l = construct_line_2(p, q);
    return 0;
}

示例程序见：https://ideone.com/6ISelp

整个编译过程成功通过。

到此处，整个kernel的结构基本完善了。

Kernel使用示例说明算法的适应性

以2D点集凸包计算的实现来举例：https://doc.cgal.org/latest/Convex_hull_2/index.html。仅仅针对算法实现过程中Kernel的使用进行简单说明，对算法的具体实现此处不进行介绍。

// 暴露给外部调用的接口
template <class InputIterator, class OutputIterator>
inline
OutputIterator
ch_graham_andrew( InputIterator first,
                  InputIterator last,
                  OutputIterator result)
{
    typedef std::iterator_traits<InputIterator> ITraits;
    typedef typename ITraits::value_type        value_type;
    typedef CGAL::Kernel_traits<value_type>     KTraits;    // 根据value_type获取KernelTraits
    typedef typename KTraits::Kernel            Kernel;     // 进一步获取Kernel
    return ch_graham_andrew(first, last, result, Kernel()); // 传入Kernel，调用具体实现
}

// 具体实现
template <class InputIterator, class OutputIterator, class Traits>
OutputIterator
ch_graham_andrew( InputIterator  first,
                       InputIterator  last,
                       OutputIterator result,
                       const Traits&  ch_traits)
{
  typedef  typename Traits::Point_2     Point_2;     // 获取Kernel中的类型
  typedef  typename Traits::Equal_2      Equal_2;    // 获取Kernel中的类型
  
  Equal_2      equal_points = ch_traits.equal_2_object();  // 获取kernel中的算法

  if (first == last) return result;
  std::vector< Point_2 >  V (first, last);
  std::sort( V.begin(), V.end(), ch_traits.less_xy_2_object() ); // 获取Kernel中的算法
  if (equal_points( *(V.begin()), *(V.rbegin())) )
  {
      *result++ = *(V.begin());
      return result;
  }

  #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \
    || defined(NDEBUG)
  OutputIterator  res(result);
  #else
  Tee_for_output_iterator<OutputIterator,Point_2> res(result);
  #endif // no postconditions ...
  ch__ref_graham_andrew_scan( V.begin(), V.end(),  res, ch_traits);
  ch__ref_graham_andrew_scan( V.rbegin(), V.rend(), res, ch_traits);
  CGAL_ch_postcondition( \
      is_ccw_strongly_convex_2( res.output_so_far_begin(), \
                                     res.output_so_far_end(), \
                                     ch_traits));
  CGAL_ch_expensive_postcondition( \
      ch_brute_force_check_2( \
          V.begin(), V.end(), \
          res.output_so_far_begin(), res.output_so_far_end(), \
          ch_traits));
  #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \
    || defined(NDEBUG)
  return res;
  #else
  return res.to_output_iterator();
  #endif // no postconditions ...
}

从上面简单的示例可得，一般在算法构建的时候会在最外层生成调用接口，然后，在具体实现中，通过分别对Kernel中的数据结构和算法的调用，最后组装成一个完整的算法实现。

简单的完整的Kernel

此处将文章最后的示例代码贴出来，用于进一步完善对Kernel的认知。

//------------------------------------------------------------
// bottom layer: number type based function toolbox
//

template <class FT>
FT determinant2x2(FT a00, FT a01, FT a10, FT a11)
{
    return a00*a11 - a10*a01;
}

template <class FT>
void line_from_pointsC2(FT px, FT py, FT qx, FT qy, FT &a, FT &b, FT &c) {}

//------------------------------------------------------------
// mid layer: representations, predicates and constructions
//

template <class K_>
struct Point_2 {
    typedef K_ K;
    typedef typename K::FT FT;
    Point_2() {}
    Point_2(FT x_, FT y_) : x(x_), y(y_) {}
    FT x, y;
};

template <class K_>
struct Line_2 {
    typedef K_ K;
    typedef typename K::Point_2 Point_2;
    Line_2() {}
    Line_2(Point_2 p, Point_2 q) { *this = K::Construct_line_2(p,q); }
    typename K::FT a, b, c;
};

template <class K_>
struct Segment_2 {
    typedef K_ K;
    typename K::Point_2 s, e;
};

template <class K_>
struct Less_xy_2 {
    typedef typename K_::Point_2 Point_2;
    bool operator()(Point_2 p, Point_2 q) const
    { return p.x < q.x || p.x == q.x && p.y < q.y; }
};

template <class K_>
struct Left_turn_2 {
    typedef typename K_::Point_2 Point_2;
    bool operator()(Point_2 p, Point_2 q, Point_2 r) const
    {
        return determinant2x2(q.x - p.x, q.y - p.y,
                              r.x - p.x, r.y - q.y) > 0;
    }
};

template <class K_>
struct Construct_line_2 {
    typedef typename K_::Point_2 Point_2;
    typedef typename K_::Line_2 Line_2;
    Line_2 operator()(Point_2 p, Point_2 q) const {
        Line_2 l;
        Line_from_pointsC2(p.x, p.y, q.x, q.y, l.a, l.b, l.c);
        return l;
    }
};

//------------------------------------------------------------
// top layer: geometric kernel
//

template <class K_, class FT_>
struct Kernel_bae {
    typedef K_                           K;
    typedef FT_                          FT;
    typedef Point_2<K>                   Point_2;
    typedef Line_2<K>                    Line_2;
    typedef Segment_2<K>                 Segment_2;
    typedef Less_xy_2<K>                 Less_xy_2;
    typedef Left_turn_2<K>               Left_turn_2;
    typedef Construct_line_2<K>          Construct_line_2;

    Less_xy_2 less_xy_2_object() const { return Less_xy_2(); }
    Left_turn_2 Left_turn_2_object() const { return Left_turn_2(); }
    Construct_line_2 construct_line_2_object() const { return Construct_line_2(); }
};

template <class FT_>
struct Kernel : public Kernel_base<Kernel<FT_>, FT_>
{};

//------------------------------------------------------------
// convenience layer: global functions
//

template < class K >inline
bool
less_xy_2(typename K::Point_2 p,typename K::Point_2 q, K k = K())
{ returnk.less_xy_2_object()(p, q); }

template < class K >inline
bool
left_turn_2(typenameK::Point_2 p,
            typenameK::Point_2 q,
            typenameK::Point_2 r,
            K k = K())
{ returnk.left_turn_2_object()(p, q, r); }

//------------------------------------------------------------
// enve more convenience: specializations for kernel
//

template < class FT > inline
bool
left_turn_2(Point_2< Kernel< FT > > p,
            Point_2< Kernel< FT > > q,
            Point_2< Kernel< FT > > r)
{ returnleft_turn_2(p, q, r, Kernel< FT >()); }

template < class FT >inline
bool
less_xy_2(Point_2< Kernel< FT > > p, Point_2< Kernel< FT > > q)
{ returnless_xy_2(p, q, Kernel< FT >()); }

参考

[1] https://www.geeksforgeeks.org/curiously-recurring-template-pattern-crtp-2/
[2] An Adaptable and Extensible Geometry Kernel https://inf.ethz.ch/~hoffmann/pub/hhkps-aegk-01a.pdf

posted @ 2019-05-05 09:10 grassofsky 阅读(296) 评论(0) 收藏举报

刷新页面返回顶部