第15章 - 三角剖分与 Voronoi

public final QuadEdge rot();      // 逆时针 90°，对偶
public final QuadEdge sym();      // rot.rot，反向边
public final QuadEdge invRot();   // rot.sym，顺时针 90°
public final QuadEdge oNext();    // next，绕起点的下一条出边
public final QuadEdge oPrev();    // rot.next.rot
public final QuadEdge dNext();    // sym.oNext.sym
public final QuadEdge dPrev();    // invRot.oNext.invRot
public final QuadEdge lNext();    // invRot.oNext.rot，左面下一条
public final QuadEdge lPrev();    // next.sym
public final QuadEdge rNext();    // rot.next.invRot
public final QuadEdge rPrev();    // sym.oNext

/** 创建一条从 o 到 d 的新边，返回 orig 侧记录 */
public static QuadEdge makeEdge(Vertex o, Vertex d);

/** 把两条边的 next 环拼接（splice） */
public static void splice(QuadEdge a, QuadEdge b);

/** 在 a 的终点与 b 的起点之间连一条新边 */
public static QuadEdge connect(QuadEdge a, QuadEdge b);

/** 翻转边 e（用于 Delaunay 局部优化） */
public static void swap(QuadEdge e);

import org.locationtech.jts.triangulate.quadedge.QuadEdge;
import org.locationtech.jts.triangulate.quadedge.Vertex;

public class QuadEdgeDemo {
    public static void main(String[] args) {
        Vertex a = new Vertex(0, 0);
        Vertex b = new Vertex(10, 0);
        Vertex c = new Vertex(0, 10);
        Vertex d = new Vertex(2, 2);      // 三角形内部一点，用于外接圆判定

        QuadEdge e0 = QuadEdge.makeEdge(a, b);   // a -> b
        QuadEdge e1 = QuadEdge.makeEdge(b, c);   // b -> c
        QuadEdge e2 = QuadEdge.makeEdge(c, a);   // c -> a

        QuadEdge.splice(e0.sym(), e1);           // 把 b 处连起来
        QuadEdge.splice(e1.sym(), e2);
        QuadEdge.splice(e2.sym(), e0);

        System.out.println("e0=" + e0 + ", sym=" + e0.sym());
        System.out.println("e0.oNext()=" + e0.oNext());
        System.out.println("e0.lNext()=" + e0.lNext());
        System.out.println("d.isInCircle(a,b,c)=" + d.isInCircle(a, b, c));
    }
}

public QuadEdgeSubdivision(Envelope env, double tolerance);
private void createFrame(Envelope env) {
    double frameSize = Math.max(deltaX, deltaY) * FRAME_SIZE_FACTOR; // 10.0
    frameVertex[0] = new Vertex(centreX, env.getMaxY() + frameSize);
    frameVertex[1] = new Vertex(env.getMinX() - frameSize, env.getMinY() - frameSize);
    frameVertex[2] = new Vertex(env.getMaxX() + frameSize, env.getMinY() - frameSize);
    // frameEnv 为框架三角形的包络
}

public QuadEdge locate(Vertex v);
public QuadEdge locate(Coordinate p);
public QuadEdge insertSite(Vertex v);
public boolean isDelaunay();          // 全量检查所有边是否满足局部 Delaunay

import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.DelaunayTriangulationBuilder;
import org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision;
import org.locationtech.jts.triangulate.quadedge.Vertex;

public class SubdivisionWalkDemo {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        Geometry sites = new WKTReader().read(
            "MULTIPOINT ((10 10), (10 20), (20 20))");

        DelaunayTriangulationBuilder builder = new DelaunayTriangulationBuilder();
        builder.setSites(sites);
        QuadEdgeSubdivision subdiv = builder.getSubdivision();
        System.out.println("isDelaunay=" + subdiv.isDelaunay());
        System.out.println("vertices=" + subdiv.getVertices(false).size());
        System.out.println("triangles=" + subdiv.getTriangles(gf).getNumGeometries());

        // 每个三角形输出顶点坐标
        List<Coordinate[]> coords = subdiv.getTriangleCoordinates(false);
        for (Coordinate[] tri : coords) {
            System.out.println("三角形顶点：" + tri[0] + " / " + tri[1] + " / " + tri[2]);
        }

        // 也可以拿到三角形顶点对象
        List<Vertex[]> verts = subdiv.getTriangleVertices(false);
        System.out.println("三角形数(Vertex)=" + verts.size());

