Constraints CGAL:2D约束Delaunay三角剖分-向约束添加信息

在将点添加到三角剖分器对象之前，可以将信息（如INT）附加到点。我这样做是因为一方面我需要一个int标志，我使用lateron来定义我的纹理坐标，另一方面我需要一个索引，我使用它来创建一个索引VBO。

但我只想插入约束边，而不是点。如果我同时插入两个CGAL，会返回奇怪的结果，因为点已经被输入了两次（一次作为点，一次作为约束边的点）。

是否可以使用与点信息相同的方式连接到“约束”，以便我只能使用此函数

cdt。插入_约束（点（j，0），点（j，6））在迭代生成的面之前

稍后，当我在三角形上循环时，我需要一些方法来访问我以前定义的int标志。与此类似，但不是在顶点上，而是由约束边定义的线段的“端点”：

for(CDT::Finite_faces_iterator fit = m_cdt.finite_faces_begin(); fit != m_cdt.finite_faces_end(); ++fit, ++k) {

    int j = k*3;
    for(int i=0; i < 3; i++) {

        indices[j+i] = fit->vertex(i)->info().first;
    }
}

for（CDT:：Finite_faces_iterator fit=m_CDT.Finite_faces_begin（）；fit！=m_CDT.Finite_faces_end（）；++fit，++k）{
int j=k*3；
对于（int i=0；i<3；i++）{
索引[j+i]=拟合->顶点（i）->信息（）。首先；
}
}

这个问题是我在这里发布的另一个问题的一部分：。
因为这是一个自己的问题，我第二次独立发布了它。
问题的作者自己找到了解决方案，但没有发布答案。所以，我会做的


答案位于这些网站和官方网站上

将描述当您只需要为
点
自定义类时的情况

获取源代码并修改/添加所需内容

#ifndef MY_POINTC2_H
#define MY_POINTC2_H
#include <CGAL/Origin.h>

class Point_i2 {
private:
  double vec[2];
  int ind;
public:
  Point_i2() : ind(0)
  {
    *vec = 0;
    *(vec+1) = 0;
  }
  Point_i2(const double x, const double y, int i = 0) : ind(i)
  {
    *vec = x;
    *(vec+1) = y;
  }
  const double& x() const  { return *vec; }
  const double& y() const { return *(vec+1); }
  double & x() { return *vec; }
  double& y() { return *(vec+1); }
  int index() const { return ind; }
  int& index() { return ind; }
  bool operator==(const Point_i2 &p) const
  {
    return ( *vec == *(p.vec) )  && ( *(vec+1) == *(p.vec + 1) && ( ind == p.ind) );
  }
  bool operator!=(const Point_i2 &p) const
  {
      return !(*this == p);
  }
};
#endif // MY_POINTC2_H

\ifndef MY_POINTC2\H
#定义我的_点C2_H
#包括
类点_i2{
私人：
双vec[2]；
int ind；
公众：
点_i2（）：ind（0）
{
*vec=0；
*（vec+1）=0；
}
点_i2（常数倍x，常数倍y，int i=0）：ind（i）
{
*vec=x；
*（vec+1）=y；
}
常量double&x（）常量{return*vec；}
常量double&y（）常量{return*（vec+1）；}
double&x（）{return*vec；}
double&y（）{return*（vec+1）；}
int index（）常量{return ind；}
int&index（）{return ind；}
布尔运算符==（常数点2&p）常数
{
返回（*vec==*（p.vec））&&（*（vec+1）=*（p.vec+1）&&（ind==p.ind））；
}
布尔运算符！=（常数点2&p）常数
{
返回！（*this==p）；
}
};
#endif//MY_POINTC2_H

然后创建新内核：

#ifndef MYKERNEL_H
#define MYKERNEL_H
#include <CGAL/Cartesian.h>
#include "Point_i2.h"

// K_ is the new kernel, and K_Base is the old kernel
template < typename K_, typename K_Base >
class MyCartesian_base
  : public K_Base::template Base<K_>::Type
{
  typedef typename K_Base::template Base<K_>::Type   OldK;
public:
  typedef K_                                Kernel;
  typedef Point_i2                         Point_2;

  template < typename Kernel2 >
  struct Base { typedef MyCartesian_base<Kernel2, K_Base>  Type; };
};
template < typename FT_ >
struct MyKernel
  : public CGAL::Type_equality_wrapper<
                MyCartesian_base<MyKernel<FT_>, CGAL::Cartesian<FT_> >,
                MyKernel<FT_> >
{};

\ifndef MYKERNEL\u H
#定义MYKERNEL\u H
#包括
#包括“第2.h点”
//K_是新内核，K_Base是旧内核
模板
类MyCartesian_基
：public K_Base:：template Base:：Type
{
typedef typename K_Base:：template Base:：Type OldK；
公众：
typedef K_u内核；
类型定义点2点2；
模板
结构基{typedef MyCartesian_Base Type；}；
};
模板
结构MyKernel
：public CGAL:：Type\u equality\u包装器<
我的笛卡尔基础，
MyKernel>
{};

现在我们可以使用新内核而不是默认内核：

typedef MyKernel<double>                   MK;
typedef CGAL::Filtered_kernel_adaptor<MK>  K;

typedef-MyKernel-MK；
typedef CGAL：：过滤的内核适配器K；
看来我终于解决了！按照以下说明：你能发布一个自我回答，并描述你的解决方案吗？我不确定安德斯和你在评论中描述了什么。