st_orientedenvelope

Author: joonaspessi

common/src/main/java/org/apache/sedona/common/Functions.java

@@ -36,6 +36,7 @@
 import org.apache.sedona.common.subDivide.GeometrySubDivider;
 import org.apache.sedona.common.utils.*;
 import org.locationtech.jts.algorithm.Angle;
+import org.locationtech.jts.algorithm.MinimumAreaRectangle;
 import org.locationtech.jts.algorithm.MinimumBoundingCircle;
 import org.locationtech.jts.algorithm.Orientation;
 import org.locationtech.jts.algorithm.construct.LargestEmptyCircle;
@@ -1227,6 +1228,10 @@ public static Geometry minimumBoundingCircle(Geometry geometry, int quadrantSegm
     return circle;
   }
 
+  public static Geometry orientedEnvelope(Geometry geometry) {
+    return MinimumAreaRectangle.getMinimumRectangle(geometry);
+  }
+
   public static InscribedCircle maximumInscribedCircle(Geometry geometry) {
     // Calculating the tolerance
     Envelope envelope = geometry.getEnvelopeInternal();

common/src/test/java/org/apache/sedona/common/FunctionsTest.java

@@ -756,6 +756,76 @@ public void envelopeAndCentroidSRID() throws ParseException {
     assertEquals(3857, centroid.getSRID());
   }
 
+  @Test
+  public void orientedEnvelope() throws ParseException {
+    Geometry axisAlignedRect = Constructors.geomFromWKT("POLYGON ((0 0, 4 0, 4 2, 0 2, 0 0))", 0);
+    String actual = Functions.asWKT(Functions.orientedEnvelope(axisAlignedRect));
+    String expected = "POLYGON ((0 0, 0 2, 4 2, 4 0, 0 0))";
+    assertEquals(expected, actual);
+
+    Geometry rotatedSquare = Constructors.geomFromWKT("POLYGON ((1 0, 2 1, 1 2, 0 1, 1 0))", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(rotatedSquare));
+    expected = "POLYGON ((1 0, 0 1, 1 2, 2 1, 1 0))";
+    assertEquals(expected, actual);
+
+    Geometry diagonalPolygon = Constructors.geomFromWKT("POLYGON ((0 0, 1 0, 5 4, 4 4, 0 0))", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(diagonalPolygon));
+    expected = "POLYGON ((0 0, 4.5 4.5, 5 4, 0.5 -0.5, 0 0))";
+    assertEquals(expected, actual);
+
+    Geometry narrowRect = Constructors.geomFromWKT("POLYGON ((0 0, 10 0, 10 1, 0 1, 0 0))", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(narrowRect));
+    expected = "POLYGON ((0 0, 0 1, 10 1, 10 0, 0 0))";
+    assertEquals(expected, actual);
+
+    Geometry triangle = Constructors.geomFromWKT("POLYGON ((0 0, 4 0, 2 3, 0 0))", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(triangle));
+    expected = "POLYGON ((4 0, 0 0, 0 3, 4 3, 4 0))";
+    assertEquals(expected, actual);
+
+    Geometry irregularPolygon =
+        Constructors.geomFromWKT("POLYGON ((0 0, 3 1, 5 0, 4 4, 1 3, 0 0))", 0);
+    actual =
+        Functions.asWKT(Functions.reducePrecision(Functions.orientedEnvelope(irregularPolygon), 2));
+    expected = "POLYGON ((5 0, 0.29 -1.18, -0.71 2.82, 4 4, 5 0))";
+    assertEquals(expected, actual);
+
+    Geometry point = Constructors.geomFromWKT("POINT (1 2)", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(point));
+    expected = "POINT (1 2)";
+    assertEquals(expected, actual);
+
+    Geometry line = Constructors.geomFromWKT("LINESTRING (0 0, 10 0)", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(line));
+    expected = "LINESTRING (0 0, 10 0)";
+    assertEquals(expected, actual);
+
+    Geometry diagonalLine = Constructors.geomFromWKT("LINESTRING (0 0, 5 5)", 0);
+    actual = Functions.asWKT(Functions.orientedEnvelope(diagonalLine));
+    expected = "LINESTRING (0 0, 5 5)";
+    assertEquals(expected, actual);
+
+    Geometry empty = Constructors.geomFromWKT("POLYGON EMPTY", 0);
+    Geometry orientedEmpty = Functions.orientedEnvelope(empty);
+    assertTrue(orientedEmpty.isEmpty());
+
+    Geometry geomWithSRID = Constructors.geomFromWKT("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))", 4326);
+    Geometry orientedWithSRID = Functions.orientedEnvelope(geomWithSRID);
+    assertEquals(4326, orientedWithSRID.getSRID());
+
+    Geometry multiPoint = Constructors.geomFromWKT("MULTIPOINT ((0 0), (-1 -1), (3 2))", 0);
+    actual = Functions.asWKT(Functions.reducePrecision(Functions.orientedEnvelope(multiPoint), 2));
+    expected = "POLYGON ((-1 -1, -1.12 -0.84, 2.88 2.16, 3 2, -1 -1))";
+    assertEquals(expected, actual);
+
+    Geometry linestring = Constructors.geomFromWKT("LINESTRING (55 75, 125 150)", 0);
+    Geometry pointGeom = Constructors.geomFromWKT("POINT (20 80)", 0);
+    Geometry collection = linestring.union(pointGeom);
+    actual = Functions.asWKT(Functions.reducePrecision(Functions.orientedEnvelope(collection), 2));
+    expected = "POLYGON ((125 150, 138.08 130.38, 33.08 60.38, 20 80, 125 150))";
+    assertEquals(expected, actual);
+  }
+
   @Test
   public void getGoogleS2CellIDsPoint() {
     Point point = GEOMETRY_FACTORY.createPoint(new Coordinate(1, 2));

python/sedona/spark/sql/st_functions.py

@@ -1595,6 +1595,18 @@ def ST_NumInteriorRing(geometry: ColumnOrName) -> Column:
     return _call_st_function("ST_NumInteriorRing", geometry)
 
 
+@validate_argument_types
+def ST_OrientedEnvelope(geometry: ColumnOrName) -> Column:
+    """Return the minimum rotated rectangle enclosing a geometry.
+
+    :param geometry: Geometry column to compute oriented envelope for.
+    :type geometry: ColumnOrName
+    :return: Minimum area rotated rectangle as a geometry column.
+    :rtype: Column
+    """
+    return _call_st_function("ST_OrientedEnvelope", geometry)
+
+
 @validate_argument_types
 def ST_PointN(geometry: ColumnOrName, n: Union[ColumnOrName, int]) -> Column:
     """Get the n-th point (starts at 1) for a geometry.

python/tests/sql/test_function.py

@@ -2529,3 +2529,14 @@ def test_st_approximate_medial_axis(self):
         actual_with_max = actual_df_with_max.take(1)[0][0]
         assert actual_with_max is not None
         assert actual_with_max.geom_type == "MultiLineString"
+
+    def test_st_oriented_envelope(self):
+        actual = self.spark.sql(
+            "SELECT ST_AsText(ST_OrientedEnvelope(ST_GeomFromText('POLYGON ((0 0, 1 0, 5 4, 4 4, 0 0))')))"
+        ).take(1)[0][0]
+        assert actual == "POLYGON ((0 0, 4.5 4.5, 5 4, 0.5 -0.5, 0 0))"
+
+        actual = self.spark.sql(
+            "SELECT ST_AsText(ST_OrientedEnvelope(ST_GeomFromText('POINT (1 2)')))"
+        ).take(1)[0][0]
+        assert actual == "POINT (1 2)"

spark/common/src/main/scala/org/apache/sedona/sql/UDF/Catalog.scala

@@ -208,6 +208,7 @@ object Catalog extends AbstractCatalog with Logging {
     function[ST_XMin](),
     function[ST_BuildArea](),
     function[ST_OrderingEquals](),
+    function[ST_OrientedEnvelope](),
     function[ST_CollectionExtract](defaultArgs = null),
     function[ST_Normalize](),
     function[ST_LineFromMultiPoint](),

spark/common/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/Functions.scala

@@ -701,6 +701,14 @@ private[apache] case class ST_MinimumBoundingCircle(inputExpressions: Seq[Expres
   }
 }
 
+private[apache] case class ST_OrientedEnvelope(inputExpressions: Seq[Expression])
+    extends InferredExpression(Functions.orientedEnvelope _) {
+
+  protected def withNewChildrenInternal(newChildren: IndexedSeq[Expression]) = {
+    copy(inputExpressions = newChildren)
+  }
+}
+
 private[apache] case class ST_HasZ(inputExpressions: Seq[Expression])
     extends InferredExpression(Functions.hasZ _) {
 

spark/common/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/st_functions.scala

@@ -504,6 +504,11 @@ object st_functions {
   def ST_MinimumBoundingRadius(geometry: String): Column =
     wrapExpression[ST_MinimumBoundingRadius](geometry)
 
+  def ST_OrientedEnvelope(geometry: Column): Column =
+    wrapExpression[ST_OrientedEnvelope](geometry)
+  def ST_OrientedEnvelope(geometry: String): Column =
+    wrapExpression[ST_OrientedEnvelope](geometry)
+
   def ST_IsPolygonCCW(geometry: Column): Column = wrapExpression[ST_IsPolygonCCW](geometry)
   def ST_IsPolygonCCW(geometry: String): Column = wrapExpression[ST_IsPolygonCCW](geometry)
 

spark/common/src/test/scala/org/apache/sedona/sql/functionTestScala.scala

@@ -2373,6 +2373,21 @@ class functionTestScala
       .toList should contain theSameElementsAs List(0, 1, 1)
   }
 
+  it("Should pass ST_OrientedEnvelope") {
+    val testCases = Seq(
+      ("POLYGON ((0 0, 4 0, 4 2, 0 2, 0 0))", "POLYGON ((0 0, 0 2, 4 2, 4 0, 0 0))"),
+      ("POLYGON ((0 0, 1 0, 5 4, 4 4, 0 0))", "POLYGON ((0 0, 4.5 4.5, 5 4, 0.5 -0.5, 0 0))"),
+      ("POINT (1 2)", "POINT (1 2)"))
+
+    testCases.foreach { case (input, expected) =>
+      val actual = sparkSession
+        .sql(s"SELECT ST_AsText(ST_OrientedEnvelope(ST_GeomFromWKT('$input')))")
+        .first()
+        .getString(0)
+      assert(expected.equals(actual), s"Input: $input, Expected: $expected, Actual: $actual")
+    }
+  }
+
   it("Should pass ST_LineSegments") {
     val baseDf = sparkSession.sql(
       "SELECT ST_GeomFromWKT('LINESTRING(120 140, 60 120, 30 20)') AS line, ST_GeomFromWKT('POLYGON ((0 0, 0 1, 1 0, 0 0))') AS poly")
@@ -2733,6 +2748,8 @@ class functionTestScala
     assert(functionDf.first().get(0) == null)
     functionDf = sparkSession.sql("select ST_MinimumBoundingRadius(null)")
     assert(functionDf.first().get(0) == null)
+    functionDf = sparkSession.sql("select ST_OrientedEnvelope(null)")
+    assert(functionDf.first().get(0) == null)
     functionDf = sparkSession.sql("select ST_LineSubstring(null, 0, 0)")
     assert(functionDf.first().get(0) == null)
     functionDf = sparkSession.sql("select ST_LineInterpolatePoint(null, 0)")