G-MAP mobility profile-based routing [Review only - DO NOT MERGE]

src/ext/java/org/opentripplanner/ext/mobilityprofile/MobilityProfile.java

@@ -0,0 +1,49 @@
+package org.opentripplanner.ext.mobilityprofile;
+
+/**
+ * Enumeration for the mobility profiles, and their associated column names for CSV parsing.
+ */
+public enum MobilityProfile {
+  NONE("None"),
+  SOME("Some"),
+  DEVICE("Device"),
+  WCHAIRM("WChairM"),
+  WCHAIRE("WChairE"),
+  MSCOOTER("MScooter"),
+  VISION("Vision"),
+  VISIONPLUS("Vision+"),
+  SOME_VISION("Some-Vision"),
+  DEVICE_VISION("Device-Vision"),
+  WCHAIRM_VISION("WChairM-Vision"),
+  WCHAIRE_VISION("WChairE-Vision"),
+  MSCOOTER_VISION("MScooter-Vision"),
+  SOME_VISIONPLUS("Some-Vision+"),
+  DEVICE_VISIONPLUS("Device-Vision+"),
+  WCHAIRM_VISIONPLUS("WChairM-Vision+"),
+  WCHAIRE_VISIONPLUS("WChairE-Vision+"),
+  MSCOOTER_VISIONPLUS("MScooter-Vision+");
+
+  private final String text;
+
+  MobilityProfile(String text) {
+    this.text = text;
+  }
+
+  public String getText() {
+    return text;
+  }
+
+  @Override
+  public String toString() {
+    return text;
+  }
+
+  public static MobilityProfile fromString(String value) {
+    for (MobilityProfile p : MobilityProfile.values()) {
+      if (p.text.equals(value)) {
+        return p;
+      }
+    }
+    throw new RuntimeException(String.format("Invalid mobility profile '%s'", value));
+  }
+}

src/ext/java/org/opentripplanner/ext/mobilityprofile/MobilityProfileParser.java

