Add ST_Contains etc.

Author: julianhyde

core/src/main/java/org/apache/calcite/runtime/GeoFunctions.java

@@ -22,11 +22,18 @@
 import org.apache.calcite.linq4j.function.Strict;
 import org.apache.calcite.util.Util;
 
+import com.esri.core.geometry.Envelope;
 import com.esri.core.geometry.Geometry;
 import com.esri.core.geometry.GeometryEngine;
+import com.esri.core.geometry.Line;
 import com.esri.core.geometry.MapGeometry;
+import com.esri.core.geometry.Operator;
+import com.esri.core.geometry.OperatorBoundary;
+import com.esri.core.geometry.OperatorFactoryLocal;
+import com.esri.core.geometry.OperatorIntersects;
 import com.esri.core.geometry.Point;
 import com.esri.core.geometry.Polygon;
+import com.esri.core.geometry.Polyline;
 import com.esri.core.geometry.SpatialReference;
 import com.esri.core.geometry.WktExportFlags;
 import com.esri.core.geometry.WktImportFlags;
@@ -46,8 +53,13 @@
  *   <li>Should we create aliases for functions in upper-case?
  *   Without ST_ prefix?
  *   <li>Consider adding spatial literals, e.g. `GEOMETRY 'POINT (30 10)'`
- *   <li>Integer arugments, e.g. SELECT ST_MakePoint(1, 2, 1.5)
+ *   <li>Integer arguments, e.g. SELECT ST_MakePoint(1, 2, 1.5),
+ *     ST_MakePoint(1, 2)
  *   <li>Are GEOMETRY values comparable? If so add ORDER BY test
+ *   <li>We have to add 'Z' to create 3D objects. This is inconsistent with
+ *   PostGIS. Who is right? At least document the difference.
+ *   <li>Should add GeometryEngine.intersects; similar to disjoint etc.
+ *   <li>Make {@link #ST_MakeLine(Geom, Geom)} varargs</li>
  * </ul>
  */
 @SuppressWarnings({"UnnecessaryUnboxing", "WeakerAccess", "unused"})
@@ -168,27 +180,76 @@ public static Geom ST_MPolyFromText(String wkt, int srid) {
 
   // Geometry creation functions ==============================================
 
-  /**  Constructs a 2D point from coordinates. */
-  public static Geom ST_MakePoint(BigDecimal x, BigDecimal y) {
-    // NOTE: Combine the double and BigDecimal variants of this function
-    if (x == null || y == null) {
-      return null; // TODO: strictness should make this check unnecessary
-    }
-    return ST_MakePoint(x.doubleValue(), y.doubleValue());
+  /**  Creates a line-string from the given POINTs (or MULTIPOINTs). */
+  public static Geom ST_MakeLine(Geom geom1, Geom geom2) {
+    return makeLine(geom1, geom2);
   }
 
-  private static Geom ST_MakePoint(double x, double y) {
-    final Geometry g = new Point(x, y);
+  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3) {
+    return makeLine(geom1, geom2, geom3);
+  }
+
+  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3,
+      Geom geom4) {
+    return makeLine(geom1, geom2, geom3, geom4);
+  }
+
+  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3,
+      Geom geom4, Geom geom5) {
+    return makeLine(geom1, geom2, geom3, geom4, geom5);
+  }
+
+  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3,
+      Geom geom4, Geom geom5, Geom geom6) {
+    return makeLine(geom1, geom2, geom3, geom4, geom5, geom6);
+  }
+
+  private static Geom makeLine(Geom... geoms) {
+    final Polyline g = new Polyline();
+    Point p = null;
+    for (Geom geom : geoms) {
+      if (geom.g() instanceof Point) {
+        final Point prev = p;
+        p = (Point) geom.g();
+        if (prev != null) {
+          final Line line = new Line();
+          line.setStart(prev);
+          line.setEnd(p);
+          g.addSegment(line, false);
+        }
+      }
+    }
     return new SimpleGeom(g);
   }
 
-  /**  Constructs a 3D point from coordinates. */
+  /**  Alias for {@link #ST_Point(BigDecimal, BigDecimal)}. */
+  public static Geom ST_MakePoint(BigDecimal x, BigDecimal y) {
+    return ST_Point(x, y);
+  }
+
+  /**  Alias for {@link #ST_Point(BigDecimal, BigDecimal, BigDecimal)}. */
   public static Geom ST_MakePoint(BigDecimal x, BigDecimal y, BigDecimal z) {
+    return ST_Point(x, y, z);
+  }
+
+  /**  Constructs a 2D point from coordinates. */
+  public static Geom ST_Point(BigDecimal x, BigDecimal y) {
+    // NOTE: Combine the double and BigDecimal variants of this function
+    return point(x.doubleValue(), y.doubleValue());
+  }
+
+  /**  Constructs a 3D point from coordinates. */
+  public static Geom ST_Point(BigDecimal x, BigDecimal y, BigDecimal z) {
     final Geometry g = new Point(x.doubleValue(), y.doubleValue(),
         z.doubleValue());
     return new SimpleGeom(g);
   }
 
+  private static Geom point(double x, double y) {
+    final Geometry g = new Point(x, y);
+    return new SimpleGeom(g);
+  }
+
   // Geometry properties (2D and 3D) ==========================================
 
   /** Returns whether {@code geom} has at least one z-coordinate. */
@@ -202,13 +263,141 @@ public static Double ST_Z(Geom geom) {
         ? ((Point) geom.g()).getZ() : null;
   }
 
