[GH-3369] Preserve declared geometry dimensions through serialization

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

@@ -74,7 +74,7 @@ public static Geometry geomFromWKB(byte[] wkb) throws ParseException {
   }
 
   public static Geometry geomFromWKB(byte[] wkb, int SRID) throws ParseException {
-    Geometry geom = new WKBReader().read(wkb);
+    Geometry geom = WKBReader.forDeclaredDimensions().read(wkb);
     if (geom.getFactory().getSRID() != geom.getSRID() || (SRID >= 0 && geom.getSRID() != SRID)) {
       // Make sure that the geometry and the geometry factory have the correct SRID
       if (SRID < 0) {

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

@@ -38,6 +38,7 @@
 import org.apache.sedona.common.sphere.Spheroid;
 import org.apache.sedona.common.subDivide.GeometrySubDivider;
 import org.apache.sedona.common.utils.*;
+import org.datasyslab.jts.geom.util.GeometryCopier;
 import org.locationtech.jts.algorithm.Angle;
 import org.locationtech.jts.algorithm.MinimumAreaRectangle;
 import org.locationtech.jts.algorithm.MinimumBoundingCircle;
@@ -1103,12 +1104,7 @@ public static Geometry setSRID(Geometry geometry, int srid) {
             geometry.getPrecisionModel(),
             srid,
             geometry.getFactory().getCoordinateSequenceFactory());
-    Geometry newGeom = factory.createGeometry(geometry);
-    // Workaround for JTS bug: GeometryEditor.editPolygon returns the original
-    // empty polygon without copying it to the new factory, so the SRID is not
-    // updated for POLYGON EMPTY (and similar empty geometry types).
-    newGeom.setSRID(srid);
-    return newGeom;
+    return GeometryCopier.copy(geometry, factory);
   }
 
   public static int getSRID(Geometry geometry) {

common/src/main/java/org/apache/sedona/common/geometrySerde/ByteBufferGeometryBuffer.java

@@ -20,12 +20,12 @@
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import org.datasyslab.jts.geom.impl.DeclaredCoordinateSequence;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.jts.geom.CoordinateSequence;
 import org.locationtech.jts.geom.CoordinateXY;
 import org.locationtech.jts.geom.CoordinateXYM;
 import org.locationtech.jts.geom.CoordinateXYZM;
-import org.locationtech.jts.geom.impl.CoordinateArraySequence;
 
 class ByteBufferGeometryBuffer implements GeometryBuffer {
   private CoordinateType coordinateType = CoordinateType.XY;
@@ -126,20 +126,20 @@ public CoordinateSequence getCoordinate(int offset) {
     switch (coordinateType) {
       case XY:
         coordinates[0] = new CoordinateXY(x, y);
-        return new CoordinateArraySequence(coordinates, 2, 0);
+        return new DeclaredCoordinateSequence(coordinates, 2, 0);
       case XYZ:
         z = byteBuffer.getDouble(offset + 16);
         coordinates[0] = new Coordinate(x, y, z);
-        return new CoordinateArraySequence(coordinates, 3, 0);
+        return new DeclaredCoordinateSequence(coordinates, 3, 0);
       case XYM:
         m = byteBuffer.getDouble(offset + 16);
         coordinates[0] = new CoordinateXYM(x, y, m);
-        return new CoordinateArraySequence(coordinates, 3, 1);
+        return new DeclaredCoordinateSequence(coordinates, 3, 1);
       case XYZM:
         z = byteBuffer.getDouble(offset + 16);
         m = byteBuffer.getDouble(offset + 24);
         coordinates[0] = new CoordinateXYZM(x, y, z, m);
-        return new CoordinateArraySequence(coordinates, 4, 1);
+        return new DeclaredCoordinateSequence(coordinates, 4, 1);
       default:
         throw new IllegalStateException("coordinateType was not configured properly");
     }
@@ -240,7 +240,7 @@ public CoordinateSequence getCoordinates(int offset, int numCoordinates) {
       default:
         throw new IllegalStateException("coordinateType was not configured properly");
     }
-    return new CoordinateArraySequence(coordinates, dimension, measures);
+    return new DeclaredCoordinateSequence(coordinates, dimension, measures);
   }
 
   @Override

common/src/main/java/org/apache/sedona/common/geometrySerde/GeometrySerializer.java

@@ -18,6 +18,8 @@
  */
 package org.apache.sedona.common.geometrySerde;
 
+import org.datasyslab.jts.geom.impl.DeclaredCoordinateSequence;
+import org.datasyslab.jts.geom.impl.DeclaredCoordinateSequenceFactory;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.jts.geom.CoordinateSequence;
 import org.locationtech.jts.geom.Geometry;
@@ -476,12 +478,14 @@ private static void collectCoordinateDimensions(
 
     // Measures are explicit CoordinateSequence metadata. A Z dimension is not always explicit:
     // JTS's default sequence factory represents ordinary XY coordinates as dimension 3 with NaN Z.
-    // XYZM is unambiguous, while XYZ is recoverable only when at least one Z value is finite. An
-    // ambiguous sequence does not constrain a multipart geometry whose other members establish the
-    // shared layout.
+    // Trusted binary layouts and XYZM are unambiguous. Unmarked XYZ is recoverable only when at
+    // least one Z value is non-NaN. An ambiguous sequence does not constrain a multipart geometry
+    // whose other members establish the shared layout.
     CoordinateType coordinateType = null;
     if (measures > 0) {
       coordinateType = spatialDimensions > 2 ? CoordinateType.XYZM : CoordinateType.XYM;
+    } else if (coordinates instanceof DeclaredCoordinateSequence && spatialDimensions == 3) {
+      coordinateType = CoordinateType.XYZ;
     } else if (spatialDimensions == 2) {
       coordinateType = CoordinateType.XY;
     } else {
@@ -500,7 +504,7 @@ private static int alignedOffset(int offset) {
   }
 
   private static GeometryFactory createGeometryFactory(int srid) {
-    return new GeometryFactory(PRECISION_MODEL, srid);
+    return new GeometryFactory(PRECISION_MODEL, srid, DeclaredCoordinateSequenceFactory.instance());
   }
 
   private static Polygon createEmptyPolygon(

common/src/main/java/org/apache/sedona/common/geometrySerde/UnsafeGeometryBuffer.java

@@ -19,12 +19,12 @@
 package org.apache.sedona.common.geometrySerde;
 
 import java.lang.reflect.Field;
+import org.datasyslab.jts.geom.impl.DeclaredCoordinateSequence;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.jts.geom.CoordinateSequence;
 import org.locationtech.jts.geom.CoordinateXY;
 import org.locationtech.jts.geom.CoordinateXYM;
 import org.locationtech.jts.geom.CoordinateXYZM;
-import org.locationtech.jts.geom.impl.CoordinateArraySequence;
 import sun.misc.Unsafe;
 
 class UnsafeGeometryBuffer implements GeometryBuffer {
@@ -173,20 +173,20 @@ public CoordinateSequence getCoordinate(int offset) {
     switch (coordinateType) {
       case XY:
         coordinates[0] = new CoordinateXY(x, y);
-        return new CoordinateArraySequence(coordinates, 2, 0);
+        return new DeclaredCoordinateSequence(coordinates, 2, 0);
       case XYZ:
         z = UNSAFE.getDouble(bytes, coordOffset + 16);
         coordinates[0] = new Coordinate(x, y, z);
-        return new CoordinateArraySequence(coordinates, 3, 0);
+        return new DeclaredCoordinateSequence(coordinates, 3, 0);
       case XYM:
         m = UNSAFE.getDouble(bytes, coordOffset + 16);
         coordinates[0] = new CoordinateXYM(x, y, m);
-        return new CoordinateArraySequence(coordinates, 3, 1);
+        return new DeclaredCoordinateSequence(coordinates, 3, 1);
       case XYZM:
         z = UNSAFE.getDouble(bytes, coordOffset + 16);
         m = UNSAFE.getDouble(bytes, coordOffset + 24);
         coordinates[0] = new CoordinateXYZM(x, y, z, m);
-        return new CoordinateArraySequence(coordinates, 4, 1);
+        return new DeclaredCoordinateSequence(coordinates, 4, 1);
       default:
         throw new IllegalStateException("coordinateType was not configured properly");
     }
@@ -293,7 +293,7 @@ public CoordinateSequence getCoordinates(int offset, int numCoordinates) {
       default:
         throw new IllegalStateException("coordinateType was not configured properly");
     }
-    return new CoordinateArraySequence(coordinates, dimension, measures);
+    return new DeclaredCoordinateSequence(coordinates, dimension, measures);
   }
 
   @Override

common/src/main/java/org/apache/sedona/common/utils/FormatUtils.java

@@ -207,10 +207,7 @@ public Geometry readWkt(String line) throws ParseException {
   public Geometry readWkb(String line) throws ParseException {
     final String[] columns = line.split(splitter.getDelimiter());
     final byte[] aux = WKBReader.hexToBytes(columns[this.startOffset]);
-    // For some unknown reasons, the wkb reader cannot be used in transient variable like the wkt
-    // reader.
-    WKBReader wkbReader = new WKBReader();
-    Geometry geometry = wkbReader.read(aux);
+    Geometry geometry = WKBReader.forDeclaredDimensions().read(aux);
     if (geometry.getSRID() != geometry.getFactory().getSRID()) {
       // Make sure that the geometry factory has the correct SRID when the parsed WKB
       // contains a non-zero SRID (EWKB)

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

@@ -37,6 +37,8 @@
 import org.junit.Test;
 import org.locationtech.jts.geom.*;
 import org.locationtech.jts.geom.LinearRing;
+import org.locationtech.jts.geom.impl.CoordinateArraySequenceFactory;
+import org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory;
 import org.locationtech.jts.geom.prep.PreparedGeometry;
 import org.locationtech.jts.geom.prep.PreparedGeometryFactory;
 import org.locationtech.jts.io.ParseException;
@@ -4676,6 +4678,166 @@ public void setSRIDEmptyGeometries() throws ParseException {
     }
   }
 
+  @Test
+  public void setSRIDPreservesEmptyPolygonHoles() throws ParseException {
+    Polygon source =
+        (Polygon) Constructors.geomFromWKT("POLYGON ((0 0, 10 0, 10 10, 0 0), EMPTY)", 100);
+
+    Polygon result = (Polygon) Functions.setSRID(source, 4326);
+
+    assertEquals(1, result.getNumInteriorRing());
+    assertTrue(result.getInteriorRingN(0).isEmpty());
+    assertEquals(source.getExteriorRing(), result.getExteriorRing());
+    assertNotSame(source.getInteriorRingN(0), result.getInteriorRingN(0));
+    assertGeometryTreeUsesFactory(result, result.getFactory(), 4326);
+    assertEquals(100, source.getSRID());
+    assertEquals(1, source.getNumInteriorRing());
+  }
+
+  @Test
+  public void setSRIDCopiesEmptyPolygonWithoutMutatingInput() throws ParseException {
+    Polygon source = (Polygon) Constructors.geomFromWKT("POLYGON EMPTY", 100);
+    source.setUserData("source metadata");
+    source.getExteriorRing().setUserData("shell metadata");
+
+    Polygon result = (Polygon) Functions.setSRID(source, 4326);
+
+    assertEquals(100, source.getSRID());
+    assertNotSame(source, result);
+    assertNotSame(source.getExteriorRing(), result.getExteriorRing());
+    assertTrue(result.isEmpty());
+    assertGeometryTreeUsesFactory(result, result.getFactory(), 4326);
+    assertNull(result.getUserData());
+    assertNull(result.getExteriorRing().getUserData());
+    assertEquals("source metadata", source.getUserData());
+    assertEquals("shell metadata", source.getExteriorRing().getUserData());
+  }
+
+  @Test
+  public void setSRIDPreservesNestedEmptyComponentsAndCopiesStructure() {
+    GeometryFactory sourceFactory =
+        new GeometryFactory(new PrecisionModel(), 100, CoordinateArraySequenceFactory.instance());
+    Point emptyPoint =
+        sourceFactory.createPoint(sourceFactory.getCoordinateSequenceFactory().create(0, 3, 0));
+    Polygon emptyPolygon =
+        sourceFactory.createPolygon(
+            sourceFactory.createLinearRing(
+                sourceFactory.getCoordinateSequenceFactory().create(0, 4, 1)));
+    Point populatedPoint = sourceFactory.createPoint(new Coordinate(1, 2));
+    GeometryCollection nested =
+        sourceFactory.createGeometryCollection(new Geometry[] {emptyPolygon, populatedPoint});
+    GeometryCollection source =
+        sourceFactory.createGeometryCollection(new Geometry[] {emptyPoint, nested});
+    source.setSRID(100);
+    emptyPoint.setSRID(101);
+    nested.setSRID(102);
+    emptyPolygon.setSRID(103);
+    populatedPoint.setSRID(104);
+    source.setUserData("root metadata");
+    emptyPoint.setUserData("child metadata");
+    nested.setUserData("nested metadata");
+
+    GeometryCollection result = (GeometryCollection) Functions.setSRID(source, 4326);
+
+    assertEquals(2, result.getNumGeometries());
+    assertEquals(2, result.getGeometryN(1).getNumGeometries());
+    assertGeometryTreeUsesFactory(result, result.getFactory(), 4326);
+    assertNull(result.getUserData());
+    assertNull(result.getGeometryN(0).getUserData());
+    assertNull(result.getGeometryN(1).getUserData());
+    assertEquals(3, ((Point) result.getGeometryN(0)).getCoordinateSequence().getDimension());
+    assertEquals(
+        4,
+        ((Polygon) result.getGeometryN(1).getGeometryN(0))
+            .getExteriorRing()
+            .getCoordinateSequence()
+            .getDimension());
+    assertEquals(
+        1,
+        ((Polygon) result.getGeometryN(1).getGeometryN(0))
+            .getExteriorRing()
+            .getCoordinateSequence()
+            .getMeasures());
+    assertNotSame(source, result);
+    assertNotSame(source.getGeometryN(0), result.getGeometryN(0));
+    Point resultPoint = (Point) result.getGeometryN(1).getGeometryN(1);
+    resultPoint.getCoordinateSequence().setOrdinate(0, 0, 9);
+    assertEquals(1, populatedPoint.getX(), 0);
+    assertEquals(100, source.getSRID());
+    assertEquals(101, emptyPoint.getSRID());
+    assertEquals(102, nested.getSRID());
+    assertEquals(103, emptyPolygon.getSRID());
+    assertEquals(104, populatedPoint.getSRID());
+    assertEquals("root metadata", source.getUserData());
+    assertEquals("child metadata", emptyPoint.getUserData());
+    assertEquals("nested metadata", nested.getUserData());
+  }
+
+  @Test
+  public void setSRIDPreservesPackedCoordinateSequenceFactoryAndEmptyLayouts() {
+    GeometryFactory sourceFactory =
+        new GeometryFactory(
+            new PrecisionModel(), 7, PackedCoordinateSequenceFactory.DOUBLE_FACTORY);
+    Point emptyXym =
+        sourceFactory.createPoint(sourceFactory.getCoordinateSequenceFactory().create(0, 3, 1));
+    LineString emptyXyz =
+        sourceFactory.createLineString(
+            sourceFactory.getCoordinateSequenceFactory().create(0, 3, 0));
+    LinearRing emptyXyzmShell =
+        sourceFactory.createLinearRing(
+            sourceFactory.getCoordinateSequenceFactory().create(0, 4, 1));
+    GeometryCollection source =
+        sourceFactory.createGeometryCollection(
+            new Geometry[] {
+              sourceFactory.createMultiPoint(new Point[] {emptyXym}),
+              sourceFactory.createMultiLineString(new LineString[] {emptyXyz}),
+              sourceFactory.createMultiPolygon(
+                  new Polygon[] {sourceFactory.createPolygon(emptyXyzmShell)})
+            });
+
+    GeometryCollection result = (GeometryCollection) Functions.setSRID(source, 3857);
+
+    assertSame(
+        PackedCoordinateSequenceFactory.DOUBLE_FACTORY,
+        result.getFactory().getCoordinateSequenceFactory());
+    assertEquals(1, result.getGeometryN(0).getNumGeometries());
+    assertEquals(1, result.getGeometryN(1).getNumGeometries());
+    assertEquals(1, result.getGeometryN(2).getNumGeometries());
+    CoordinateSequence pointSequence =
+        ((Point) result.getGeometryN(0).getGeometryN(0)).getCoordinateSequence();
+    CoordinateSequence lineSequence =
+        ((LineString) result.getGeometryN(1).getGeometryN(0)).getCoordinateSequence();
+    CoordinateSequence shellSequence =
+        ((Polygon) result.getGeometryN(2).getGeometryN(0))
+            .getExteriorRing()
+            .getCoordinateSequence();
+    assertEquals(3, pointSequence.getDimension());
+    assertEquals(1, pointSequence.getMeasures());
+    assertEquals(3, lineSequence.getDimension());
+    assertEquals(0, lineSequence.getMeasures());
+    assertEquals(4, shellSequence.getDimension());
+    assertEquals(1, shellSequence.getMeasures());
+    assertGeometryTreeUsesFactory(result, result.getFactory(), 3857);
+    assertEquals(7, source.getFactory().getSRID());
+  }
+
+  private static void assertGeometryTreeUsesFactory(
+      Geometry geometry, GeometryFactory factory, int srid) {
+    assertSame(factory, geometry.getFactory());
+    assertEquals(srid, geometry.getSRID());
+    assertEquals(srid, geometry.getFactory().getSRID());
+    for (int i = 0; i < geometry.getNumGeometries(); i++) {
+      Geometry child = geometry.getGeometryN(i);
+      if (child != geometry) assertGeometryTreeUsesFactory(child, factory, srid);
+    }
+    if (geometry instanceof Polygon) {
+      Polygon polygon = (Polygon) geometry;
+      assertGeometryTreeUsesFactory(polygon.getExteriorRing(), factory, srid);
+      for (int i = 0; i < polygon.getNumInteriorRing(); i++)
+        assertGeometryTreeUsesFactory(polygon.getInteriorRingN(i), factory, srid);
+    }
+  }
+
   @Test
   public void closestPoint() {
     Point point1 = GEOMETRY_FACTORY.createPoint(new Coordinate(1, 1));