fix: spatially compute geofencing boundaries for split vertices

Split vertices on boundary-crossing edges were getting wrong geofencing
boundaries because copyRentalRestrictionsFrom blind-copied the entering
flag from parent vertices. The entering flag encodes position (outside=
true, inside=false), so a split vertex on the opposite side of the zone
boundary from its parent got the wrong flag, breaking the pairing check
in updateGeofencingZones.

Now VertexLinker.createSplitVertex queries the spatial zone index to
determine which zones contain the split point and sets the correct
entering flag accordingly. For permanent split vertices at concave zone
corners where no permanent neighbor is inside the zone, the missing
boundary is lazily added to the parent edge's fromVertex.

Also fixes GeofencingZoneApplier to add boundary extensions to both
endpoints of boundary-crossing edges (not just fromv), and aligns
GeofencingZoneIndex to use covers() matching the applier's semantics.

Author: testower

street/src/main/java/org/opentripplanner/service/vehiclerental/street/GeofencingZoneApplier.java

@@ -144,27 +144,51 @@ private Map<StreetEdge, GeofencingBoundaryExtension> addBoundaryExtensions(
 
       for (var e : candidates) {
         if (e instanceof StreetEdge streetEdge) {
-          var fromVertex = streetEdge.getFromVertex();
-          var toVertex = streetEdge.getToVertex();
-
-          boolean fromInZone = vertexInZone.computeIfAbsent(fromVertex, v ->
-            isVertexInZone(v.getCoordinate(), zoneBBox, preparedZone, reusablePoint)
-          );
-          boolean toInZone = vertexInZone.computeIfAbsent(toVertex, v ->
-            isVertexInZone(v.getCoordinate(), zoneBBox, preparedZone, reusablePoint)
+          addBoundaryIfCrossing(
+            streetEdge,
+            zone,
+            zoneBBox,
+            preparedZone,
+            reusablePoint,
+            vertexInZone,
+            edgesUpdated
           );
-
-          if (fromInZone != toInZone) {
-            var ext = new GeofencingBoundaryExtension(zone, toInZone);
-            streetEdge.addGeofencingBoundary(ext);
-            edgesUpdated.put(streetEdge, ext);
-          }
         }
       }
     }
     return edgesUpdated;
   }
 
+  private static void addBoundaryIfCrossing(
+    StreetEdge streetEdge,
+    GeofencingZone zone,
+    Envelope zoneBBox,
+    PreparedGeometry preparedZone,
+    Point reusablePoint,
+    Map<Vertex, Boolean> vertexInZone,
+    Map<StreetEdge, GeofencingBoundaryExtension> edgesUpdated
+  ) {
+    var fromVertex = streetEdge.getFromVertex();
+    var toVertex = streetEdge.getToVertex();
+
+    boolean fromInZone = vertexInZone.computeIfAbsent(fromVertex, v ->
+      isVertexInZone(v.getCoordinate(), zoneBBox, preparedZone, reusablePoint)
+    );
+    boolean toInZone = vertexInZone.computeIfAbsent(toVertex, v ->
+      isVertexInZone(v.getCoordinate(), zoneBBox, preparedZone, reusablePoint)
+    );
+
+    if (fromInZone != toInZone) {
+      var ext = new GeofencingBoundaryExtension(zone, toInZone);
+      streetEdge.addGeofencingBoundary(ext);
+      // Also add to tov with opposite entering flag so that the pairing check
+      // in updateGeofencingZones works for all vertices, including permanent
+      // split vertices that may only be tov of boundary-crossing edges.
+      toVertex.addGeofencingBoundary(new GeofencingBoundaryExtension(zone, !toInZone));
+      edgesUpdated.put(streetEdge, ext);
+    }
+  }
+
   private static boolean isVertexInZone(
     Coordinate coord,
     Envelope zoneBBox,

street/src/main/java/org/opentripplanner/service/vehiclerental/street/GeofencingZoneIndex.java

@@ -35,15 +35,18 @@ public GeofencingZoneIndex(Collection<GeofencingZone> zones) {
   }
 
   /**
-   * Returns all zones whose geometry contains the given coordinate.
+   * Returns all zones whose geometry covers the given coordinate. Uses {@code covers()}
+   * (not {@code contains()}) to include points on the zone boundary, matching the semantics
+   * of {@link GeofencingZoneApplier#isVertexInZone} which uses {@code covers()} for
+   * boundary detection during graph building.
    */
   @SuppressWarnings("unchecked")
   public Set<GeofencingZone> getZonesContaining(Coordinate coord) {
     var point = GeometryUtils.getGeometryFactory().createPoint(coord);
     List<GeofencingZone> candidates = index.query(new Envelope(coord));
     return candidates
       .stream()
-      .filter(z -> preparedGeometries.get(z).contains(point))
+      .filter(z -> preparedGeometries.get(z).covers(point))
       .collect(Collectors.toSet());
   }
 }

