perf(street): reuse the prepared area index for the point-in-area test

The vertex-in-area check in snapAndLink used a raw Polygon.contains(point),
which rebuilds a sweep-line index over the polygon boundary on every call,
while addAreaVertex separately built a PreparedGeometry for the visibility
fan-out. Build one PreparedAreaGroup per area and reuse it for the point
test, the forced split-point edge and the fan-out, so the index is built
once. Add PreparedAreaGroup.containsPoint and pass the prepared group into
addAreaVertex instead of rebuilding it there.

Behavior is unchanged (PreparedGeometry.contains matches Geometry.contains
for points and segments).

Author: vpaturet

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

@@ -54,10 +54,24 @@ AreaGroup areaGroup() {
    * indexed {@link #areasCrossedBy} crossing test on this same group.
    */
   boolean containsSegment(Coordinate from, Coordinate to) {
+    return preparedGroup().contains(createShrunkLine(from, to));
+  }
+
+  /**
+   * Whether the area group polygon contains the given point. Reuses the same lazily built prepared
+   * index as {@link #containsSegment}, so the point-in-area test and the per-candidate segment tests
+   * share a single index build instead of each rebuilding a sweep-line index over the polygon
+   * boundary.
+   */
+  boolean containsPoint(Coordinate point) {
+    return preparedGroup().contains(GEOMETRY_FACTORY.createPoint(point));
+  }
+
+  private PreparedGeometry preparedGroup() {
     if (preparedGroup == null) {
       preparedGroup = PreparedGeometryFactory.prepare(areaGroup.getGeometry());
     }
-    return preparedGroup.contains(createShrunkLine(from, to));
+    return preparedGroup;
   }
 
   /**

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

@@ -442,10 +442,13 @@ private StreetVertex snapAndLink(
       edge instanceof AreaEdge aEdge
     ) {
       AreaGroup ag = aEdge.getArea();
+      // Prepared once and reused for the point-in-area test, the forced split-point edge and the
+      // visibility fan-out below, so the area's spatial index is built a single time.
+      var area = new PreparedAreaGroup(ag);
       // is area already linked ?
       start = linkedAreas.get(ag);
       if (start == null) {
-        if (ag.getGeometry().contains(GEOMETRY_FACTORY.createPoint(vertex.getCoordinate()))) {
+        if (area.containsPoint(vertex.getCoordinate())) {
           // vertex is inside an area
           if (distSquared(vertex, split) <= DUPLICATE_NODE_EPSILON_DEGREES_SQUARED) {
             // vertex is so close to the edge that we can use the split point directly
@@ -464,14 +467,14 @@ private StreetVertex snapAndLink(
         // vertex is inside the area. try connecting the vertex to the edge's split point, because
         // connections to visibility vertices may fail or do not always provide an optimal route
         // note that by definition, connection to closest edge cannot be blocked and edge can be forced
-        addVisibilityEdges(start, split, new PreparedAreaGroup(ag), scope, tempEdges, true);
+        addVisibilityEdges(start, split, area, scope, tempEdges, true);
       } else {
         // vertex is outside an area. Use split point for area connections
         start = split;
       }
       // connect start point to area visibility points to achieve optimal paths
       if (!ag.visibilityVertices().contains(start)) {
-        addAreaVertex(start, ag, scope, tempEdges, false);
+        addAreaVertex(start, area, scope, tempEdges, false);
       }
     } else {
       start = split;
@@ -652,7 +655,7 @@ public boolean equals(Object o) {
    * Link a new vertex permanently with area geometry
    */
   public boolean addPermanentAreaVertex(IntersectionVertex newVertex, AreaGroup areaGroup) {
-    return addAreaVertex(newVertex, areaGroup, Scope.PERMANENT, null, true);
+    return addAreaVertex(newVertex, new PreparedAreaGroup(areaGroup), Scope.PERMANENT, null, true);
   }
 
   /**
@@ -672,14 +675,13 @@ private double distSquared(Vertex a, Vertex b) {
    */
   private boolean addAreaVertex(
     IntersectionVertex newVertex,
-    AreaGroup areaGroup,
+    PreparedAreaGroup area,
     Scope scope,
     DisposableEdgeCollection tempEdges,
     boolean force
   ) {
+    AreaGroup areaGroup = area.areaGroup();
     Geometry polygon = areaGroup.getGeometry();
-    // Reused across all candidate contains() checks below so the spatial index is built only once.
-    var area = new PreparedAreaGroup(areaGroup);
 
     int added = 0;
 

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

@@ -50,6 +50,22 @@ void doesNotContainExteriorSegment() {
     assertFalse(area.containsSegment(new Coordinate(11, 11), new Coordinate(12, 12)));
   }
 
+  @Test
+  void containsInteriorPoint() {
+    assertTrue(area.containsPoint(new Coordinate(1, 1)));
+  }
+
+  @Test
+  void doesNotContainPointInHole() {
+    // The 2x2 hole is centred at x,y in (4,6); a point in its middle is not inside the area.
+    assertFalse(area.containsPoint(new Coordinate(5, 5)));
+  }
+
+  @Test
+  void doesNotContainExteriorPoint() {
+    assertFalse(area.containsPoint(new Coordinate(11, 11)));
+  }
+
   @Test
   void exposesWrappedAreaGroup() {
     var ag = new AreaGroup(SQUARE_WITH_HOLE);