Geometry simplifier (#94859)

Support geometry and streaming simplification

There are many opportunities to enable geometry simplification in Elasticsearch, both as an explicit feature available to users, and as an internal optimization technique for reducing memory consumption for complex geometries. For the latter case, it can even be considered a bug fix. This PR provides support for constraining Line and LinearRing sizes to a fixed number of points, and thereby a fixed amount of memory usage.

Consider, for example, the geo_line aggregation. This is similar to the top-10 aggregation, but allows the top-10k (ten thousand) points to be aggregated. This is not only a lot of memory, but can still cause unwanted line truncation for very large geometries. Line simplification is a solution to this. It is likely that a much smaller limit than 10k would suffice, while at the same time not truncating the geometry at all, so we fix a bug (truncation) while improving memory usage (pull limit from 10k down to perhaps just 1k).

This PR provides two APIs:

Streaming:
* By using the simplifier.consume(x, y) method on a stream of points, the total memory used is limited to a linear function of k, the total number of points to retain. This algorithm is at its heart based on the Visvalingam–Whyatt algorithm, with concepts from https://bost.ocks.org/mike/simplify/ and in particular the detailed streaming discussions in the paper at https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.106.7132&rep=rep1&type=pdf

Full-geometry:
* Simplifying full geometries using the simplifier.simplify(geometry) method can work with most geometry types, even GeometryCollection, but:
  - Some geometries do not get simplified because it makes no sense to: Point, Circle, Rectangle
  - The maxPoints parameter is used as is to apply to the main component (shell for polygons, largest geometry for multi-polygons and geometry collections), and all other sub-components (holes in polygons, etc.) are simplified to a scaled down version of the maxPoints, scaled by the relative size of the sub-component to the main component.
* The simplification itself is done on each Line and LinearRing component using the same streaming algorithm above. Since we use the Visvalingam–Whyatt algorithm, this works is applicable to both streaming and full-geometry simplification with the same essential result, but better control over memory than normal full-geometry simplifiers.

The basic algorithm for simplification on a stream of points requires maintaining two data structures:
* an array of all currently simplified points (implicitly ordered in stream order)
* a priority queue of all but the two end points with an estimated error on each that expresses the cost of removing that point from the line

Author: craigtaverner

benchmarks/src/main/java/org/elasticsearch/benchmark/spatial/GeometrySimplificationBenchmark.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.benchmark.spatial;
+
+import org.elasticsearch.geometry.LinearRing;
+import org.elasticsearch.geometry.simplify.GeometrySimplifier;
+import org.elasticsearch.geometry.simplify.SimplificationErrorCalculator;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.text.ParseException;
+import java.util.concurrent.TimeUnit;
+import java.util.zip.GZIPInputStream;
+
+@Fork(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Thread)
+public class GeometrySimplificationBenchmark {
+    @Param({ "cartesiantrianglearea", "triangleArea", "triangleheight", "heightandbackpathdistance" })
+    public String calculatorName;
+
+    @Param({ "10", "100", "1000", "10000", "20000" })
+    public int maxPoints;
+
+    private GeometrySimplifier<LinearRing> simplifier;
+    private static LinearRing ring;
+
+    @Setup
+    public void setup() throws ParseException, IOException {
+        SimplificationErrorCalculator calculator = SimplificationErrorCalculator.byName(calculatorName);
+        this.simplifier = new GeometrySimplifier.LinearRingSimplifier(maxPoints, calculator);
+        if (ring == null) {
+            ring = loadRing("us.json.gz");
+        }
+    }
+
+    @Benchmark
+    public void simplify(Blackhole bh) {
+        bh.consume(simplifier.simplify(ring));
+    }
+
+    private static LinearRing loadRing(@SuppressWarnings("SameParameterValue") String name) throws IOException, ParseException {
+        String json = loadJsonFile(name);
+        org.apache.lucene.geo.Polygon[] lucenePolygons = org.apache.lucene.geo.Polygon.fromGeoJSON(json);
+        LinearRing ring = null;
+        for (org.apache.lucene.geo.Polygon lucenePolygon : lucenePolygons) {
+            double[] x = lucenePolygon.getPolyLons();
+            double[] y = lucenePolygon.getPolyLats();
+            if (ring == null || x.length > ring.length()) {
+                ring = new LinearRing(x, y);
+            }
+        }
+        return ring;
+    }
+
+    private static String loadJsonFile(String name) throws IOException {
+        InputStream is = GeometrySimplificationBenchmark.class.getResourceAsStream(name);
+        if (is == null) {
+            throw new FileNotFoundException("classpath resource not found: " + name);
+        }
+        if (name.endsWith(".gz")) {
+            is = new GZIPInputStream(is);
+        }
+        BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
+        StringBuilder builder = new StringBuilder();
+        reader.lines().forEach(builder::append);
+        return builder.toString();
+    }
+}

benchmarks/src/main/resources/org/elasticsearch/benchmark/spatial/us.json.gz

@@ -0,0 +1,5 @@
+pr: 94859
+summary: Geometry simplifier
+area: Geo
+type: feature
+issues: []

docs/changelog/94859.yaml

@@ -9,4 +9,5 @@
 module org.elasticsearch.geo {
     exports org.elasticsearch.geometry;
     exports org.elasticsearch.geometry.utils;
+    exports org.elasticsearch.geometry.simplify;
 }