        // 查找某条边
        System.out.println("locate((15,15))=" + subdiv.locate(new Coordinate(15, 15)));
        Polygon ignored = null;
        Geometry unused = null;
    }
}

public class DelaunayTriangulationBuilder {
    public DelaunayTriangulationBuilder();
    public void setSites(Geometry geom);        // 从几何的坐标中取站点
    public void setSites(Collection coords);    // 直接给 Coordinate 集合
    public void setTolerance(double tolerance);
    public QuadEdgeSubdivision getSubdivision();
    public Geometry getEdges(GeometryFactory geomFact);
    public Geometry getTriangles(GeometryFactory geomFact);
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.DelaunayTriangulationBuilder;

public class DelaunayDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        GeometryFactory gf = new GeometryFactory();

        Geometry sites = reader.read("MULTIPOINT ((10 10), (10 20), (20 20))");
        DelaunayTriangulationBuilder builder = new DelaunayTriangulationBuilder();
        builder.setSites(sites);

        System.out.println("边：" + builder.getEdges(gf));
        System.out.println("三角形：" + builder.getTriangles(gf));
    }
}

Geometry sites = reader.read(
    "MULTIPOINT ((50 40), (140 70), (80 100), (130 140),"
    + " (30 150), (70 180), (190 110), (120 20))");

// 校验：三角形面积之和应等于凸包面积
Geometry tris = builder.getTriangles(gf);
double triArea = tris.getArea();
double hullArea = new org.locationtech.jts.algorithm.ConvexHull(
    sites).getConvexHull().getArea();
System.out.println("三角形面积和=" + triArea + ", 凸包面积=" + hullArea);
System.out.println("一致=" + (Math.abs(triArea - hullArea) < 1e-6));

public class ConformingDelaunayTriangulationBuilder {
    public ConformingDelaunayTriangulationBuilder();
    public void setSites(Geometry geom);
    public void setConstraints(Geometry constraintLines);  // 约束线，通常是 LineString/MultiLineString
    public void setTolerance(double tolerance);
    public QuadEdgeSubdivision getSubdivision();
    public Geometry getEdges(GeometryFactory geomFact);
    public Geometry getTriangles(GeometryFactory geomFact);
}

do {
    splits = enforceGabriel(segments);
    count++;
} while (splits > 0 && count < MAX_SPLIT_ITER);

if (count == MAX_SPLIT_ITER) {
    throw new ConstraintEnforcementException(
        "Too many splitting iterations while enforcing constraints.  Last split point was at: ",
        splitPt);
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder;

public class ConformingDelaunayDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        GeometryFactory gf = new GeometryFactory();

        ConformingDelaunayTriangulationBuilder builder =
            new ConformingDelaunayTriangulationBuilder();
        // 四个角点 + 一条竖直约束线
        builder.setSites(reader.read(
            "MULTIPOINT ((0 0), (10 0), (10 10), (0 10))"));
        builder.setConstraints(reader.read("LINESTRING (5 0, 5 10)"));
        builder.setTolerance(0.0);

        Geometry tris = builder.getTriangles(gf);
        System.out.println("三角形数=" + tris.getNumGeometries());
        System.out.println("总面积=" + tris.getArea());
        System.out.println("边=" + builder.getEdges(gf));
    }
}

public interface ConstraintSplitPointFinder {
    Coordinate findSplitPoint(Segment seg, Coordinate encroachPt);
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.triangulate.ConstraintSplitPointFinder;
import org.locationtech.jts.triangulate.Segment;

public class EndpointSplitFinder implements ConstraintSplitPointFinder {
    @Override
    public Coordinate findSplitPoint(Segment seg, Coordinate encroachPt) {
        // 简化示例：取中点（生产代码应做安全区间判断）
        return seg.midPoint();
    }
}

public class VoronoiDiagramBuilder {
    public VoronoiDiagramBuilder();
    public void setSites(Geometry geom);
    public void setSites(Collection coords);
    public void setClipEnvelope(Envelope clipEnv);   // 裁剪范围
    public void setTolerance(double tolerance);
    public QuadEdgeSubdivision getSubdivision();
    public Geometry getDiagram(GeometryFactory geomFact);
}

diagramEnv = clipEnv;
if (diagramEnv == null) {
    diagramEnv = DelaunayTriangulationBuilder.envelope(siteCoords);
    double expandBy = diagramEnv.getDiameter();
    diagramEnv.expandBy(expandBy);   // 四周各扩一个对角线长度
}

import org.locationtech.jts.geom.Envelope;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.VoronoiDiagramBuilder;

public class VoronoiDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        GeometryFactory gf = new GeometryFactory();

