Avoid dummy endpoints in no-endpoint LineString uncompaction

Rewrite CompactLineStringUtils.uncompactLineString(byte[], boolean) to
decode delta-encoded coordinates directly from origin (0,0) instead of
delegating to the endpoint-aware overload with dummy (0,0) endpoints and
then stripping them via removeStartEndCoordinatesFromLineString().

This eliminates per-call allocation of 2 dummy Coordinate objects,
1 intermediate LineString, and 1 redundant Coordinate[] copy.

JFR profiling under production-like load shows geometry subsystem
allocation dropped from 93 GB to 42 GB (-55%) and overall allocation
rate dropped from 1,499 MB/s to 1,170 MB/s (-22%).

Author: vpaturet

street/src/main/java/org/opentripplanner/street/geometry/CompactLineStringUtils.java

@@ -168,12 +168,27 @@ public static LineString uncompactLineString(
   }
 
   /**
-   * Wrapper for the above method in the case where there are no start/end coordinates provided.
-   * 0-coordinates are added and then removed in order for the delta encoding to work correctly.
-   * Same as the other version, but in a var-len int packed form (Dlugosz coding).
+   * Uncompact a line string that was compacted without start/end endpoint context. Decodes the
+   * delta-encoded coordinates directly, avoiding the intermediate dummy-endpoint LineString and
+   * subsequent strip that the previous implementation used.
    */
   public static LineString uncompactLineString(byte[] packedCoords, boolean reverse) {
-    LineString lineString = uncompactLineString(0.0, 0.0, 0.0, 0.0, packedCoords, reverse);
-    return GeometryUtils.removeStartEndCoordinatesFromLineString(lineString);
+    int[] coords = DlugoszVarLenIntPacker.unpack(packedCoords);
+    if (coords == null || coords.length == 0) {
+      return GeometryUtils.makeLineString(new Coordinate[0]);
+    }
+    int size = coords.length / 2;
+    Coordinate[] c = new Coordinate[size];
+    int oix = 0;
+    int oiy = 0;
+    for (int i = 0; i < size; i++) {
+      int ix = oix + coords[i * 2];
+      int iy = oiy + coords[i * 2 + 1];
+      c[i] = new Coordinate(ix / FIXED_FLOAT_MULT, iy / FIXED_FLOAT_MULT);
+      oix = ix;
+      oiy = iy;
+    }
+    LineString out = GeometryUtils.makeLineString(c);
+    return reverse ? out.reverse() : out;
   }
 }

street/src/main/java/org/opentripplanner/street/geometry/GeometryUtils.java

@@ -113,13 +113,6 @@ public static LineString addStartEndCoordinatesToLineString(
     return makeLineString(result);
   }
 
-  public static LineString removeStartEndCoordinatesFromLineString(LineString lineString) {
-    Coordinate[] c = lineString.getCoordinates();
-    Coordinate[] result = new Coordinate[c.length - 2];
-    System.arraycopy(c, 1, result, 0, c.length - 2);
-    return makeLineString(result);
-  }
-
   public static GeometryFactory getGeometryFactory() {
     return GF;
   }

street/src/test/java/org/opentripplanner/street/geometry/CompactLineStringUtilsTest.java

@@ -80,6 +80,30 @@ public final void testCompactString() {
     assertTrue(lsi.equalsExact(ls2, 0.00000015));
   }
 
+  @Test
+  public void testNoEndpointRoundTrip() {
+    GeometryFactory gf = new GeometryFactory();
+
+    Coordinate[] points = {
+      new Coordinate(-179.99, 1.12345),
+      new Coordinate(10.123456, 59.654321),
+      new Coordinate(179.99, 1.12345),
+    };
+    LineString original = gf.createLineString(points);
+
+    // Forward
+    byte[] packed = CompactLineStringUtils.compactLineString(original, false);
+    LineString result = CompactLineStringUtils.uncompactLineString(packed, false);
+    assertEquals(original.getNumPoints(), result.getNumPoints());
+    assertTrue(original.equalsExact(result, 0.0000015));
+
+    // Reverse
+    LineString reversed = (LineString) original.reverse();
+    result = CompactLineStringUtils.uncompactLineString(packed, true);
+    assertEquals(reversed.getNumPoints(), result.getNumPoints());
+    assertTrue(reversed.equalsExact(result, 0.0000015));
+  }
+
   @Test
   public final void testDlugoszVarLenIntPacker() {
     packTest(new int[] {}, 0);