street/src/main/java/org/opentripplanner/street/linking/VertexLinker.java

@@ -17,6 +17,8 @@
 import org.locationtech.jts.geom.LineString;
 import org.locationtech.jts.linearref.LinearLocation;
 import org.locationtech.jts.linearref.LocationIndexedLine;
+import org.opentripplanner.service.vehiclerental.model.GeofencingZone;
+import org.opentripplanner.service.vehiclerental.street.GeofencingBoundaryExtension;
 import org.opentripplanner.street.Scope;
 import org.opentripplanner.street.geometry.GeometryUtils;
 import org.opentripplanner.street.geometry.SphericalDistanceLibrary;
@@ -562,9 +564,38 @@ private SplitterVertex createSplitVertex(
         v.addBusinessAreaBorderNetwork(network);
       }
     }
-    for (var boundary : toVertex.getGeofencingBoundaries()) {
-      if (!v.getGeofencingBoundaries().contains(boundary)) {
-        v.addGeofencingBoundary(boundary);
+    // Compute geofencing boundaries spatially for the split vertex.
+    // The entering flag encodes position: outside=true, inside=false.
+    // Blind-copying from parent vertices would give the wrong flag when
+    // the split point is on the opposite side of the zone boundary.
+    var fromBoundaries = originalEdge.getFromVertex().getGeofencingBoundaries();
+    var toBoundaries = toVertex.getGeofencingBoundaries();
+    if (!fromBoundaries.isEmpty() || !toBoundaries.isEmpty()) {
+      var splitCoord = new Coordinate(x, y);
+      var containingZones = graph.getGeofencingZonesContaining(splitCoord);
+      var boundaryZones = new HashSet<GeofencingZone>();
+      for (var b : fromBoundaries) {
+        boundaryZones.add(b.zone());
+      }
+      for (var b : toBoundaries) {
+        boundaryZones.add(b.zone());
+      }
+      var fromVertex = originalEdge.getFromVertex();
+      for (var zone : boundaryZones) {
+        boolean splitInZone = containingZones.contains(zone);
+        v.addGeofencingBoundary(new GeofencingBoundaryExtension(zone, !splitInZone));
+
+        // If the split vertex is inside the zone but the parent edge's fromVertex
+        // has no boundary for this zone (e.g., a permanent SplitterVertex in a
+        // concave corner where all permanent neighbors are outside the zone),
+        // add the missing boundary to fromVertex. Without this, the pairing check
+        // in updateGeofencingZones would fail and the zone would never enter state.
+        if (splitInZone) {
+          boolean fromvHasBoundary = fromBoundaries.stream().anyMatch(b -> b.zone().equals(zone));
+          if (!fromvHasBoundary) {
+            fromVertex.addGeofencingBoundary(new GeofencingBoundaryExtension(zone, true));
+          }
+        }
       }
     }
 

street/src/main/java/org/opentripplanner/street/model/vertex/Vertex.java

@@ -358,15 +358,16 @@ public void removeAllBusinessAreaBorders() {
   }
 
   /**
-   * Copy all rental restriction data from another vertex to this one.
+   * Copy business area border data from another vertex to this one.
+   * Geofencing boundaries are NOT copied — they require spatial computation
+   * based on the vertex's actual position (see VertexLinker.createSplitVertex).
    */
   public void copyRentalRestrictionsFrom(Vertex other) {
     if (other.businessAreaBorder != null) {
       for (var network : other.businessAreaBorder.networks()) {
         addBusinessAreaBorderNetwork(network);
       }
     }
-    this.geofencingBoundaries = other.geofencingBoundaries;
   }
 
   /**

street/src/test/java/org/opentripplanner/service/vehiclerental/street/GeofencingZoneIndexTest.java

@@ -51,6 +51,19 @@ void pointOutsideAllZones() {
     assertTrue(zones.isEmpty());
   }
 
+  @Test
+  void pointOnZoneBoundaryIsIncluded() {
+    // A point exactly on the polygon boundary should be classified as inside,
+    // matching GeofencingZoneApplier.isVertexInZone which uses covers().
+    // Use the first vertex of the Oslo polygon (which is on its boundary).
+    var boundaryCoord = new Coordinate(10.62535658370308, 59.961055202323195);
+    var zones = index.getZonesContaining(boundaryCoord);
+    assertTrue(
+      zones.contains(oslo),
+      "Point on zone boundary should be included (covers semantics)"
+    );
+  }
+
   @Test
   void emptyIndex() {
     var emptyIndex = new GeofencingZoneIndex(List.of());

street/src/test/java/org/opentripplanner/street/linking/VertexLinkerGeofencingTest.java

@@ -0,0 +1,178 @@
+package org.opentripplanner.street.linking;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.opentripplanner.street.model.StreetModelFactory.intersectionVertex;
+import static org.opentripplanner.street.model.StreetModelFactory.streetEdge;
+
+import java.util.List;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Polygon;
+import org.opentripplanner.core.model.i18n.I18NString;
+import org.opentripplanner.core.model.id.FeedScopedId;
+import org.opentripplanner.service.vehiclerental.model.GeofencingZone;
+import org.opentripplanner.service.vehiclerental.street.GeofencingBoundaryExtension;
+import org.opentripplanner.service.vehiclerental.street.GeofencingZoneIndex;
+import org.opentripplanner.street.geometry.GeometryUtils;
+import org.opentripplanner.street.graph.Graph;
+import org.opentripplanner.street.model.StreetConstants;
+import org.opentripplanner.street.model.edge.TemporaryFreeEdge;
+import org.opentripplanner.street.model.vertex.SplitterVertex;
+import org.opentripplanner.street.model.vertex.StreetVertex;
+import org.opentripplanner.street.model.vertex.TemporaryStreetLocation;
+import org.opentripplanner.street.search.TraverseModeSet;
+
+/**
+ * Tests that split vertices on boundary-crossing edges get spatially correct
+ * geofencing boundary extensions instead of blind-copied ones from parent vertices.
+ */
+class VertexLinkerGeofencingTest {
+
+  // Zone polygon: a rectangle covering lon [10.70, 10.71], lat [59.92, 59.93]
+  private static final Polygon ZONE_POLYGON = GeometryUtils.getGeometryFactory().createPolygon(
+    new Coordinate[] {
+      new Coordinate(10.70, 59.92),
+      new Coordinate(10.71, 59.92),
+      new Coordinate(10.71, 59.93),
+      new Coordinate(10.70, 59.93),
+      new Coordinate(10.70, 59.92),
+    }
+  );
+
+  private static final GeofencingZone NO_DROP_OFF_ZONE = new GeofencingZone(
+    new FeedScopedId("tier", "park"),
+    null,
+    ZONE_POLYGON,
+    true,
+    false
+  );
+
+  // A is outside the zone (lon=10.695), B is inside (lon=10.705)
+  // Both at lat=59.925 (midpoint of zone's lat range)
+  private final StreetVertex vertexOutside = intersectionVertex("A", 59.925, 10.695);
+  private final StreetVertex vertexInside = intersectionVertex("B", 59.925, 10.705);
+
+  @Test
+  void splitVertexInsideZoneGetsEnteringFalse() {
+    // Split at a point inside the zone (lon=10.703, which is inside [10.70, 10.71])
+    var splitVertex = linkAndFindSplitVertex(59.925, 10.703);
+
+    var boundaries = splitVertex.getGeofencingBoundaries();
+    assertEquals(1, boundaries.size());
+    var boundary = boundaries.getFirst();
+    assertEquals(NO_DROP_OFF_ZONE, boundary.zone());
+    // Inside the zone → entering=false
+    assertEquals(false, boundary.entering());
+  }
+
+  @Test
+  void splitVertexOutsideZoneGetsEnteringTrue() {
+    // Split at a point outside the zone (lon=10.698, which is outside [10.70, 10.71])
+    var splitVertex = linkAndFindSplitVertex(59.925, 10.698);
+
+    var boundaries = splitVertex.getGeofencingBoundaries();
+    assertEquals(1, boundaries.size());
+    var boundary = boundaries.getFirst();
+    assertEquals(NO_DROP_OFF_ZONE, boundary.zone());
+    // Outside the zone → entering=true
+    assertEquals(true, boundary.entering());
+  }
+
+  @Test
+  void splitVertexOnNonBoundaryEdgeGetsNoBoundaries() {
+    // Two vertices both outside the zone
+    var v1 = intersectionVertex("C", 59.925, 10.690);
+    var v2 = intersectionVertex("D", 59.925, 10.695);
+    streetEdge(v1, v2);
+
+    var graph = new Graph();
+    graph.addVertex(v1);
+    graph.addVertex(v2);
+    registerZoneIndex(graph);
+    graph.index();
+
+    var linker = new VertexLinker(
+      graph,
+      VisibilityMode.COMPUTE_AREA_VISIBILITY_LINES,
+      StreetConstants.DEFAULT_MAX_AREA_NODES,
+      true
+    );
+
+    var split = new TemporaryStreetLocation(
+      new Coordinate(10.6925, 59.925),
+      I18NString.of("split")
+    );
+    var disposable = linker.linkVertexForRequest(
+      split,
+      TraverseModeSet.allModes(),
+      LinkingDirection.BIDIRECTIONAL,
+      (sv1, sv2) ->
+        List.of(TemporaryFreeEdge.createTemporaryFreeEdge((TemporaryStreetLocation) sv1, sv2))
+    );
+
+    // Find the split vertex
+    var splitterVertex = findSplitterVertex(split);
+    assertTrue(
+      splitterVertex.getGeofencingBoundaries().isEmpty(),
+      "Split vertex on non-boundary edge should have no geofencing boundaries"
+    );
+
+    disposable.disposeEdges();
+  }
+
+  private SplitterVertex linkAndFindSplitVertex(double lat, double lon) {
+    streetEdge(vertexOutside, vertexInside);
+
+    // Add boundary extensions to simulate what GeofencingZoneApplier does:
+    // A (outside) gets entering=true, B (inside) gets entering=false
+    vertexOutside.addGeofencingBoundary(new GeofencingBoundaryExtension(NO_DROP_OFF_ZONE, true));
+    vertexInside.addGeofencingBoundary(new GeofencingBoundaryExtension(NO_DROP_OFF_ZONE, false));
+
+    var graph = new Graph();
+    graph.addVertex(vertexOutside);
+    graph.addVertex(vertexInside);
+    registerZoneIndex(graph);
+    graph.index();
+
+    var linker = new VertexLinker(
+      graph,
+      VisibilityMode.COMPUTE_AREA_VISIBILITY_LINES,
+      StreetConstants.DEFAULT_MAX_AREA_NODES,
+      true
+    );
+
+    var split = new TemporaryStreetLocation(new Coordinate(lon, lat), I18NString.of("split"));
+    var disposable = linker.linkVertexForRequest(
+      split,
+      TraverseModeSet.allModes(),
+      LinkingDirection.BIDIRECTIONAL,
+      (v1, v2) ->
+        List.of(TemporaryFreeEdge.createTemporaryFreeEdge((TemporaryStreetLocation) v1, v2))
+    );
+
+    var splitterVertex = findSplitterVertex(split);
+    disposable.disposeEdges();
+    return splitterVertex;
+  }
+
+  private static SplitterVertex findSplitterVertex(TemporaryStreetLocation location) {
+    for (var edge : location.getOutgoing()) {
+      if (edge.getToVertex() instanceof SplitterVertex sv) {
+        return sv;
+      }
+    }
+    for (var edge : location.getIncoming()) {
+      if (edge.getFromVertex() instanceof SplitterVertex sv) {
+        return sv;
+      }
+    }
+    throw new AssertionError("No SplitterVertex found connected to the temporary location");
+  }
+
+  private static void registerZoneIndex(Graph graph) {
+    var index = new GeofencingZoneIndex(Set.of(NO_DROP_OFF_ZONE));
+    graph.setGeofencingZoneIndex("tier", index);
+  }
+}