        VoronoiDiagramBuilder builder = new VoronoiDiagramBuilder();
        builder.setSites(reader.read(
            "MULTIPOINT ((0 0), (10 0), (0 10), (10 10))"));
        builder.setClipEnvelope(new Envelope(-5, 15, -5, 15));
        builder.setTolerance(0.0);

        Geometry diagram = builder.getDiagram(gf);
        System.out.println("面数=" + diagram.getNumGeometries());
        double sum = 0;
        for (int i = 0; i < diagram.getNumGeometries(); i++) {
            Geometry cell = diagram.getGeometryN(i);
            sum += cell.getArea();
            System.out.println("面积=" + cell.getArea()
                + " 站点=" + cell.getUserData());
        }
        System.out.println("面积和=" + sum);
    }
}

import java.util.HashMap;
import java.util.Map;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;

/** 把 Voronoi 面与站点属性关联起来 */
public final class VoronoiLookup {
    private final Map<String, Geometry> cellBySite = new HashMap<String, Geometry>();

    public VoronoiLookup(Geometry diagram) throws Exception {
        for (int i = 0; i < diagram.getNumGeometries(); i++) {
            Geometry cell = diagram.getGeometryN(i);
            Coordinate site = (Coordinate) cell.getUserData();
            if (site == null) continue;
            cellBySite.put(key(site), cell);
        }
    }

    public Geometry cellOf(Coordinate site) {
        return cellBySite.get(key(site));
    }