+  /** Returns the boundary of {@code geom}. */
+  public static Geom ST_Boundary(Geom geom) {
+    OperatorBoundary op = OperatorBoundary.local();
+    Geometry result = op.execute(geom.g(), null);
+    return geom.wrap(result);
+  }
+
   /** Returns the distance between {@code geom1} and {@code geom2}. */
   public static double ST_Distance(Geom geom1, Geom geom2) {
     return GeometryEngine.distance(geom1.g(), geom2.g(), geom1.sr());
   }
 
+  /** Returns the type of {@code geom}. */
+  public static String ST_GeometryType(Geom geom) {
+    return type(geom.g()).name();
+  }
+
+  /** Returns the OGC SFS type code of {@code geom}. */
+  public static int ST_GeometryTypeCode(Geom geom) {
+    return type(geom.g()).code;
+  }
+
+  /** Returns the OGC type of a geometry. */
+  private static Type type(Geometry g) {
+    switch (g.getType()) {
+    case Point:
+      return Type.POINT;
+    case Polyline:
+      return Type.LINESTRING;
+    case Polygon:
+      return Type.POLYGON;
+    case MultiPoint:
+      return Type.MULTIPOINT;
+    case Envelope:
+      return Type.POLYGON;
+    case Line:
+      return Type.LINESTRING;
+    case Unknown:
+      return Type.Geometry;
+    default:
+      throw new AssertionError(g);
+    }
+  }
+
+  /** Returns the minimum bounding box of {@code geom} (which may be a
+   *  GEOMETRYCOLLECTION). */
+  public static Geom ST_Envelope(Geom geom) {
+    final Envelope env = envelope(geom.g());
+    return geom.wrap(env);
+  }
+
+  private static Envelope envelope(Geometry g) {
+    final Envelope env = new Envelope();
+    g.queryEnvelope(env);
+    return env;
+  }
+
   // Geometry predicates ======================================================
 
+  /** Returns whether {@code geom1} contains {@code geom2}. */
+  public static boolean ST_Contains(Geom geom1, Geom geom2) {
+    return GeometryEngine.contains(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether {@code geom1} contains {@code geom2} but does not
+   * intersect its boundary. */
+  public static boolean ST_ContainsProperly(Geom geom1, Geom geom2) {
+    return GeometryEngine.contains(geom1.g(), geom2.g(), geom1.sr())
+        && !GeometryEngine.crosses(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether no point in {@code geom2} is outside {@code geom1}. */
+  private static boolean ST_Covers(Geom geom1, Geom geom2)  {
+    throw todo();
+  }
+
+  /** Returns whether {@code geom1} crosses {@code geom2}. */
+  public static boolean ST_Crosses(Geom geom1, Geom geom2)  {
+    return GeometryEngine.crosses(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether {@code geom1} and {@code geom2} are disjoint. */
+  public static boolean ST_Disjoint(Geom geom1, Geom geom2)  {
+    return GeometryEngine.disjoint(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether the envelope of {@code geom1} intersects the envelope of
+   *  {@code geom2}. */
+  public static boolean ST_EnvelopesIntersect(Geom geom1, Geom geom2)  {
+    final Geometry e1 = envelope(geom1.g());
+    final Geometry e2 = envelope(geom2.g());
+    return intersects(e1, e2, geom1.sr());
+  }
+
+  /** Returns whether {@code geom1} equals {@code geom2}. */
+  public static boolean ST_Equals(Geom geom1, Geom geom2)  {
+    return GeometryEngine.equals(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether {@code geom1} intersects {@code geom2}. */
+  public static boolean ST_Intersects(Geom geom1, Geom geom2)  {
+    final Geometry g1 = geom1.g();
+    final Geometry g2 = geom2.g();
+    final SpatialReference sr = geom1.sr();
+    return intersects(g1, g2, sr);
+  }
+
+  private static boolean intersects(Geometry g1, Geometry g2,
+      SpatialReference sr) {
+    final OperatorIntersects op = (OperatorIntersects) OperatorFactoryLocal
+        .getInstance().getOperator(Operator.Type.Intersects);
+    return op.execute(g1, g2, sr, null);
+  }
+
+  /** Returns whether {@code geom1} equals {@code geom2} and their coordinates
+   * and component Geometries are listed in the same order. */
+  public static boolean ST_OrderingEquals(Geom geom1, Geom geom2)  {
+    return GeometryEngine.equals(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns {@code geom1} overlaps {@code geom2}. */
+  public static boolean ST_Overlaps(Geom geom1, Geom geom2)  {
+    return GeometryEngine.overlaps(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether {@code geom1} touches {@code geom2}. */
+  public static boolean ST_Touches(Geom geom1, Geom geom2)  {
+    return GeometryEngine.touches(geom1.g(), geom2.g(), geom1.sr());
+  }
+
+  /** Returns whether {@code geom1} is within {@code geom2}. */
+  public static boolean ST_Within(Geom geom1, Geom geom2)  {
+    return GeometryEngine.within(geom1.g(), geom2.g(), geom1.sr());
+  }
+
   /** Returns whether {@code geom1} and {@code geom2} are within
    * {@code distance} of each other. */
   public static boolean ST_DWithin(Geom geom1, Geom geom2, double distance) {
@@ -436,6 +625,27 @@ public Geom wrap(Geometry g) {
       return bind(g, this.mg.getSpatialReference());
     }
   }
+
+  /** Geometry types, with the names and codes assigned by OGC. */
+  enum Type {
+    Geometry(0),
+    POINT(1),
+    LINESTRING(2),
+    POLYGON(3),
+    MULTIPOINT(4),
+    MULTILINESTRING(5),
+    MULTIPOLYGON(6),
+    GEOMCOLLECTION(7),
+    CURVE(13),
+    SURFACE(14),
+    POLYHEDRALSURFACE(15);
+
+    final int code;
+
+    Type(int code) {
+      this.code = code;
+    }
+  }
 }
 
 // End GeoFunctions.java