Java delaunay三角剖分的代码是如何工作的？

我有一段Java代码，它通过一组输入点返回一组表示Delaunay三角剖分的图的边

我想知道使用了什么策略来实现这一点，如果存在，使用的算法的名称

在此代码中，GraphEdge包含两个awt点并表示三角剖分中的一条边，GraphPoint扩展awt点，最终三角剖分的边在TreeSet对象中返回

我的目的是了解该方法的工作原理：

public TreeSet getEdges(int n, int[] x, int[] y, int[] z)

下面是此三角测量的完整源代码：

import java.awt.Point;
import java.util.Iterator;
import java.util.TreeSet;

public class DelaunayTriangulation
{
   int[][] adjMatrix;

   DelaunayTriangulation(int size)
   {
     this.adjMatrix = new int[size][size];
   }
   public int[][] getAdj() {
     return this.adjMatrix;
   }

   public TreeSet getEdges(int n, int[] x, int[] y, int[] z)
   {
     TreeSet result = new TreeSet();

     if (n == 2)
     {
       this.adjMatrix[0][1] = 1;
       this.adjMatrix[1][0] = 1;
       result.add(new GraphEdge(new GraphPoint(x[0], y[0]), new GraphPoint(x[1], y[1])));

       return result;
     }

     for (int i = 0; i < n - 2; i++) {
       for (int j = i + 1; j < n; j++) {
         for (int k = i + 1; k < n; k++)
         {
           if (j == k) {
             continue;
           }
           int xn = (y[j] - y[i]) * (z[k] - z[i]) - (y[k] - y[i]) * (z[j] - z[i]);

           int yn = (x[k] - x[i]) * (z[j] - z[i]) - (x[j] - x[i]) * (z[k] - z[i]);

           int zn = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
           boolean flag;
           if (flag = (zn < 0 ? 1 : 0) != 0) {
             for (int m = 0; m < n; m++) {
               flag = (flag) && ((x[m] - x[i]) * xn + (y[m] - y[i]) * yn + (z[m] - z[i]) * zn <= 0);
             }

           }

           if (!flag)
           {
             continue;
           }
           result.add(new GraphEdge(new GraphPoint(x[i], y[i]), new GraphPoint(x[j], y[j])));
           //System.out.println("----------");
           //System.out.println(x[i]+" "+ y[i] +"----"+x[j]+" "+y[j]);

          result.add(new GraphEdge(new GraphPoint(x[j], y[j]), new GraphPoint(x[k], y[k])));
          //System.out.println(x[j]+" "+ y[j] +"----"+x[k]+" "+y[k]);
          result.add(new GraphEdge(new GraphPoint(x[k], y[k]), new GraphPoint(x[i], y[i])));
           //System.out.println(x[k]+" "+ y[k] +"----"+x[i]+" "+y[i]);
           this.adjMatrix[i][j] = 1;
           this.adjMatrix[j][i] = 1;
           this.adjMatrix[k][i] = 1;
           this.adjMatrix[i][k] = 1;
           this.adjMatrix[j][k] = 1;
           this.adjMatrix[k][j] = 1;
         }

       }

     }

     return result;
   }

   public TreeSet getEdges(TreeSet pointsSet)
   {
     if ((pointsSet != null) && (pointsSet.size() > 0))
     {
       int n = pointsSet.size();

       int[] x = new int[n];
       int[] y = new int[n];
       int[] z = new int[n];

       int i = 0;

       Iterator iterator = pointsSet.iterator();
       while (iterator.hasNext())
       {
         Point point = (Point)iterator.next();

         x[i] = (int)point.getX();
         y[i] = (int)point.getY();
         z[i] = (x[i] * x[i] + y[i] * y[i]);

         i++;
       }

       return getEdges(n, x, y, z);
     }

     return null;
   }
 }

导入java.awt.Point；
导入java.util.Iterator；
导入java.util.TreeSet；
公共类delaunay三角剖分
{
int[][]调整矩阵；
Delaunay三角剖分（整数大小）
{
this.adjMatrix=新整数[size][size]；
}
公共int[]getAdj（）{
返回这个.adj矩阵；
}
公共树集getEdge（int n，int[]x，int[]y，int[]z）
{
树集结果=新树集（）；
如果（n==2）
{
该矩阵[0][1]=1；
该矩阵[1][0]=1；
结果.添加（新图形边缘（新图形点（x[0]，y[0]），新图形点（x[1]，y[1]））；
返回结果；
}
对于（int i=0；i

看起来像这里描述的：

在d维欧几里德空间中寻找一组点的Delaunay三角剖分的问题可以转化为在（d+1）中寻找一组点的凸包的问题-维空间，通过给每个点p一个等于| p | 2的额外坐标，取凸包的底面，并通过删除最后一个坐标映射回d维空间

在您的示例中，

d

是2

向量

（xn，yn，zn）

是向量

（点i->点j）

和

（点i->点k）

的叉积，或者换句话说，是垂直于三角形的向量

（点i，点j，点k）

---

标志的计算

检查此三角形的法线是否指向负z方向，以及所有其他点是否位于三角形法线的对面（相反，因为其他点需要在三角形平面上方，因为我们对凸包的底部感兴趣）。如果是这种情况，三角形

（i，j，k）

是三维凸包的一部分，因此是

x

和

y

组件（3D三角形在x，y平面上的投影）是（2D）Delaunay三角剖分的一部分。

代码是从哪里获得的。为什么不问问代码的作者？