    private static String key(Coordinate c) {
        return c.x + "," + c.y;
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.index.strtree.STRtree;

public class NearestSiteByVoronoi {
    private final STRtree cellIndex = new STRtree();

    public NearestSiteByVoronoi(Geometry diagram) {
        for (int i = 0; i < diagram.getNumGeometries(); i++) {
            Geometry cell = diagram.getGeometryN(i);
            cellIndex.insert(cell.getEnvelopeInternal(), cell);
        }
        cellIndex.build();
    }

    public Object nearestSite(Point p) {
        for (Object o : cellIndex.query(p.getEnvelopeInternal())) {
            Geometry cell = (Geometry) o;
            if (cell.covers(p)) return cell.getUserData();
        }
        // 裁剪边界外的点没有对应面，返回 null 由调用方处理
        return null;
    }
}

public class Tri {
    public Tri(Coordinate p0, Coordinate p1, Coordinate p2);
    public static Tri create(Coordinate p0, Coordinate p1, Coordinate p2);

    public void setAdjacent(Tri tri0, Tri tri1, Tri tri2);
    public Tri getAdjacent(int index);
    public int getIndex(Coordinate p);      // 顶点在三角形中的下标
    public int getIndex(Tri tri);           // 邻居边的下标

    public Tri split(Coordinate p);         // 在 p 处把三角形一分为三
    public void flip(int index);            // 与第 index 条边对面的三角形交换对角线
    public void remove();                   // 从邻接关系中摘除自身

    public double getArea();
    public double getLength();              // 周长
    public Polygon toPolygon(GeometryFactory geomFact);
    public void validate();                 // 检查方向与邻接一致性
    public boolean isBorder();              // 是否有边界边
    public boolean isInteriorVertex(int index);
}

public class TriangulationBuilder {
    public static void build(List<? extends Tri> triList);
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.triangulate.tri.Tri;
import org.locationtech.jts.triangulate.tri.TriangulationBuilder;

public class TriAdjacentDemo {
    public static void main(String[] args) {
        List<Tri> list = new ArrayList<Tri>();
        // 注意：Tri 要求顺时针，所以顶点顺序是 (0,0),(10,10),(10,0)
        Tri t0 = Tri.create(new Coordinate(0, 0),
                            new Coordinate(10, 10),
                            new Coordinate(10, 0));
        Tri t1 = Tri.create(new Coordinate(10, 10),
                            new Coordinate(0, 0),
                            new Coordinate(0, 10));
        list.add(t0);
        list.add(t1);

        TriangulationBuilder.build(list);
        System.out.println("t0 邻居数=" + t0.numAdjacent()
            + ", t1 邻居数=" + t1.numAdjacent());
        System.out.println("t0 是否含边界边=" + t0.isBorder());
        System.out.println("t0 面积=" + t0.getArea()
            + ", 周长=" + t0.getLength());
        t0.validate();
        System.out.println("邻接校验通过, t0=" + t0);
    }
}

public class PolygonTriangulator {
    public static Geometry triangulate(Geometry geom);
    public PolygonTriangulator(Geometry inputGeom);
    public Geometry getResult();        // GeometryCollection<Polygon>
    public List<Tri> getTriangles();    // 带邻接的三角形列表
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.polygon.PolygonTriangulator;

public class PolygonTriangulatorDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        GeometryFactory gf = new GeometryFactory();
        // 10x10 的方形，中间挖一个 6x6 的洞
        Geometry poly = reader.read(
            "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0),"
            + " (2 2, 2 8, 8 8, 8 2, 2 2))");

        Geometry tris = PolygonTriangulator.triangulate(poly);
        System.out.println("三角形数=" + tris.getNumGeometries());
        System.out.println("三角形面积和=" + tris.getArea());
        System.out.println("原多边形面积=" + poly.getArea());
        System.out.println("首个三角形=" + tris.getGeometryN(0));
    }
}

List<Tri> triList = PolygonEarClipper.triangulate(polyShell);
TriangulationBuilder.build(triList);   // 建邻接
TriDelaunayImprover.improve(triList);  // 反复 flip 直到局部 Delaunay

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator;

public class CDTDemo {
    public static void main(String[] args) throws Exception {
        Geometry poly = new WKTReader().read(
            "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0),"
            + " (2 2, 2 8, 8 8, 8 2, 2 2))");
        Geometry tris = ConstrainedDelaunayTriangulator.triangulate(poly);
        System.out.println("三角形数=" + tris.getNumGeometries());
        System.out.println("面积和=" + tris.getArea());
    }
}

/** 三角形内插值（三点确定平面） */
public static double interpolateZ(Coordinate p, Coordinate v0, Coordinate v1, Coordinate v2);

/** 线段上按距离比例插值 */
public static double interpolateZ(Coordinate p, Coordinate p0, Coordinate p1);

/** 实例方法：以本点为三角形第一顶点 */
public double interpolateZValue(Vertex v0, Vertex v1, Vertex v2);

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.DelaunayTriangulationBuilder;
import org.locationtech.jts.triangulate.quadedge.Vertex;

public class TinDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        GeometryFactory gf = new GeometryFactory();

        Geometry sites = reader.read(
            "MULTIPOINT ((0 0 10), (10 0 20), (0 10 30), (10 10 40))");
        DelaunayTriangulationBuilder builder = new DelaunayTriangulationBuilder();
        builder.setSites(sites);
        Geometry tris = builder.getTriangles(gf);
        System.out.println("三角形：" + tris);

        // 1. 体积：每个三角形是一个三棱柱，体积 = 底面积 × 平均高
        double volume = 0;
        for (int i = 0; i < tris.getNumGeometries(); i++) {
            Polygon p = (Polygon) tris.getGeometryN(i);
            Coordinate[] c = p.getExteriorRing().getCoordinates();
            volume += p.getArea() * (c[0].z + c[1].z + c[2].z) / 3.0;
        }
        System.out.println("体积=" + volume);

        // 2. 插值：查询点落在哪个三角形内
        Coordinate q = new Coordinate(5, 5);
        org.locationtech.jts.geom.Point qp = gf.createPoint(q);
        for (int i = 0; i < tris.getNumGeometries(); i++) {
            Polygon p = (Polygon) tris.getGeometryN(i);
            if (!p.covers(qp)) continue;
            Coordinate[] c = p.getExteriorRing().getCoordinates();
            System.out.println("z(5,5)=" + Vertex.interpolateZ(q, c[0], c[1], c[2]));
        }
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.index.strtree.STRtree;

public class TinLocator {
    private final STRtree index = new STRtree();

    public TinLocator(Geometry triangles) {
        for (int i = 0; i < triangles.getNumGeometries(); i++) {
            Polygon tri = (Polygon) triangles.getGeometryN(i);
            index.insert(tri.getEnvelopeInternal(), tri);
        }
        index.build();
    }

    /** 返回包含该点的第一个三角形；点在公共边上时结果不唯一 */
    public Polygon locate(Point p) {
        for (Object o : index.query(p.getEnvelopeInternal())) {
            Polygon tri = (Polygon) o;
            if (tri.covers(p)) return tri;
        }
        return null;
    }
}

public static double volumeBetween(Geometry triangles, double designElevation) {
    double volume = 0;
    for (int i = 0; i < triangles.getNumGeometries(); i++) {
        Polygon p = (Polygon) triangles.getGeometryN(i);
        if (p.getNumInteriorRing() > 0) continue;      // TIN 三角形无洞
        org.locationtech.jts.geom.Coordinate[] c =
            p.getExteriorRing().getCoordinates();
        double avgZ = (c[0].z + c[1].z + c[2].z) / 3.0;
        volume += p.getArea() * (avgZ - designElevation);
    }
    return volume;
}

// 以数据包络中心为原点，把坐标压到 [-1, 1] 附近
Envelope env = sites.getEnvelopeInternal();
double cx = env.centre().x;
double cy = env.centre().y;
Coordinate[] shifted = new Coordinate[sites.getNumPoints()];
for (int i = 0; i < shifted.length; i++) {
    Coordinate c = sites.getCoordinates()[i];
    shifted[i] = new Coordinate(c.x - cx, c.y - cy, c.getZ());
}
Geometry localSites = new GeometryFactory().createMultiPointFromCoords(shifted);
// 构网后再把结果平移回去

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.triangulate.quadedge.Vertex;

public class TerrainService {
    private final Geometry triangles;
    private final TinLocator locator;
    private final GeometryFactory gf = new GeometryFactory();

    public TerrainService(Geometry triangles) {
        this.triangles = triangles;
        this.locator = new TinLocator(triangles);
    }

    /** 返回高程；点不在 TIN 范围内或 Z 无效时返回 Double.NaN */
    public double elevationAt(double x, double y) {
        Point p = gf.createPoint(new Coordinate(x, y));
        Polygon tri = locator.locate(p);
        if (tri == null) return Double.NaN;
        Coordinate[] c = tri.getExteriorRing().getCoordinates();
        if (Double.isNaN(c[0].z) || Double.isNaN(c[1].z) || Double.isNaN(c[2].z)) {
            return Double.NaN;
        }
        return Vertex.interpolateZ(new Coordinate(x, y), c[0], c[1], c[2]);
    }

    public Geometry getTriangles() { return triangles; }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.locationtech.jts.geom.Envelope;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.VoronoiDiagramBuilder;

public class VoronoiAreaReport {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        Geometry sites = new WKTReader().read(
            "MULTIPOINT ((10 10), (80 20), (40 70), (90 90), (20 90))");

        VoronoiDiagramBuilder builder = new VoronoiDiagramBuilder();
        builder.setSites(sites);
        builder.setClipEnvelope(new Envelope(0, 100, 0, 100));
        Geometry diagram = builder.getDiagram(gf);

        List<String> rows = new ArrayList<String>();
        double total = 0;
        for (int i = 0; i < diagram.getNumGeometries(); i++) {
            Geometry cell = diagram.getGeometryN(i);
            total += cell.getArea();
            rows.add("站点=" + cell.getUserData() + " 面积=" + cell.getArea());
        }
        Collections.sort(rows);
        for (String r : rows) System.out.println(r);
        System.out.println("服务区总面积=" + total);
    }
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator;

public class RenderMeshBuilder {
    /** 输出 [x0,y0,z0, x1,y1,z1, x2,y2,z2, ...] 的扁平三角形数组 */
    public static float[] buildMesh(Geometry polygons) {
        Geometry tris = ConstrainedDelaunayTriangulator.triangulate(polygons);
        List<Float> data = new ArrayList<Float>();
        for (int i = 0; i < tris.getNumGeometries(); i++) {
            Polygon tri = (Polygon) tris.getGeometryN(i);
            Coordinate[] c = tri.getExteriorRing().getCoordinates();
            for (int j = 0; j < 3; j++) {
                data.add((float) c[j].x);
                data.add((float) c[j].y);
                data.add((float) c[j].getZ());
            }
        }
        float[] out = new float[data.size()];
        for (int i = 0; i < out.length; i++) out[i] = data.get(i);
        return out;
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder;

public class ParcelMeshDemo {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        WKTReader reader = new WKTReader();

        ConformingDelaunayTriangulationBuilder builder =
            new ConformingDelaunayTriangulationBuilder();
        builder.setSites(reader.read("MULTIPOINT ((0 0), (100 0), (100 60), (0 60), (50 30), (20 15))"));
        // 地块边界作为约束
        builder.setConstraints(reader.read(
            "LINESTRING (0 0, 100 0, 100 60, 0 60, 0 0)"));
        Geometry tris = builder.getTriangles(gf);
        System.out.println("三角形数=" + tris.getNumGeometries());
        System.out.println("面积和=" + tris.getArea());
    }
}