Geo: replace intermediate geo objects with libs/geo

build.gradle

@@ -212,6 +212,7 @@ allprojects {
     "org.elasticsearch:elasticsearch-core:${version}": ':libs:core',
     "org.elasticsearch:elasticsearch-nio:${version}": ':libs:nio',
     "org.elasticsearch:elasticsearch-x-content:${version}": ':libs:x-content',
+    "org.elasticsearch:elasticsearch-geo:${version}": ':libs:elasticsearch-geo',
     "org.elasticsearch:elasticsearch-secure-sm:${version}": ':libs:secure-sm',
     "org.elasticsearch.client:elasticsearch-rest-client:${version}": ':client:rest',
     "org.elasticsearch.client:elasticsearch-rest-client-sniffer:${version}": ':client:sniffer',

libs/geo/src/main/java/org/elasticsearch/geo/geometry/Line.java

@@ -67,6 +67,14 @@ public double getLon(int i) {
         return lons[i];
     }
 
+    public double[] getLats() {
+        return lats.clone();
+    }
+
+    public double[] getLons() {
+        return lons.clone();
+    }
+
     @Override
     public ShapeType type() {
         return ShapeType.LINESTRING;

libs/geo/src/main/java/org/elasticsearch/geo/geometry/Point.java

@@ -48,11 +48,11 @@ public ShapeType type() {
         return ShapeType.POINT;
     }
 
-    public double lat() {
+    public double getLat() {
         return lat;
     }
 
-    public double lon() {
+    public double getLon() {
         return lon;
     }
 

libs/geo/src/main/java/org/elasticsearch/geo/utils/WellKnownText.java

@@ -123,12 +123,12 @@ public Void visit(MultiLine multiLine) {
                 public Void visit(MultiPoint multiPoint) {
                     // walk through coordinates:
                     sb.append(LPAREN);
-                    visitPoint(multiPoint.get(0).lon(), multiPoint.get(0).lat());
+                    visitPoint(multiPoint.get(0).getLon(), multiPoint.get(0).getLat());
                     for (int i = 1; i < multiPoint.size(); ++i) {
                         sb.append(COMMA);
                         sb.append(SPACE);
                         Point point = multiPoint.get(i);
-                        visitPoint(point.lon(), point.lat());
+                        visitPoint(point.getLon(), point.getLat());
                     }
                     sb.append(RPAREN);
                     return null;
@@ -146,7 +146,7 @@ public Void visit(Point point) {
                         sb.append(EMPTY);
                     } else {
                         sb.append(LPAREN);
-                        visitPoint(point.lon(), point.lat());
+                        visitPoint(point.getLon(), point.getLat());
                         sb.append(RPAREN);
                     }
                     return null;

server/build.gradle

@@ -77,7 +77,8 @@ dependencies {
   compile "org.elasticsearch:elasticsearch-core:${version}"
   compile "org.elasticsearch:elasticsearch-secure-sm:${version}"
   compile "org.elasticsearch:elasticsearch-x-content:${version}"
-
+  compile "org.elasticsearch:elasticsearch-geo:${version}"
+
   compileOnly project(':libs:plugin-classloader')
   testRuntime project(':libs:plugin-classloader')
 

server/src/main/java/org/elasticsearch/common/geo/GeoShapeType.java

@@ -258,7 +258,7 @@ CoordinateNode validate(CoordinateNode coordinates, boolean coerce) {
     },
     GEOMETRYCOLLECTION("geometrycollection") {
         @Override
-        public ShapeBuilder<?, ?> getBuilder(CoordinateNode coordinates, DistanceUnit.Distance radius,
+        public ShapeBuilder<?, ?, ?> getBuilder(CoordinateNode coordinates, DistanceUnit.Distance radius,
                                        Orientation orientation, boolean coerce) {
             // noop, handled in parser
             return null;
@@ -298,7 +298,7 @@ public static GeoShapeType forName(String geoshapename) {
         throw new IllegalArgumentException("unknown geo_shape ["+geoshapename+"]");
     }
 
-    public abstract ShapeBuilder<?, ?> getBuilder(CoordinateNode coordinates, DistanceUnit.Distance radius,
+    public abstract ShapeBuilder<?, ?, ?> getBuilder(CoordinateNode coordinates, DistanceUnit.Distance radius,
                                             ShapeBuilder.Orientation orientation, boolean coerce);
     abstract CoordinateNode validate(CoordinateNode coordinates, boolean coerce);
 

server/src/main/java/org/elasticsearch/common/geo/builders/CircleBuilder.java

@@ -34,7 +34,7 @@
 import java.io.IOException;
 import java.util.Objects;
 
-public class CircleBuilder extends ShapeBuilder<Circle, CircleBuilder> {
+public class CircleBuilder extends ShapeBuilder<Circle, org.elasticsearch.geo.geometry.Circle, CircleBuilder> {
 
     public static final ParseField FIELD_RADIUS = new ParseField("radius");
     public static final GeoShapeType TYPE = GeoShapeType.CIRCLE;
@@ -164,7 +164,7 @@ public Circle buildS4J() {
     }
 
     @Override
-    public Object buildLucene() {
+    public org.elasticsearch.geo.geometry.Circle buildGeometry() {
         throw new UnsupportedOperationException("CIRCLE geometry is not supported");
     }
 

server/src/main/java/org/elasticsearch/common/geo/builders/EnvelopeBuilder.java

@@ -32,7 +32,7 @@
 import java.io.IOException;
 import java.util.Objects;
 
-public class EnvelopeBuilder extends ShapeBuilder<Rectangle, EnvelopeBuilder> {
+public class EnvelopeBuilder extends ShapeBuilder<Rectangle, org.elasticsearch.geo.geometry.Rectangle, EnvelopeBuilder> {
 
     public static final GeoShapeType TYPE = GeoShapeType.ENVELOPE;
 
@@ -113,8 +113,8 @@ public Rectangle buildS4J() {
     }
 
     @Override
-    public org.apache.lucene.geo.Rectangle buildLucene() {
-        return new org.apache.lucene.geo.Rectangle(bottomRight.y, topLeft.y, topLeft.x, bottomRight.x);
+    public org.elasticsearch.geo.geometry.Rectangle buildGeometry() {
+        return new org.elasticsearch.geo.geometry.Rectangle(bottomRight.y, topLeft.y, topLeft.x, bottomRight.x);
     }
 
     @Override

server/src/main/java/org/elasticsearch/common/geo/builders/GeometryCollectionBuilder.java

@@ -31,11 +31,11 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
-public class GeometryCollectionBuilder extends ShapeBuilder<Shape, GeometryCollectionBuilder> {
+public class GeometryCollectionBuilder extends ShapeBuilder<Shape,
+    org.elasticsearch.geo.geometry.GeometryCollection<org.elasticsearch.geo.geometry.Geometry>, GeometryCollectionBuilder> {
 
     public static final GeoShapeType TYPE = GeoShapeType.GEOMETRYCOLLECTION;
 
@@ -185,19 +185,14 @@ public Shape buildS4J() {
     }
 
     @Override
-    public Object buildLucene() {
-        List<Object> shapes = new ArrayList<>(this.shapes.size());
+    public org.elasticsearch.geo.geometry.GeometryCollection<org.elasticsearch.geo.geometry.Geometry> buildGeometry() {
+        List<org.elasticsearch.geo.geometry.Geometry> shapes = new ArrayList<>(this.shapes.size());
 
         for (ShapeBuilder shape : this.shapes) {
-            Object o = shape.buildLucene();
-            if (o.getClass().isArray()) {
-                shapes.addAll(Arrays.asList((Object[])o));
-            } else {
-                shapes.add(o);
-            }
+            shapes.add(shape.buildGeometry());
         }
 
-        return shapes.toArray(new Object[shapes.size()]);
+        return new org.elasticsearch.geo.geometry.GeometryCollection<>(shapes);
     }
 
     @Override

server/src/main/java/org/elasticsearch/common/geo/builders/LineStringBuilder.java

@@ -19,16 +19,16 @@
 
 package org.elasticsearch.common.geo.builders;
 
-import org.apache.lucene.geo.Line;
-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.elasticsearch.common.geo.GeoShapeType;
 import org.elasticsearch.common.geo.parsers.ShapeParser;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.geo.geometry.Line;
+import org.elasticsearch.geo.geometry.MultiLine;
+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.spatial4j.shape.jts.JtsGeometry;
 
 import java.io.IOException;
@@ -39,7 +39,7 @@
 import static org.elasticsearch.common.geo.GeoUtils.normalizeLat;
 import static org.elasticsearch.common.geo.GeoUtils.normalizeLon;
 
-public class LineStringBuilder extends ShapeBuilder<JtsGeometry, LineStringBuilder> {
+public class LineStringBuilder extends ShapeBuilder<JtsGeometry, org.elasticsearch.geo.geometry.Geometry, LineStringBuilder> {
     public static final GeoShapeType TYPE = GeoShapeType.LINESTRING;
 
     /**
@@ -125,15 +125,15 @@ public JtsGeometry buildS4J() {
     }
 
     @Override
-    public Object buildLucene() {
+    public org.elasticsearch.geo.geometry.Geometry buildGeometry() {
         // decompose linestrings crossing dateline into array of Lines
         Coordinate[] coordinates = this.coordinates.toArray(new Coordinate[this.coordinates.size()]);
         if (wrapdateline) {
-            ArrayList<Line> linestrings = decomposeLucene(coordinates, new ArrayList<>());
+            List<Line> linestrings = decomposeGeometry(coordinates, new ArrayList<>());
             if (linestrings.size() == 1) {
                 return linestrings.get(0);
             } else {
-                return linestrings.toArray(new Line[linestrings.size()]);
+                return new MultiLine(linestrings);
             }
         }
         return new Line(Arrays.stream(coordinates).mapToDouble(i->normalizeLat(i.y)).toArray(),
@@ -149,7 +149,7 @@ static ArrayList<LineString> decomposeS4J(GeometryFactory factory, Coordinate[]
         return strings;
     }
 
-    static ArrayList<Line> decomposeLucene(Coordinate[] coordinates, ArrayList<Line> lines) {
+    static List<Line> decomposeGeometry(Coordinate[] coordinates, List<Line> lines) {
         for (Coordinate[] part : decompose(+DATELINE, coordinates)) {
             for (Coordinate[] line : decompose(-DATELINE, part)) {
                 lines.add(new Line(Arrays.stream(line).mapToDouble(i->normalizeLat(i.y)).toArray(),

server/src/main/java/org/elasticsearch/common/geo/builders/MultiLineStringBuilder.java

@@ -19,25 +19,25 @@
 
 package org.elasticsearch.common.geo.builders;
 
-import org.apache.lucene.geo.Line;
 import org.elasticsearch.common.geo.GeoShapeType;
 import org.elasticsearch.common.geo.parsers.GeoWKTParser;
 import org.elasticsearch.common.geo.parsers.ShapeParser;
-import org.locationtech.jts.geom.Coordinate;
-import org.locationtech.jts.geom.Geometry;
-import org.locationtech.jts.geom.LineString;
-
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.geo.geometry.MultiLine;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.LineString;
 import org.locationtech.spatial4j.shape.jts.JtsGeometry;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Objects;
 
-public class MultiLineStringBuilder extends ShapeBuilder<JtsGeometry, MultiLineStringBuilder> {
+public class MultiLineStringBuilder extends ShapeBuilder<JtsGeometry, org.elasticsearch.geo.geometry.Geometry, MultiLineStringBuilder> {
 
     public static final GeoShapeType TYPE = GeoShapeType.MULTILINESTRING;
 
@@ -150,24 +150,24 @@ public JtsGeometry buildS4J() {
     }
 
     @Override
-    public Object buildLucene() {
+    public org.elasticsearch.geo.geometry.Geometry buildGeometry() {
         if (wrapdateline) {
-            ArrayList<Line> parts = new ArrayList<>();
+            List<org.elasticsearch.geo.geometry.Line> parts = new ArrayList<>();
             for (LineStringBuilder line : lines) {
-                LineStringBuilder.decomposeLucene(line.coordinates(false), parts);
+                LineStringBuilder.decomposeGeometry(line.coordinates(false), parts);
             }
             if (parts.size() == 1) {
                 return parts.get(0);
             }
-            return parts.toArray(new Line[parts.size()]);
+            return new MultiLine(parts);
         }
-        Line[] linestrings = new Line[lines.size()];
+        List<org.elasticsearch.geo.geometry.Line> linestrings = new ArrayList<>(lines.size());
         for (int i = 0; i < lines.size(); ++i) {
             LineStringBuilder lsb = lines.get(i);
-            linestrings[i] = new Line(lsb.coordinates.stream().mapToDouble(c->c.y).toArray(),
-                lsb.coordinates.stream().mapToDouble(c->c.x).toArray());
+            linestrings.add(new org.elasticsearch.geo.geometry.Line(lsb.coordinates.stream().mapToDouble(c->c.y).toArray(),
+                lsb.coordinates.stream().mapToDouble(c->c.x).toArray()));
         }
-        return linestrings;
+        return new MultiLine(linestrings);
     }
 
     @Override

server/src/main/java/org/elasticsearch/common/geo/builders/MultiPointBuilder.java

@@ -24,14 +24,16 @@
 import org.elasticsearch.common.geo.parsers.ShapeParser;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.geo.geometry.MultiPoint;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.spatial4j.shape.Point;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
-public class MultiPointBuilder extends ShapeBuilder<XShapeCollection<Point>, MultiPointBuilder> {
+public class MultiPointBuilder extends ShapeBuilder<XShapeCollection<Point>, MultiPoint, MultiPointBuilder> {
 
     public static final GeoShapeType TYPE = GeoShapeType.MULTIPOINT;
 
@@ -74,14 +76,9 @@ public XShapeCollection<Point> buildS4J() {
     }
 
     @Override
-    public double[][] buildLucene() {
-        double[][] points = new double[coordinates.size()][];
-        Coordinate coord;
-        for (int i = 0; i < coordinates.size(); ++i) {
-            coord = coordinates.get(i);
-            points[i] = new double[] {coord.x, coord.y};
-        }
-        return points;
+    public MultiPoint buildGeometry() {
+        return new MultiPoint(coordinates.stream().map(coord -> new org.elasticsearch.geo.geometry.Point(coord.y, coord.x))
+            .collect(Collectors.toList()));
     }
 
     @Override

server/src/main/java/org/elasticsearch/common/geo/builders/MultiPolygonBuilder.java

@@ -26,17 +26,17 @@
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.geo.geometry.MultiPolygon;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.spatial4j.shape.Shape;
 
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 
-public class MultiPolygonBuilder extends ShapeBuilder<Shape, MultiPolygonBuilder> {
+public class MultiPolygonBuilder extends ShapeBuilder<Shape, MultiPolygon, MultiPolygonBuilder> {
 
     public static final GeoShapeType TYPE = GeoShapeType.MULTIPOLYGON;
 
@@ -185,31 +185,20 @@ public Shape buildS4J() {
         //note: ShapeCollection is probably faster than a Multi* geom.
     }
 
+    @SuppressWarnings({"unchecked"})
     @Override
-    public Object buildLucene() {
-        List<org.apache.lucene.geo.Polygon> shapes = new ArrayList<>(this.polygons.size());
+    public MultiPolygon buildGeometry() {
+        List<org.elasticsearch.geo.geometry.Polygon> shapes = new ArrayList<>(this.polygons.size());
         Object poly;
-        if (wrapdateline) {
-            for (PolygonBuilder polygon : this.polygons) {
-                poly = polygon.buildLucene();
-                if (poly instanceof org.apache.lucene.geo.Polygon[]) {
-                    shapes.addAll(Arrays.asList((org.apache.lucene.geo.Polygon[])poly));
-                } else {
-                    shapes.add((org.apache.lucene.geo.Polygon)poly);
-                }
-            }
-        } else {
-            for (int i = 0; i < this.polygons.size(); ++i) {
-                PolygonBuilder pb = this.polygons.get(i);
-                poly = pb.buildLucene();
-                if (poly instanceof org.apache.lucene.geo.Polygon[]) {
-                    shapes.addAll(Arrays.asList((org.apache.lucene.geo.Polygon[])poly));
-                } else {
-                    shapes.add((org.apache.lucene.geo.Polygon)poly);
-                }
+        for (PolygonBuilder polygon : this.polygons) {
+            poly = polygon.buildGeometry();
+            if (poly instanceof List) {
+                shapes.addAll((List<org.elasticsearch.geo.geometry.Polygon>) poly);
+            } else {
+                shapes.add((org.elasticsearch.geo.geometry.Polygon)poly);
             }
         }
-        return shapes.stream().toArray(org.apache.lucene.geo.Polygon[]::new);
+        return new MultiPolygon(shapes);
     }
 
     @Override