Simplificação sem polígonos sem perdas?

Existe um algoritmo padrão / recomendado para simplificar um polígono sem reduzir nenhum de seus limites originais?

No momento, estou usando TopologyPreservingSimplifer no JTS e encontrando problemas mais tarde no meu aplicativo quando encontro polígonos "com perdas". Idealmente, eu gostaria de produzir polígonos simplificados que são menores que o casco convexo, mas permanecem um superconjunto do meu polígono original.

Atualizar:

Acabei criando um algoritmo reconhecidamente imperfeito que coloca um "invólucro" em torno do polígono de entrada, reduz-o até que nenhuma área em excesso exceda uma porcentagem da área total da entrada e, em seguida, executa um simplificador de linha com um limite muito mais fino para remover quaisquer pontos redundantes ao longo de linhas retas. 100% dependente de dados, mas estou vendo cerca de 80% de compactação de vértices com áreas mínimas em excesso. Todos os comentários / comentários apreciados:

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;
    }
}

}

Você pode simplesmente se unir ao polígono original após a simplificação.

Se o TopologyPreservingSimplifer for baseado no algoritmo Douglas-Peucker, como diz em vividsolutions (criadores do JTS), geralmente não mudará as áreas dos polígonos. Cada polígono deve , no entanto, ter seqüências resultantes de pequenos ganhos e perdas (equilibrando-se no geral).

Se você estiver focando em um único polígono ou em um pequeno grupo de polígonos, e permitir que eles expandam, mas não encolhem (às custas de seus vizinhos), você estará introduzindo um viés em sua análise.

termo aditivo

Portanto, acredito que sua escolha original, TopologyPreservingSimplifer, é a solução correta.

Meu módulo qgis plugin / python permite simplificar geometrias por "contrato" (somente encolhimento) ou somente expansão:

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