Crosswalk naming

application/src/main/java/org/opentripplanner/graph_builder/module/osm/OsmModule.java

@@ -225,7 +225,7 @@ private void build(OsmDatabase osmdb, VertexGenerator vertexGenerator) {
 
     TurnRestrictionUnifier.unifyTurnRestrictions(osmdb, issueStore, osmInfoGraphBuildRepository);
 
-    params.edgeNamer().postprocess();
+    params.edgeNamer().finalizeNames();
 
     normalizer.applySafetyFactors();
   }
@@ -678,6 +678,7 @@ private StreetEdge getEdgeForStreet(
       .withCarSpeed(carSpeed)
       .withLink(way.isLink())
       .withRoundabout(way.isRoundabout())
+      .withCrossing(way.isCrossing())
       .withSlopeOverride(way.getOsmProvider().getWayPropertySet().getSlopeOverride(way))
       .withStairs(way.isSteps())
       .withWheelchairAccessible(way.isWheelchairAccessible())

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/AssignNameToEdge.java

@@ -0,0 +1,11 @@
+package org.opentripplanner.graph_builder.module.osm.naming;
+
+import org.locationtech.jts.geom.Geometry;
+
+/**
+ * Helper interface with method to assign a name to an edge.
+ */
+@FunctionalInterface
+interface AssignNameToEdge {
+  boolean assignNameToEdge(EdgeOnLevel crosswalkOnLevel, Geometry buffer);
+}

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/BufferedEdgeProcessor.java

@@ -0,0 +1,75 @@
+package org.opentripplanner.graph_builder.module.osm.naming;
+
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Envelope;
+import org.opentripplanner.utils.lang.DoubleUtils;
+import org.opentripplanner.utils.logging.ProgressTracker;
+import org.slf4j.Logger;
+
+/**
+ * Base class for namers that use a geo buffer to query geo features.
+ */
+class BufferedEdgeProcessor {
+
+  private final String type;
+  private final Logger logger;
+  private final int bufferMeters;
+  private final AssignNameToEdge assigner;
+
+  BufferedEdgeProcessor(int bufferMeters, String type, Logger logger, AssignNameToEdge assigner) {
+    this.type = type;
+    this.logger = logger;
+    this.bufferMeters = bufferMeters;
+    this.assigner = assigner;
+  }
+
+  public void applyNames(Collection<EdgeOnLevel> unnamedEdges) {
+    ProgressTracker progress = ProgressTracker.track(
+      String.format("Assigning names to %s", type),
+      500,
+      unnamedEdges.size()
+    );
+    PreciseBufferFactory preciseBufferFactory = new PreciseBufferFactory(
+      computeEnvelopeCenter(unnamedEdges),
+      bufferMeters
+    );
+
+    final AtomicInteger namesApplied = new AtomicInteger(0);
+    unnamedEdges
+      .parallelStream()
+      .forEach(edgeOnLevel -> {
+        var buffer = preciseBufferFactory.preciseBuffer(edgeOnLevel.edge().getGeometry());
+        if (assigner.assignNameToEdge(edgeOnLevel, buffer)) {
+          namesApplied.incrementAndGet();
+        }
+
+        // Keep lambda! A method-ref would cause incorrect class and line number to be logged
+        // noinspection Convert2MethodRef
+        progress.step(m -> logger.info(m));
+      });
+
+    logger.info(
+      "Assigned names to {} of {} {} ({}%)",
+      namesApplied.get(),
+      unnamedEdges.size(),
+      type,
+      DoubleUtils.roundTo2Decimals(((double) namesApplied.get() / unnamedEdges.size()) * 100)
+    );
+
+    logger.info(progress.completeMessage());
+  }
+
+  /**
+   * Compute the centroid of all sidewalk edges.
+   */
+  private static Coordinate computeEnvelopeCenter(Collection<EdgeOnLevel> edges) {
+    var envelope = new Envelope();
+    edges.forEach(e -> {
+      envelope.expandToInclude(e.edge().getFromVertex().getCoordinate());
+      envelope.expandToInclude(e.edge().getToVertex().getCoordinate());
+    });
+    return envelope.centre();
+  }
+}

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/CrosswalkNamer.java

@@ -0,0 +1,171 @@
+package org.opentripplanner.graph_builder.module.osm.naming;
+
+import gnu.trove.list.TLongList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import org.locationtech.jts.geom.Geometry;
+import org.opentripplanner.framework.i18n.I18NString;
+import org.opentripplanner.graph_builder.module.osm.OsmDatabase;
+import org.opentripplanner.graph_builder.module.osm.StreetEdgePair;
+import org.opentripplanner.graph_builder.services.osm.EdgeNamer;
+import org.opentripplanner.osm.model.OsmEntity;
+import org.opentripplanner.osm.model.OsmWay;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A namer that assigns names to crosswalks using the name or type of the crossed street.
+ * <p>
+ * The algorithm works as follows:
+ *  - For each crosswalk, we find the intersecting street edge that shares a node.
+ *  - Apply a name depending on the type of street:
+ *      * For named streets, name the crossing so it reads "crossing over 10th Street".
+ *      * For service roads (e.g. car access to commercial complexes, such as
+ *        <a href="https://www.openstreetmap.org/way/1024601318">...</a>),
+ *        use "crossing over service road".
+ *      * For turn lanes or slip lanes at intersections (shortcuts from a street to another,
+ *        to bypass traffic signals, prevalent in North America,
+ *        e.g. <a href="https://www.openstreetmap.org/way/1139062913">...</a>),
+ *        use "crossing over turn lane".
+ */
+public class CrosswalkNamer implements EdgeNamer {
+
+  private static final Logger LOG = LoggerFactory.getLogger(CrosswalkNamer.class);
+  private static final int BUFFER_METERS = 25;
+  private final BufferedEdgeProcessor processor; //=
+
+  private StreetEdgeIndex streetIndex = new StreetEdgeIndex();
+  private StreetEdgeIndex sidewalkIndex = new StreetEdgeIndex();
+  private Collection<EdgeOnLevel> unnamedCrosswalks = new ArrayList<>();
+
+  public CrosswalkNamer() {
+    processor = new BufferedEdgeProcessor(BUFFER_METERS, "crosswalks", LOG, this::assignNameToEdge);
+  }
+
+  @Override
+  public I18NString name(OsmEntity way) {
+    return way.getAssumedName();
+  }
+
+  @Override
+  public void recordEdges(OsmEntity way, StreetEdgePair pair, OsmDatabase osmdb) {
+    if (way instanceof OsmWay osmWay) {
+      // Record unnamed crossings to a list.
+      if (osmWay.isCrossing() && way.hasNoName() && !way.isExplicitlyUnnamed()) {
+        pair
+          .asIterable()
+          .forEach(edge -> unnamedCrosswalks.add(new EdgeOnLevel(osmWay, edge, Set.of())));
+      }
+      // Record (short) sidewalks to a geometric index
+      else if (way.isSidewalk()) {
+        sidewalkIndex.add(way, pair, Set.of(), BUFFER_METERS);
+      }
+      // Record named streets, service roads, and slip/turn lanes to a geometric index.
+      else if (
+        !osmWay.isFootway() && (way.isNamed() || osmWay.isServiceRoad() || osmWay.isTurnLane())
+      ) {
+        streetIndex.add(way, pair, Set.of());
+      }
+    }
+  }
+
+  @Override
+  public void finalizeNames() {
+    processor.applyNames(unnamedCrosswalks);
+
+    // Set the indices to null so they can be garbage-collected
+    streetIndex = null;
+    sidewalkIndex = null;
+    unnamedCrosswalks = null;
+  }
+
+  /**
+   * The actual logic for naming individual crosswalk edges.
+   * This will also name adjacent sidewalks on each end if they are the only adjacent sidewalks to a crosswalk.
+   */
+  public boolean assignNameToEdge(EdgeOnLevel crosswalkOnLevel, Geometry buffer) {
+    var crosswalk = crosswalkOnLevel.edge();
+    OsmWay way = crosswalkOnLevel.way();
+
+    var streetCandidates = streetIndex.query(buffer).stream().map(EdgeOnLevel::way).toList();
+
+    var crossStreetOpt = getIntersectingStreet(way, streetCandidates);
+    if (crossStreetOpt.isPresent()) {
+      OsmWay crossStreet = crossStreetOpt.get();
+      // TODO: i18n
+      if (crossStreet.isNamed()) {
+        crosswalk.setName(
+          I18NString.of(String.format("crossing over %s", crossStreet.getAssumedName()))
+        );
+      } else if (crossStreet.isServiceRoad()) {
+        crosswalk.setName(I18NString.of("crossing over service road"));
+      } else if (crossStreet.isMotorwayRamp()) {
+        crosswalk.setName(I18NString.of("crossing over freeway ramp"));
+      } else if (crossStreet.isTurnLane()) {
+        crosswalk.setName(I18NString.of("crossing over turn lane"));
+      } else {
+        // Default on using the OSM way ID, which should not happen.
+        crosswalk.setName(I18NString.of(String.format("crossing %s", way.getId())));
+      }
+
+      var adjacentSidewalks = sidewalkIndex
+        .query(buffer)
+        .stream()
+        .filter(e -> e.way().isAdjacentTo(way))
+        .filter(e -> e.edge().nameIsDerived())
+        .toList();
+
+      // Group sidewalks at each end of the crosswalk.
+      TLongList nodes = way.getNodeRefs();
+      renameAdjacentSidewalk(adjacentSidewalks, crosswalk.getName(), nodes.get(0));
+      renameAdjacentSidewalk(adjacentSidewalks, crosswalk.getName(), nodes.get(nodes.size() - 1));
+
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Rename a sidewalk, among candidates, if it is the only adjacent sidewalk to the given crosswalk.
+   */
+  private void renameAdjacentSidewalk(
+    List<EdgeOnLevel> adjacentSidewalks,
+    I18NString crosswalkName,
+    long nodeId
+  ) {
+    List<EdgeOnLevel> sidewalks = adjacentSidewalks
+      .stream()
+      .filter(e -> e.way().getNodeRefs().contains(nodeId))
+      .toList();
+    if (sidewalks.size() == 1) {
+      sidewalks.getFirst().edge().setName(crosswalkName);
+    }
+  }
+
+  /**
+   * Gets the intersecting street, if any, for the given way and candidate streets.
+   */
+  public static Optional<OsmWay> getIntersectingStreet(OsmWay way, Collection<OsmWay> streets) {
+    TLongList nodeRefs = way.getNodeRefs();
+    if (nodeRefs.size() >= 3) {
+      // There needs to be at least three nodes: 2 extremities that are on the sidewalk,
+      // and one somewhere in the middle that joins the crossing with the street.
+      // We exclude the first and last node which are on the sidewalk.
+      long[] nodeRefsArray = nodeRefs.toArray(1, nodeRefs.size() - 2);
+      return streets
+        .stream()
+        .filter(w -> Arrays.stream(nodeRefsArray).anyMatch(nid -> w.getNodeRefs().contains(nid)))
+        .findFirst();
+    }
+    return Optional.empty();
+  }
+
+  Collection<EdgeOnLevel> getUnnamedCrosswalks() {
+    return unnamedCrosswalks;
+  }
+}

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/DefaultNamer.java

@@ -17,5 +17,5 @@ public I18NString name(OsmEntity way) {
   public void recordEdges(OsmEntity way, StreetEdgePair edge, OsmDatabase osmdb) {}
 
   @Override
-  public void postprocess() {}
+  public void finalizeNames() {}
 }

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/EdgeOnLevel.java

@@ -0,0 +1,8 @@
+package org.opentripplanner.graph_builder.module.osm.naming;
+
+import java.util.Set;
+import org.opentripplanner.osm.model.OsmLevel;
+import org.opentripplanner.osm.model.OsmWay;
+import org.opentripplanner.street.model.edge.StreetEdge;
+
+public record EdgeOnLevel(OsmWay way, StreetEdge edge, Set<OsmLevel> levels) {}

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/PortlandCustomNamer.java

@@ -97,7 +97,7 @@ public void recordEdges(OsmEntity way, StreetEdgePair edgePair, OsmDatabase osmd
   }
 
   @Override
-  public void postprocess() {
+  public void finalizeNames() {
     for (StreetEdge e : nameByOrigin) {
       nameAccordingToOrigin(e, 15);
     }

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/PreciseBufferFactory.java

@@ -0,0 +1,56 @@
+package org.opentripplanner.graph_builder.module.osm.naming;
+
+import org.geotools.api.referencing.FactoryException;
+import org.geotools.api.referencing.crs.CoordinateReferenceSystem;
+import org.geotools.api.referencing.operation.MathTransform;
+import org.geotools.api.referencing.operation.TransformException;
+import org.geotools.geometry.jts.JTS;
+import org.geotools.referencing.CRS;
+import org.geotools.referencing.crs.DefaultGeographicCRS;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.operation.buffer.BufferParameters;
+
+/**
+ * A class to cache the expensive construction of a Universal Traverse Mercator coordinate reference
+ * system. Re-using the same CRS for all edges might introduce tiny imprecisions for OTPs use cases
+ * but speeds up the processing enormously and is a price well worth paying.
+ */
+final class PreciseBufferFactory {
+
+  private final double distanceInMeters;
+  private final MathTransform toTransform;
+  private final MathTransform fromTransform;
+
+  PreciseBufferFactory(Coordinate coordinate, double distanceInMeters) {
+    this.distanceInMeters = distanceInMeters;
+    String code = "AUTO:42001,%s,%s".formatted(coordinate.x, coordinate.y);
+    try {
+      CoordinateReferenceSystem auto = CRS.decode(code);
+      this.toTransform = CRS.findMathTransform(DefaultGeographicCRS.WGS84, auto);
+      this.fromTransform = CRS.findMathTransform(auto, DefaultGeographicCRS.WGS84);
+    } catch (FactoryException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Add a buffer around a geometry that makes sure that the buffer is the same distance (in meters)
+   * anywhere on earth.
+   * <p>
+   * Background: If you call the regular buffer() method on a JTS geometry that uses WGS84 as the
+   * coordinate reference system, the buffer will be accurate at the equator but will become more
+   * and more elongated the farther north/south you go.
+   * <p>
+   * Taken from https://stackoverflow.com/questions/36455020
+   */
+  Geometry preciseBuffer(Geometry geometry) {
+    try {
+      Geometry pGeom = JTS.transform(geometry, toTransform);
+      Geometry pBufferedGeom = pGeom.buffer(distanceInMeters, 4, BufferParameters.CAP_FLAT);
+      return JTS.transform(pBufferedGeom, fromTransform);
+    } catch (TransformException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}

application/src/main/java/org/opentripplanner/graph_builder/module/osm/naming/SidewalkCrosswalkNamer.java

@@ -0,0 +1,33 @@
+package org.opentripplanner.graph_builder.module.osm.naming;
+
+import org.opentripplanner.framework.i18n.I18NString;
+import org.opentripplanner.graph_builder.module.osm.OsmDatabase;
+import org.opentripplanner.graph_builder.module.osm.StreetEdgePair;
+import org.opentripplanner.graph_builder.services.osm.EdgeNamer;
+import org.opentripplanner.osm.model.OsmEntity;
+
+/**
+ * Combines the sidewalk and crosswalk namer.
+ */
+public class SidewalkCrosswalkNamer implements EdgeNamer {
+
+  private final SidewalkNamer sidewalkNamer = new SidewalkNamer();
+  private final CrosswalkNamer crosswalkNamer = new CrosswalkNamer();
+
+  @Override
+  public I18NString name(OsmEntity way) {
+    return way.getAssumedName();
+  }
+
+  @Override
+  public void recordEdges(OsmEntity way, StreetEdgePair pair, OsmDatabase osmdb) {
+    sidewalkNamer.recordEdges(way, pair, osmdb);
+    crosswalkNamer.recordEdges(way, pair, osmdb);
+  }
+
+  @Override
+  public void finalizeNames() {
+    sidewalkNamer.finalizeNames();
+    crosswalkNamer.finalizeNames();
+  }
+}