ロスレスポリゴンの単純化？

元の境界を縮小せずにポリゴンを単純化するための標準/推奨アルゴリズムはありますか？

現在、私はJTS内でTopologyPreservingSimpliferを使用しており、アプリケーションで後で「損失のある」ポリゴンに遭遇したときに問題が発生します。理想的には、凸包よりも小さいが、元のポリゴンのスーパーセットのままである簡略化されたポリゴンを作成したいです。

更新：

私は最終的に、入力ポリゴンの周りに「ラッパー」を配置し、余分な領域が入力の合計領域のパーセンテージを超えなくなるまで縮小する確かに不完全なアルゴリズムを思いつきました。直線に沿った冗長ポイント。100％データ依存ですが、余分な領域を最小限に抑えて約80％の頂点を圧縮しています。感謝/すべてのフィードバック/コメント：

public class LosslessPolygonSimplifier {
protected final static Logger logger = Logger.getLogger(LosslessPolygonSimplifier.class.getName());

public static Polygon simplify(Polygon input) {
    final double AREA_THRESHOLD = 0.005; // allow excesses up to half a percent of total original area
    final double LINE_THRESHOLD = 0.0001; // fine threshold to strip straight lines
    try {
        if (!input.isSimple()) {
            logger.warning("Attempting to simplify complex polygon!");
        }
        Polygon simple = simplifyInternal(input, AREA_THRESHOLD, LINE_THRESHOLD);
        return simple;
    }
    catch (Exception e) {
        logger.log(Level.WARNING, "Failed to simplify. Resorting to convex hull.\n " + input.toText(), e);
        try {
            // worst case scenario - fall back to convex hull
            // probably a result of a bow-tie LINESTRING that doubles back on itself due to precision loss?
            return (Polygon) input.convexHull();
        }
        catch (Exception e2) {
            // Is this even possible? Polygons that cross the anti-meridian?
            logger.log(Level.SEVERE, "Failed to simplify to convex hull: " + input.toText(), e2);
            return input; // Garbage In, Garbage Out
        }
    }
}

// TODO avoid creating triangles on long straight edges
public static Polygon simplifyInternal(Polygon original, double areaThreshold, double lineThreshold) {
    GeometryFactory gf = new GeometryFactory();
    Geometry excesses, excess, keepTotal, keepA, keepB, chA, chB, keep = null, elim = null;
    Polygon simplified = null, wrapper = (Polygon) original.convexHull();
    try {
        boolean done = false;
        while (!done) {
            done = true;
            excesses = wrapper.difference(original);
            for (int i = 0; i < excesses.getNumGeometries(); i++) {
                excess = excesses.getGeometryN(i);
                if (excess.getArea() / original.getArea() > areaThreshold) {
                    done = false; // excess too big - try to split then shrink
                    keepTotal = excess.intersection(original);
                    keepA = gf.createGeometryCollection(null);
                    keepB = gf.createGeometryCollection(null);
                    for (int j = 0; j < keepTotal.getNumGeometries(); j++) {
                        if (j < keepTotal.getNumGeometries() / 2) {
                            keepA = keepA.union(keepTotal.getGeometryN(j));
                        }
                        else {
                            keepB = keepB.union(keepTotal.getGeometryN(j));
                        }
                    }
                    chA = keepA.convexHull();
                    chB = keepB.convexHull();
                    keep = gf.createMultiPolygon(null);
                    if (chA instanceof Polygon) {
                        keep = keep.union(chA);
                    }
                    if (chB instanceof Polygon) {
                        keep = keep.union(chB);
                    }
                    elim = excess.difference(keep);
                    wrapper = (Polygon) wrapper.difference(elim);
                }
            }
        }
        new Assert(wrapper.getArea() >= original.getArea());
        new Assert(wrapper.getArea() <= original.convexHull().getArea());
        simplified = (Polygon) com.vividsolutions.jts.simplify.TopologyPreservingSimplifier.simplify(wrapper, lineThreshold);
        new Assert(simplified.getNumPoints() <= original.getNumPoints());
        new Assert(simplified.getNumInteriorRing() == 0);
        new Assert(simplified.isSimple());
        return simplified;
    }
    catch (Exception e) {
        if (original.isSimple()) {
            StringBuilder sb = new StringBuilder();
            sb.append("Failed to simplify non-complex polygon!");
            sb.append("\noriginal: " + original.toText());
            sb.append("\nwrapper: " + (null == wrapper ? "" : wrapper.toText()));
            sb.append("\nsimplified: " + (null == simplified ? "" : simplified.toText()));
            sb.append("\nkeep: " + (null == keep ? "" : keep.toText()));
            sb.append("\nelim: " + (null == elim ? "" : elim.toText()));
            logger.log(Level.SEVERE, sb.toString());
        }
        throw e;
    }
}

}

単純化した後、単純に元のポリゴンと結合できます。

TopologyPreservingSimpliferがDouglas-Peuckerアルゴリズムに基づいている場合、それはvividsolutions（JTSの作成者）で述べているように、通常はポリゴン領域を変更しません。ただし、各ポリゴンには、小さなゲインとロスのシーケンスが必要です（全体としてバランスを取ります）。

単一のポリゴンまたはポリゴンの小さなグループに焦点を合わせており、それらを拡大することは可能であるが、縮小しないことを許可する場合（それらの近隣を犠牲にして）、分析にバイアスを導入しています。

補遺

したがって、元の選択であるTopologyPreservingSimpliferが正しい解決策であると思います。

私のqgis​​プラグイン/ Pythonモジュールでは、「契約」（縮小のみ）または拡張のみでジオメトリを単純化できます。

https://github.com/albertferras/simplipy https://plugins.qgis.org/plugins/simplipy/