第05章 - 几何创建、编辑与仿射变换

// 1. 最常用：浮点精度、SRID=0、默认坐标序列工厂
GeometryFactory gf1 = new GeometryFactory();

// 2. 指定精度模型与 SRID
GeometryFactory gf2 = new GeometryFactory(new PrecisionModel(), 4326);

// 3. 指定固定精度（比例因子 1000，即小数点后 3 位）与 SRID
GeometryFactory gf3 = new GeometryFactory(new PrecisionModel(1000), 3857);

// 4. 指定坐标序列工厂（例如换成压缩存储）
GeometryFactory gf4 = new GeometryFactory(
        new PrecisionModel(), 4326,
        PackedCoordinateSequenceFactory.DOUBLE_FACTORY);

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.geom.PrecisionModel;

public class PrecisionTrap {
    public static void main(String[] args) {
        // 固定精度：比例因子 1000，即保留 3 位小数
        PrecisionModel pm = new PrecisionModel(1000);
        GeometryFactory gf = new GeometryFactory(pm, 0);

        Point p = gf.createPoint(new Coordinate(1.23456, 2.34567));
        System.out.println(p);            // POINT (1.23456 2.34567)，并没有被截断

        // 想真正落到精度网格上，必须显式调用 makePrecise
        Coordinate c = new Coordinate(1.23456, 2.34567);
        pm.makePrecise(c);
        System.out.println(c.x + ", " + c.y);   // 1.235, 2.346
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.LinearRing;
import org.locationtech.jts.geom.Polygon;

public class RingClosure {
    public static void main(String[] args) {
        GeometryFactory gf = new GeometryFactory();

        // 正确：首尾坐标相同
        Coordinate[] shellPts = new Coordinate[] {
            new Coordinate(0, 0), new Coordinate(0, 4),
            new Coordinate(4, 4), new Coordinate(4, 0),
            new Coordinate(0, 0)
        };
        LinearRing shell = gf.createLinearRing(shellPts);
        Polygon poly = gf.createPolygon(shell, null);
        System.out.println(poly.getArea());        // 16.0
        System.out.println(poly.getNumPoints());   // 5

        // 错误示范：忘记闭合会抛 IllegalArgumentException
        try {
            gf.createLinearRing(new Coordinate[] {
                new Coordinate(0, 0), new Coordinate(0, 4), new Coordinate(4, 4)
            });
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            // Points of LinearRing do not form a closed linestring
        }
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.CoordinateList;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Polygon;

public class CoordinateListDemo {
    public static void main(String[] args) {
        CoordinateList list = new CoordinateList();
        // 第二个参数 allowRepeated=false 表示跳过与上一个点重合的点
        list.add(new Coordinate(0, 0), false);
        list.add(new Coordinate(0, 0), false);   // 被忽略
        list.add(new Coordinate(0, 5), false);
        list.add(new Coordinate(5, 5), false);
        list.add(new Coordinate(5, 0), false);
        System.out.println(list.size());         // 4

        list.closeRing();                        // 末尾补上首点
        System.out.println(list.size());         // 5

        Coordinate[] pts = list.toCoordinateArray();
        GeometryFactory gf = new GeometryFactory();
        Polygon poly = gf.createPolygon(pts);
        System.out.println(poly.getArea());      // 25.0
    }
}

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.GeometryFactory;

public class BuildGeometryDemo {
    public static void main(String[] args) {
        GeometryFactory gf = new GeometryFactory();
        List<Geometry> parts = new ArrayList<Geometry>();
        parts.add(gf.createPolygon(new Coordinate[] {
            new Coordinate(0, 0), new Coordinate(0, 1),
            new Coordinate(1, 1), new Coordinate(1, 0), new Coordinate(0, 0)
        }));
        parts.add(gf.createPolygon(new Coordinate[] {
            new Coordinate(2, 2), new Coordinate(2, 3),
            new Coordinate(3, 3), new Coordinate(3, 2), new Coordinate(2, 2)
        }));
        Geometry built = gf.buildGeometry(parts);
        System.out.println(built.getGeometryType());   // MultiPolygon
        System.out.println(built.getNumGeometries());  // 2

        // 单个元素时不会被包装
        List<Geometry> one = new ArrayList<Geometry>();
        one.add(parts.get(0));
        System.out.println(gf.buildGeometry(one).getGeometryType());  // Polygon
    }
}

import org.locationtech.jts.geom.CoordinateSequence;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.PrecisionModel;
import org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory;

public class PackedDemo {
    public static void main(String[] args) {
        // 三个点、二维：(x0,y0, x1,y1, x2,y2)
        double[] flat = new double[] { 0, 0, 1, 2, 3, 3 };
        PackedCoordinateSequenceFactory csf = PackedCoordinateSequenceFactory.DOUBLE_FACTORY;
        CoordinateSequence seq = csf.create(flat, 2);

        GeometryFactory gf = new GeometryFactory(new PrecisionModel(), 0, csf);
        LineString line = gf.createLineString(seq);
        System.out.println(line);                             // LINESTRING (0 0, 1 2, 3 3)
        System.out.println(seq.getDimension());               // 2
        System.out.println(seq.getX(1) + " " + seq.getY(1));  // 1.0 2.0

        // 按下标读写，0=X 1=Y 2=Z 3=M
        seq.setOrdinate(0, 0, 10);
        System.out.println(line.getCoordinateN(0).x);         // 10.0，序列是共享的
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.PrecisionModel;
import org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory;
import org.locationtech.jts.io.WKTReader;

public class FactorySwitch {
    public static void main(String[] args) throws Exception {
        Geometry g = new WKTReader().read("LINESTRING (0 0, 10 0)");
        System.out.println(g.getSRID() + " / " + g.getFactory().getCoordinateSequenceFactory().getClass().getSimpleName());
        // 0 / CoordinateArraySequenceFactory

        GeometryFactory target = new GeometryFactory(
                new PrecisionModel(), 4326, PackedCoordinateSequenceFactory.DOUBLE_FACTORY);
        Geometry moved = target.createGeometry(g);

        System.out.println(moved.getSRID());                                  // 4326
        System.out.println(moved == g);                                       // false，深拷贝
        System.out.println(moved.getFactory().getCoordinateSequenceFactory().getClass().getSimpleName());
        // PackedCoordinateSequenceFactory
        System.out.println(moved.equalsExact(g));                             // true，坐标一致
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Polygon;

public class SridTrap {
    public static void main(String[] args) {
        GeometryFactory gf4326 = new GeometryFactory(new PrecisionModel(), 4326);
        GeometryFactory gf3857 = new GeometryFactory(new PrecisionModel(), 3857);

        Polygon a = gf4326.createPolygon(new Coordinate[] {
            new Coordinate(0, 0), new Coordinate(0, 1),
            new Coordinate(1, 1), new Coordinate(1, 0), new Coordinate(0, 0)
        });
        Polygon b = gf3857.createPolygon(new Coordinate[] {
            new Coordinate(2, 2), new Coordinate(2, 3),
            new Coordinate(3, 3), new Coordinate(3, 2), new Coordinate(2, 2)
        });
        org.locationtech.jts.geom.MultiPolygon mp = gf4326.createMultiPolygon(new Polygon[] { a, b });
        System.out.println(mp.getSRID());            // 4326
        System.out.println(mp.getGeometryN(1).getSRID());   // 3857，没有被统一
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.CoordinateList;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryEditor;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;

public class EditorDemo {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        Geometry g = new WKTReader(gf).read(
            "POLYGON ((0 0, 0 10, 10 10, 10 10, 10 0, 0 0))");   // 故意带一个重复点

        GeometryEditor editor = new GeometryEditor(gf);
        Geometry shifted = editor.edit(g, new GeometryEditor.CoordinateOperation() {
            public Coordinate[] edit(Coordinate[] coordinates, Geometry geometry) {
                CoordinateList list = new CoordinateList();
                for (Coordinate c : coordinates) {
                    Coordinate moved = new Coordinate(c.x + 100, c.y + 100, c.getZ());
                    list.add(moved, false);   // false：去掉重复点
                }
                return list.toCoordinateArray();
            }
        });

        System.out.println(shifted);
        // POLYGON ((100 100, 100 110, 110 110, 110 100, 100 100))
        System.out.println(shifted.getNumPoints());   // 5，重复点已被移除
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryEditor;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.io.WKTReader;

public class DropHoles {
    static class DropHolesOp extends GeometryEditor.CoordinateSequenceOperation {
        public org.locationtech.jts.geom.CoordinateSequence edit(
                org.locationtech.jts.geom.CoordinateSequence seq, Geometry geometry) {
            return seq;   // 坐标序列原样返回
        }
    }

    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        Geometry poly = new WKTReader(gf).read(
            "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))");

        GeometryEditor editor = new GeometryEditor(gf);
        editor.setCopyUserData(true);          // 默认不复制 UserData，需要时显式打开
        poly.setUserData("parcel-42");

        Geometry noHoles = editor.edit(poly, new GeometryEditor.GeometryEditorOperation() {
            public Geometry edit(Geometry g, GeometryFactory factory) {
                if (g instanceof Polygon && ((Polygon) g).getNumInteriorRing() > 0) {
                    Polygon p = (Polygon) g;
                    return factory.createPolygon(p.getExteriorRing().getCoordinateSequence());
                }
                return g;   // 其余组件原样保留
            }
        });

        System.out.println(noHoles);           // POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))
        System.out.println(noHoles.getUserData());   // parcel-42
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.CoordinateSequence;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.util.GeometryTransformer;
import org.locationtech.jts.geom.impl.CoordinateArraySequenceFactory;
import org.locationtech.jts.io.WKTReader;

public class DropZTransformer extends GeometryTransformer {
    private final GeometryFactory factory = new GeometryFactory();

    @Override
    protected CoordinateSequence transformCoordinates(CoordinateSequence coords, Geometry parent) {
        Coordinate[] pts = new Coordinate[coords.size()];
        for (int i = 0; i < coords.size(); i++) {
            pts[i] = new Coordinate(coords.getX(i), coords.getY(i));   // 只保留 XY
        }
        return CoordinateArraySequenceFactory.instance().create(pts);
    }

    @Override
    protected Geometry transformPolygon(org.locationtech.jts.geom.Polygon geom, Geometry parent) {
        Geometry result = super.transformPolygon(geom, parent);
        return result;   // 空面在父级组装时会被跳过
    }

    public static void main(String[] args) throws Exception {
        Geometry g = new WKTReader().read(
            "GEOMETRYCOLLECTION (POINT Z (1 2 3), LINESTRING Z (0 0 5, 1 1 6))");
        Geometry out = new DropZTransformer().transform(g);
        System.out.println(out);
        // GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (0 0, 1 1))
        System.out.println(out.getCoordinate().getZ());   // NaN
    }
}

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.GeometryFactory;
import org.locationtech.jts.geom.util.GeometryMapper;
import org.locationtech.jts.io.WKTReader;

public class MapperDemo {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        Geometry gc = new WKTReader(gf).read(
            "GEOMETRYCOLLECTION (POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0)), POINT (5 5))");

        // 对每个成员做缓冲
        Geometry buffered = GeometryMapper.map(gc, new GeometryMapper.MapOp() {
            public Geometry map(Geometry g) {
                return g.buffer(1);
            }
        });
        System.out.println(buffered.getGeometryType());   // GeometryCollection
        System.out.println(buffered.getNumGeometries());  // 2

        // 逐点平移并拍平
        Geometry moved = GeometryMapper.flatMap(gc, 0, new GeometryMapper.MapOp() {
            public Geometry map(Geometry g) {
                return g.copy();   // 占位：真实场景在这里做变换
            }
        });
        System.out.println(moved.getGeometryType());      // GeometryCollection
    }
}

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.GeometryFactory;
import org.locationtech.jts.geom.util.GeometryCombiner;

public class CombinerDemo {
    public static void main(String[] args) {
        GeometryFactory gf = new GeometryFactory();
        Geometry line = gf.createLineString(new Coordinate[] {
            new Coordinate(0, 0), new Coordinate(1, 1)
        });
        Geometry point = gf.createPoint(new Coordinate(2, 2));

        // 直接合并两个同维度/不同维度几何
        Geometry combined = GeometryCombiner.combine(line, point);
        System.out.println(combined.getGeometryType());   // GeometryCollection

        // 合并两个 MultiLineString，结果会被拍平成 MultiLineString
        List<Geometry> list = new ArrayList<Geometry>();
        list.add(line);
        list.add(line);
        System.out.println(GeometryCombiner.combine(list).getGeometryType());  // MultiLineString
    }
}

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.GeometryFactory;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.geom.util.GeometryExtracter;
import org.locationtech.jts.geom.util.LineStringExtracter;
import org.locationtech.jts.geom.util.PointExtracter;
import org.locationtech.jts.geom.util.PolygonExtracter;
import org.locationtech.jts.io.WKTReader;

public class ExtractDemo {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory();
        Geometry gc = new WKTReader(gf).read(
            "GEOMETRYCOLLECTION (POINT (1 1), LINESTRING (0 0, 2 2),"
            + " POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0)))");

        List<Point> pts = PointExtracter.getPoints(gc);
        List<LineString> lines = LineStringExtracter.getLines(gc);
        List<Polygon> polys = PolygonExtracter.getPolygons(gc);

        System.out.println(pts.size() + " / " + lines.size() + " / " + polys.size());  // 1 / 1 / 1

        // 把线合并成一条 MultiLineString（若只有一条则返回该条）
        Geometry lineGeom = LineStringExtracter.getGeometry(gc);
        System.out.println(lineGeom.getGeometryType());   // LineString

        // 按类名提取
        List<Geometry> onlyPoly = GeometryExtracter.extract(gc, "Polygon");
        System.out.println(onlyPoly.size());              // 1
    }
}

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

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

        // 逆时针的外环
        Geometry a = reader.read("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))");
        Geometry b = a.copy();
        b.normalize();
        System.out.println(a);   // POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))
        System.out.println(b);   // POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))
        System.out.println(a.equalsExact(b));   // false，顶点顺序不同

        // 规范之后拓扑相等判断不受顺序影响
        System.out.println(a.equalsTopo(b));    // true
        System.out.println(a.norm().equalsExact(b.norm()));   // true

        // 线的反向
        Geometry line = reader.read("LINESTRING (5 5, 1 1)");
        System.out.println(line.reverse());     // LINESTRING (1 1, 5 5)
        System.out.println(line);               // LINESTRING (5 5, 1 1)，原对象不变
    }
}

import org.locationtech.jts.algorithm.Orientation;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.LinearRing;

public class OrientationDemo {
    public static void main(String[] args) {
        GeometryFactory gf = new GeometryFactory();
        LinearRing ccw = gf.createLinearRing(new Coordinate[] {
            new Coordinate(0, 0), new Coordinate(10, 0),
            new Coordinate(10, 10), new Coordinate(0, 10), new Coordinate(0, 0)
        });
        System.out.println(Orientation.isCCW(ccw.getCoordinateSequence()));  // true
        System.out.println(ccw.isCCW());   // true，环上的便捷方法

        LinearRing cw = (LinearRing) ccw.reverse();
        System.out.println(cw.isCCW());    // false
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.util.AffineTransformation;
import org.locationtech.jts.io.WKTReader;

public class AffineBasic {
    public static void main(String[] args) throws Exception {
        Geometry line = new WKTReader().read("LINESTRING (0 0, 10 0)");

        System.out.println(AffineTransformation.translationInstance(5, 3).transform(line));
        // LINESTRING (5 3, 15 3)

        System.out.println(AffineTransformation.scaleInstance(2, 2).transform(line));
        // LINESTRING (0 0, 20 0)

        // 绕原点逆时针 90 度：x' = -y, y' = x
        System.out.println(AffineTransformation.rotationInstance(Math.PI / 2).transform(line));
        // LINESTRING (0 0, 0 10)

        // 用 sin/cos 精确表达 90 度，避免 Math.PI/2 的舍入误差
        AffineTransformation rot90 = AffineTransformation.rotationInstance(1.0, 0.0);
        System.out.println(rot90.transform(line));   // LINESTRING (0 0, 0 10)

        // 绕点 (10, 0) 旋转 90 度
        System.out.println(AffineTransformation.rotationInstance(Math.PI / 2, 10, 0).transform(line));
        // LINESTRING (10 0, 10 10)

        // 沿 X 轴反射：y 取反
        System.out.println(AffineTransformation.reflectionInstance(0, 0, 1, 0).transform(line));
        // LINESTRING (0 0, 10 0)

        // 错切：y 不变，x 随 y 线性偏移
        System.out.println(AffineTransformation.shearInstance(0.5, 0).transform(line));
        // LINESTRING (0 0, 10 0)
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.util.AffineTransformation;
import org.locationtech.jts.io.WKTReader;

public class ComposeOrder {
    public static void main(String[] args) throws Exception {
        Coordinate origin = new Coordinate(0, 0);

        // 先平移 (10,0)，再旋转 90 度
        AffineTransformation t1 = AffineTransformation.translationInstance(10, 0);
        t1.rotate(Math.PI / 2);
        System.out.println(t1.transform(origin, new Coordinate()));   // (0, 10)

        // 先旋转，再平移
        AffineTransformation t2 = AffineTransformation.rotationInstance(Math.PI / 2);
        t2.translate(10, 0);
        System.out.println(t2.transform(origin, new Coordinate()));   // (10, 0)

        // compose 与 composeBefore 的等价写法
        AffineTransformation a = AffineTransformation.translationInstance(10, 0);
        AffineTransformation b = AffineTransformation.rotationInstance(Math.PI / 2);
        System.out.println(a.copy().compose(b).transform(origin, new Coordinate()));       // (0, 10)
        System.out.println(a.copy().composeBefore(b).transform(origin, new Coordinate())); // (10, 0)

        // 对几何做整体旋转，验证只改 X/Y
        Geometry line = new WKTReader().read("LINESTRING (0 0, 4 0)");
        AffineTransformation rot = AffineTransformation.rotationInstance(Math.PI / 4);
        System.out.println(rot.transform(line));
        // LINESTRING (0 0, 2.8284271247461903 2.8284271247461903)
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.util.AffineTransformation;
import org.locationtech.jts.geom.util.NoninvertibleTransformationException;

public class InverseDemo {
    public static void main(String[] args) {
        AffineTransformation t = AffineTransformation.translationInstance(10, 20)
                .scale(2, 3);   // 先平移再缩放：x' = 2*(x+10), y' = 3*(y+20)
        System.out.println(t.getDeterminant());   // 6.0

        AffineTransformation inv = t.getInverse();
        Coordinate p = new Coordinate(4, 7);
        Coordinate q = t.transform(p, new Coordinate());
        Coordinate back = inv.transform(q, new Coordinate());
        System.out.println(q);      // (28.0, 81.0)
        System.out.println(back);   // (4.0, 7.0)，回到原位

        try {
            AffineTransformation.scaleInstance(0, 1).getInverse();
        } catch (NoninvertibleTransformationException e) {
            System.out.println(e.getMessage());   // Transformation is non-invertible
        }
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.util.AffineTransformation;
import org.locationtech.jts.geom.util.AffineTransformationFactory;
import org.locationtech.jts.io.WKTReader;

public class ControlPointFit {
    public static void main(String[] args) throws Exception {
        // 三个控制点：把单位正方形映射成一个平行四边形（含错切）
        Coordinate s0 = new Coordinate(0, 0);
        Coordinate s1 = new Coordinate(1, 0);
        Coordinate s2 = new Coordinate(0, 1);
        Coordinate d0 = new Coordinate(10, 10);
        Coordinate d1 = new Coordinate(12, 10);
        Coordinate d2 = new Coordinate(11, 13);

        AffineTransformation fit = AffineTransformationFactory
                .createFromControlVectors(s0, s1, s2, d0, d1, d2);
        Geometry square = new WKTReader().read(
                "POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))");
        System.out.println(fit.transform(square));
        // POLYGON ((10 10, 12 10, 13 13, 11 13, 10 10))

        // 两控制点：平移 + 旋转 + 等比缩放
        AffineTransformation twoPt = AffineTransformationFactory.createFromControlVectors(
                new Coordinate(0, 0), new Coordinate(1, 0),
                new Coordinate(0, 0), new Coordinate(0, 2));
        System.out.println(twoPt.transform(new Coordinate(1, 0)));
        // (0.0, 2.0)

        // 退化输入返回 null
        System.out.println(AffineTransformationFactory.createFromControlVectors(
                new Coordinate(5, 5), new Coordinate(5, 5),
                new Coordinate(0, 0), new Coordinate(1, 1)));   // null
    }
}

Geometry g2 = g.copy();
g2.apply(this);
return g2;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.PrecisionModel;
import org.locationtech.jts.geom.util.AffineTransformation;
import org.locationtech.jts.geom.util.GeometryFixer;
import org.locationtech.jts.io.WKTReader;

public class AffineFixDemo {
    public static void main(String[] args) throws Exception {
        GeometryFactory gf = new GeometryFactory(new PrecisionModel(1000), 0);
        WKTReader reader = new WKTReader(gf);

        // 一个带微小自相交的三角形（顶点几乎共线）
        Geometry g = reader.read("POLYGON ((0 0, 10 0.0001, 10 0, 0 0.0001, 0 0))");
        System.out.println(g.isValid());   // false

        // 旋转 45 度后按毫米网格吸附
        Geometry rotated = AffineTransformation.rotationInstance(Math.PI / 4).transform(g);
        PrecisionModel pm = new PrecisionModel(1000);
        Coordinate[] cs = rotated.getCoordinates();
        for (Coordinate c : cs) {
            pm.makePrecise(c);            // 逐点吸附（注意：这不会自动重建几何）
        }
        System.out.println(rotated.getCoordinates()[1]);

        // 真正修复要重建几何
        Geometry fixed = GeometryFixer.fix(rotated);
        System.out.println(fixed.isValid());          // true
        System.out.println(fixed.getGeometryType());  // Polygon 或 MultiPolygon
    }
}