@@ -0,0 +1,72 @@
+package org.opentripplanner.ext.mobilityprofile;
+
+import com.csvreader.CsvReader;
+import com.google.common.collect.ImmutableTable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.EnumMap;
+import java.util.Map;
+import org.opentripplanner.street.model.vertex.VertexLabel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Helper class that processes CSV files containing profile-based OSM costs.
+ */
+public class MobilityProfileParser {
+
+  private static final Logger LOG = LoggerFactory.getLogger(MobilityProfileParser.class);
+
+  private MobilityProfileParser() {}
+
+  /**
+   * Process rows from the given CSV stream and build a table indexed by both the
+   * upstream/downstream nodes, where each value is a map of costs by mobility profile.
+   */
+  public static ImmutableTable<String, String, Map<MobilityProfile, Float>> parseData(InputStream is) {
+    try {
+      var reader = new CsvReader(is, StandardCharsets.UTF_8);
+      reader.setDelimiter(',');
+      reader.readHeaders();
+
+      ImmutableTable.Builder<String, String, Map<MobilityProfile, Float>> tableBuilder = ImmutableTable.builder();
+      int lineNumber = 1;
+      while (reader.readRecord()) {
+        parseRow(lineNumber, reader, tableBuilder);
+        lineNumber++;
+      }
+
+      return tableBuilder.build();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static void parseRow(
+    int lineNumber,
+    CsvReader reader,
+    ImmutableTable.Builder<String, String, Map<MobilityProfile, Float>> tableBuilder
+  ) throws IOException {
+    try {
+      long fromNode = Long.parseLong(reader.get("Upstream Node"), 10);
+      long toNode = Long.parseLong(reader.get("Downstream Node"), 10);
+
+      var weightMap = new EnumMap<MobilityProfile, Float>(MobilityProfile.class);
+      for (var profile : MobilityProfile.values()) {
+        weightMap.put(profile, Float.parseFloat(reader.get(profile.getText())));
+      }
+
+      tableBuilder.put(
+        VertexLabel.osm(fromNode).toString(),
+        VertexLabel.osm(toNode).toString(),
+        weightMap
+      );
+    } catch (NumberFormatException | NullPointerException e) {
+      LOG.warn(
+        "Skipping mobility profile data at line {}: missing/invalid data",
+        lineNumber
+      );
+    }
+  }
+}

src/main/java/org/opentripplanner/apis/gtfs/mapping/RouteRequestMapper.java

@@ -57,6 +57,7 @@ public static RouteRequest toRouteRequest(
       context.transitService().getTimeZone()
     );
 
+    callWith.argument("wheelchair", request::setWheelchair);
     callWith.argument("wheelchair", request::setWheelchair);
     callWith.argument("numItineraries", request::setNumItineraries);
     callWith.argument("searchWindow", (Long m) -> request.setSearchWindow(Duration.ofSeconds(m)));
@@ -251,6 +252,7 @@ public static RouteRequest toRouteRequest(
       "locale",
       (String v) -> request.setLocale(GraphQLUtils.getLocale(environment, v))
     );
+    callWith.argument("mobilityProfile", request::setMobilityProfileFromString);
     return request;
   }
 

src/main/java/org/opentripplanner/graph_builder/GraphBuilder.java

@@ -5,11 +5,15 @@
 import static org.opentripplanner.datastore.api.FileType.OSM;
 
 import jakarta.inject.Inject;
+import java.io.IOException;
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import org.opentripplanner.datastore.api.DataSource;
+import org.opentripplanner.ext.mobilityprofile.MobilityProfileParser;
 import org.opentripplanner.ext.emissions.EmissionsDataModel;
 import org.opentripplanner.ext.stopconsolidation.StopConsolidationRepository;
 import org.opentripplanner.framework.application.OTPFeature;
@@ -20,6 +24,7 @@
 import org.opentripplanner.graph_builder.issue.api.DataImportIssueSummary;
 import org.opentripplanner.graph_builder.model.GraphBuilderModule;
 import org.opentripplanner.graph_builder.module.configure.DaggerGraphBuilderFactory;
+import org.opentripplanner.graph_builder.module.osm.OsmModule;
 import org.opentripplanner.routing.graph.Graph;
 import org.opentripplanner.service.worldenvelope.WorldEnvelopeRepository;
 import org.opentripplanner.standalone.config.BuildConfig;
@@ -96,7 +101,17 @@ public static GraphBuilder create(
     graphBuilder.hasTransitData = hasTransitData;
 
     if (hasOsm) {
-      graphBuilder.addModule(factory.osmModule());
+      Optional<DataSource> mobilityDataSource = dataSources.mobilityProfileDataSource();
+      OsmModule osmModule = factory.osmModule();
+      if (mobilityDataSource.isPresent()) {
+        // Parse stuff from the mobility profile CSV
+        try (var inputStream = mobilityDataSource.get().asInputStream()) {
+          osmModule.setMobilityProfileData(MobilityProfileParser.parseData(inputStream));
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+      graphBuilder.addModule(osmModule);
     }
 
     if (hasGtfs) {

src/main/java/org/opentripplanner/graph_builder/GraphBuilderDataSources.java

@@ -195,6 +195,18 @@ public Optional<DataSource> stopConsolidationDataSource() {
       });
   }
 
+  /**
+   * Returns the optional data source for the mobility profile routing costs.
+   */
+  public Optional<DataSource> mobilityProfileDataSource() {
+    return Optional
+      .ofNullable(buildConfig.mobilityProfileFile)
+      .map(fileName -> {
+        var f = baseDirectory.toPath().resolve(fileName).toFile();
+        return new FileDataSource(f, FileType.CONFIG);
+      });
+  }
+
   /**
    * Match the URI provided in the configuration with the URI of a datasource,
    * either by comparing directly the two URIs or by first prepending the OTP base directory

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

@@ -1,5 +1,6 @@
 package org.opentripplanner.graph_builder.module.osm;
 
+import com.google.common.collect.ImmutableTable;
 import com.google.common.collect.Iterables;
 import gnu.trove.iterator.TLongIterator;
 import java.util.ArrayList;
@@ -10,6 +11,7 @@
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.LineString;
+import org.opentripplanner.ext.mobilityprofile.MobilityProfile;
 import org.opentripplanner.framework.geometry.GeometryUtils;
 import org.opentripplanner.framework.geometry.SphericalDistanceLibrary;
 import org.opentripplanner.framework.i18n.I18NString;
@@ -55,6 +57,8 @@ public class OsmModule implements GraphBuilderModule {
   private final SafetyValueNormalizer normalizer;
   private final VertexGenerator vertexGenerator;
   private final OsmDatabase osmdb;
+  private ImmutableTable<String, String, Map<MobilityProfile, Float>> mobilityProfileData;
+  private HashMap<String, Boolean> mappedMobilityProfileEntries;
 
   OsmModule(
     Collection<OsmProvider> providers,
@@ -107,6 +111,10 @@ public Map<Vertex, Double> elevationDataOutput() {
     return elevationData;
   }
 
+  public void setMobilityProfileData(ImmutableTable<String, String, Map<MobilityProfile, Float>> mobilityProfileData) {
+    this.mobilityProfileData = mobilityProfileData;
+  }
+
   private record StreetEdgePair(StreetEdge main, StreetEdge back) {}
 
   private void build() {
@@ -142,6 +150,8 @@ private void build() {
     // figure out which nodes that are actually intersections
     vertexGenerator.initIntersectionNodes();
 
+    mappedMobilityProfileEntries = new HashMap<>();
+
     buildBasicGraph();
     buildWalkableAreas(!params.areaVisibility());
     validateBarriers();
@@ -171,6 +181,31 @@ private void build() {
     params.edgeNamer().postprocess();
 
     normalizer.applySafetyFactors();
+
+    listUnusedMobilityCosts();
+  }
+
+  /**
+   * Lists unused entries from the mobility profile data.
+   */
+  private void listUnusedMobilityCosts() {
+    var unusedEntries = new ArrayList<String>();
+
+    for (var cell : mobilityProfileData.cellSet()) {
+      String key = getNodeKey(cell.getRowKey(), cell.getColumnKey());
+      Boolean exists = mappedMobilityProfileEntries.get(key);
+      if (exists == null || !exists) {
+        unusedEntries.add(key);
+      }
+    }
+
+    if (!unusedEntries.isEmpty()) {
+      StringBuilder sb = new StringBuilder();
+      for (var entry : unusedEntries) {
+        sb.append(String.format("%n- %s", entry));
+      }
+      LOG.warn("{} mobility profile entries were not used:{}", unusedEntries.size(), sb);
+    }
   }
 
   /**
@@ -537,6 +572,24 @@ private StreetEdge getEdgeForStreet(
       .withStairs(way.isSteps())
       .withWheelchairAccessible(way.isWheelchairAccessible());
 
+    // Lookup costs by mobility profile, if any were defined.
+    String startId = startEndpoint.getLabel().toString();
+    String endId = endEndpoint.getLabel().toString();
+    var edgeMobilityCostMap = mobilityProfileData.get(
+      startId,
+      endId
+    );
+    if (edgeMobilityCostMap != null) {
+      seb.withProfileCosts(edgeMobilityCostMap);
+      LOG.info(
+        "Applied mobility profile costs between nodes {}-{}",
+        startId,
+        endId
+      );
+      // Keep tab of node pairs for which mobility profile costs have been mapped.
+      mappedMobilityProfileEntries.put(getNodeKey(startId, endId), true);
+    }
+
     if (!way.hasTag("name") && !way.hasTag("ref")) {
       seb.withBogusName(true);
     }
@@ -551,4 +604,8 @@ private StreetEdge getEdgeForStreet(
 
     return street;
   }
+
+  private static String getNodeKey(String startId, String endId) {
+    return String.format("%s=>%s", startId, endId);
+  }
 }

src/main/java/org/opentripplanner/routing/api/request/RouteRequest.java

@@ -13,6 +13,7 @@
 import java.util.Locale;
 import java.util.function.Consumer;
 import javax.annotation.Nullable;
+import org.opentripplanner.ext.mobilityprofile.MobilityProfile;
 import org.opentripplanner.framework.collection.ListSection;
 import org.opentripplanner.framework.time.DateUtils;
 import org.opentripplanner.framework.tostring.ToStringBuilder;
@@ -81,6 +82,8 @@ public class RouteRequest implements Cloneable, Serializable {
 
   private boolean wheelchair = false;
 
+  private MobilityProfile mobilityProfile;
+
   /* CONSTRUCTORS */
 
   /** Constructor for options; modes defaults to walk and transit */
@@ -127,6 +130,21 @@ public void setWheelchair(boolean wheelchair) {
     this.wheelchair = wheelchair;
   }
 
+  /**
+   * Applicable mobility profile for street routing
+   */
+  public MobilityProfile mobilityProfile() {
+    return mobilityProfile;
+  }
+
+  public void setMobilityProfile(MobilityProfile profile) {
+    this.mobilityProfile = profile;
+  }
+
+  public void setMobilityProfileFromString(String profile) {
+    this.mobilityProfile = MobilityProfile.fromString(profile);
+  }
+
   /**
    * The epoch date/time in seconds that the trip should depart (or arrive, for requests where
    * arriveBy is true)

src/main/java/org/opentripplanner/standalone/config/BuildConfig.java

@@ -183,6 +183,7 @@ public class BuildConfig implements OtpDataStoreConfig {
   public final ZoneId transitModelTimeZone;
 
   public final String stopConsolidationFile;
+  public final String mobilityProfileFile;
 
   /**
    * Set all parameters from the given Jackson JSON tree, applying defaults. Supplying
@@ -611,6 +612,15 @@ that we support remote input files (cloud storage or arbitrary URLs) not all dat
         )
         .asString(null);
 
+    mobilityProfileFile =
+      root
+        .of("mobilityProfileFile")
+        .since(V2_5)
+        .summary(
+          "Name of the CSV-formatted file in the build directory which contains the routing costs by mobility profile."
+        )
+        .asString(null);
+
     osmDefaults = OsmConfig.mapOsmDefaults(root, "osmDefaults");
     osm = OsmConfig.mapOsmConfig(root, "osm", osmDefaults);
     demDefaults = DemConfig.mapDemDefaultsConfig(root, "demDefaults");