Add support for direct routing with coordinate via locations

Author: optionsome

application/src/main/java/org/opentripplanner/routing/algorithm/RoutingWorker.java

@@ -23,8 +23,8 @@
 import org.opentripplanner.routing.algorithm.raptoradapter.router.AdditionalSearchDays;
 import org.opentripplanner.routing.algorithm.raptoradapter.router.FilterTransitWhenDirectModeIsEmpty;
 import org.opentripplanner.routing.algorithm.raptoradapter.router.TransitRouter;
-import org.opentripplanner.routing.algorithm.raptoradapter.router.street.DefaultDirectStreetRouter;
 import org.opentripplanner.routing.algorithm.raptoradapter.router.street.DirectFlexRouter;
+import org.opentripplanner.routing.algorithm.raptoradapter.router.street.DirectStreetRouterFactory;
 import org.opentripplanner.routing.api.request.RouteRequest;
 import org.opentripplanner.routing.api.request.StreetMode;
 import org.opentripplanner.routing.api.request.request.StreetRequest;
@@ -222,14 +222,6 @@ private Duration searchWindowUsed() {
   }
 
   private RoutingResult routeDirectStreet() {
-    // TODO: Add support for via search to the direct-street search and remove this.
-    //       The direct search is used to prune away silly transit results and it
-    //       would be nice to also support via as a feature in the direct-street
-    //       search.
-    if (request.isViaSearch()) {
-      return RoutingResult.empty();
-    }
-
     // If no direct mode is set, then we set one.
     // See {@link FilterTransitWhenDirectModeIsEmpty}
     var emptyDirectModeHandler = new FilterTransitWhenDirectModeIsEmpty(
@@ -244,7 +236,7 @@ private RoutingResult routeDirectStreet() {
 
     debugTimingAggregator.startedDirectStreetRouter();
     try {
-      var directRouter = new DefaultDirectStreetRouter();
+      var directRouter = DirectStreetRouterFactory.create(request);
       return RoutingResult.ok(
         directRouter
           .route(serverContext, directBuilder.buildRequest(), linkingContext())

application/src/main/java/org/opentripplanner/routing/algorithm/mapping/GraphPathToItineraryMapper.java

@@ -98,13 +98,14 @@ public static boolean isFloatingRentalDropoff(State state) {
   }
 
   /**
-   * Generates a TripPlan from a set of paths
+   * Generates a TripPlan from a set of paths. Each path generates a leg in the itinerary.
    */
+
   public Optional<Itinerary> mapToItinerary(
-    GraphPath<State, Edge, Vertex> path,
+    List<GraphPath<State, Edge, Vertex>> paths,
     RouteRequest request
   ) {
-    Itinerary itinerary = generateItinerary(path, request);
+    Itinerary itinerary = generateItinerary(paths, request);
     if (itinerary.legs().isEmpty()) {
       return Optional.empty();
     }
@@ -113,43 +114,74 @@ public Optional<Itinerary> mapToItinerary(
   }
 
   /**
-   * Generate an itinerary from a {@link GraphPath}. This method first slices the list of states at
-   * the leg boundaries. These smaller state arrays are then used to generate legs.
+   * Generates a TripPlan from a path.
+   */
+  public Optional<Itinerary> mapToItinerary(
+    GraphPath<State, Edge, Vertex> path,
+    RouteRequest request
+  ) {
+    return mapToItinerary(List.of(path), request);
+  }
+
+  /**
+   * Generate an itinerary from a list {@link GraphPath}s. Each path generates one more or more
+   * legs. This method first slices the list of states at the leg boundaries. These smaller state
+   * arrays are then used to generate legs.
    *
-   * @param path The graph path to base the itinerary on
+   * @param paths The graph paths to base the itinerary on
    * @return The generated itinerary
    */
-  public Itinerary generateItinerary(GraphPath<State, Edge, Vertex> path, RouteRequest request) {
+  public Itinerary generateItinerary(
+    List<GraphPath<State, Edge, Vertex>> paths,
+    RouteRequest request
+  ) {
     List<Leg> legs = new ArrayList<>();
-    WalkStep previousStep = null;
-    for (List<State> legStates : sliceStates(path.states)) {
-      if (OTPFeature.FlexRouting.isOn() && legStates.get(1).backEdge instanceof FlexTripEdge) {
-        legs.add(generateFlexLeg(legStates));
-        previousStep = null;
-        continue;
-      }
-      StreetLeg leg = generateLeg(legStates, previousStep, request);
-      legs.add(leg);
-
-      List<WalkStep> walkSteps = leg.listWalkSteps();
-      if (walkSteps.size() > 0) {
-        previousStep = walkSteps.get(walkSteps.size() - 1);
-      } else {
-        previousStep = null;
+    for (GraphPath<State, Edge, Vertex> path : paths) {
+      WalkStep previousStep = null;
+      for (List<State> legStates : sliceStates(path.states)) {
+        if (OTPFeature.FlexRouting.isOn() && legStates.get(1).backEdge instanceof FlexTripEdge) {
+          legs.add(generateFlexLeg(legStates));
+          previousStep = null;
+          continue;
+        }
+        StreetLeg leg = generateLeg(legStates, previousStep, request);
+        legs.add(leg);
+
+        List<WalkStep> walkSteps = leg.listWalkSteps();
+        if (walkSteps.size() > 0) {
+          previousStep = walkSteps.get(walkSteps.size() - 1);
+        } else {
+          previousStep = null;
+        }
       }
     }
 
-    State lastState = path.states.getLast();
-    var cost = Cost.costOfSeconds(lastState.weight);
+    var cost = Cost.costOfSeconds(
+      paths.stream().map(GraphPath::getWeight).reduce(0.0, Double::sum)
+    );
     var builder = Itinerary.ofDirect(legs).withGeneralizedCost(cost);
 
-    builder.withArrivedAtDestinationWithRentedVehicle(lastState.isRentingVehicleFromStation());
+    builder.withArrivedAtDestinationWithRentedVehicle(
+      paths.getLast().states.getLast().isRentingVehicleFromStation()
+    );
 
-    calculateElevations(builder, path.edges);
+    var allEdges = paths.stream().flatMap(p -> p.edges.stream()).toList();
+    calculateElevations(builder, allEdges);
 
     return builder.build();
   }
 
+  /**
+   * Generate an itinerary from a {@link GraphPath}. This method first slices the list of states at
+   * the leg boundaries. These smaller state arrays are then used to generate legs.
+   *
+   * @param path The graph path to base the itinerary on
+   * @return The generated itinerary
+   */
+  public Itinerary generateItinerary(GraphPath<State, Edge, Vertex> path, RouteRequest request) {
+    return generateItinerary(List.of(path), request);
+  }
+
   /**
    * Slice a {@link State} list at the leg boundaries.
    *

application/src/main/java/org/opentripplanner/routing/algorithm/raptoradapter/router/street/DefaultDirectStreetRouter.java

@@ -1,12 +1,12 @@
 package org.opentripplanner.routing.algorithm.raptoradapter.router.street;
 
+import java.util.List;
 import org.opentripplanner.astar.model.GraphPath;
 import org.opentripplanner.framework.geometry.SphericalDistanceLibrary;
 import org.opentripplanner.routing.api.request.RouteRequest;
 import org.opentripplanner.routing.api.request.StreetMode;
 import org.opentripplanner.routing.impl.GraphPathFinder;
 import org.opentripplanner.routing.linking.LinkingContext;
-import org.opentripplanner.standalone.api.OtpServerRequestContext;
 import org.opentripplanner.street.model.edge.Edge;
 import org.opentripplanner.street.model.vertex.Vertex;
 import org.opentripplanner.street.search.state.State;
@@ -17,26 +17,19 @@
  */
 public class DefaultDirectStreetRouter extends DirectStreetRouter {
 
-  GraphPath<State, Edge, Vertex> findPath(
-    OtpServerRequestContext serverContext,
+  List<GraphPath<State, Edge, Vertex>> findPaths(
+    GraphPathFinder graphPathFinder,
     LinkingContext linkingContext,
-    RouteRequest request,
-    float maxCarSpeed
+    RouteRequest request
   ) {
-    // we could also get a persistent router-scoped GraphPathFinder but there's no setup cost here
-    GraphPathFinder gpFinder = new GraphPathFinder(
-      serverContext.traverseVisitor(),
-      serverContext.listExtensionRequestContexts(request),
-      maxCarSpeed
-    );
-    return gpFinder.graphPathFinderEntryPoint(request, linkingContext);
+    return List.of(graphPathFinder.graphPathFinderEntryPoint(request, linkingContext));
   }
 
-  boolean isRequestValidForRouting(RouteRequest request) {
+  boolean isRequestInvalidForRouting(RouteRequest request) {
     return request.journey().direct().mode() == StreetMode.NOT_SET;
   }
 
-  boolean isStraightLineDistanceIsWithinLimit(
+  boolean isStraightLineDistanceWithinLimit(
     LinkingContext linkingContext,
     RouteRequest request,
     double maxDistanceLimit

application/src/main/java/org/opentripplanner/routing/algorithm/raptoradapter/router/street/DirectStreetRouter.java

@@ -1,5 +1,6 @@
 package org.opentripplanner.routing.algorithm.raptoradapter.router.street;
 
+import java.util.List;
 import java.util.Optional;
 import org.locationtech.jts.geom.Coordinate;
 import org.opentripplanner.astar.model.GraphPath;
@@ -12,6 +13,7 @@
 import org.opentripplanner.routing.api.request.StreetMode;
 import org.opentripplanner.routing.error.PathNotFoundException;
 import org.opentripplanner.routing.graphfinder.TransitServiceResolver;
+import org.opentripplanner.routing.impl.GraphPathFinder;
 import org.opentripplanner.routing.linking.LinkingContext;
 import org.opentripplanner.standalone.api.OtpServerRequestContext;
 import org.opentripplanner.street.model.edge.Edge;
@@ -33,20 +35,26 @@ public Optional<Itinerary> route(
     RouteRequest request,
     LinkingContext linkingContext
   ) {
-    if (isRequestValidForRouting(request)) {
+    if (isRequestInvalidForRouting(request)) {
       return Optional.empty();
     }
     OTPRequestTimeoutException.checkForTimeout();
 
     var maxCarSpeed = serverContext.streetLimitationParametersService().maxCarSpeed();
     var maxDistanceLimit = calculateDistanceMaxLimit(request, maxCarSpeed);
-    if (!isStraightLineDistanceIsWithinLimit(linkingContext, request, maxDistanceLimit)) {
+    if (!isStraightLineDistanceWithinLimit(linkingContext, request, maxDistanceLimit)) {
       return Optional.empty();
     }
 
     try {
-      var path = findPath(serverContext, linkingContext, request, maxCarSpeed);
-      return mapToItinerary(serverContext, request, path);
+      // we could also get a persistent router-scoped GraphPathFinder but there's no setup cost here
+      GraphPathFinder gpFinder = new GraphPathFinder(
+        serverContext.traverseVisitor(),
+        serverContext.listExtensionRequestContexts(request),
+        maxCarSpeed
+      );
+      var paths = findPaths(gpFinder, linkingContext, request);
+      return mapToItinerary(serverContext, request, paths);
     } catch (PathNotFoundException e) {
       return Optional.empty();
     }
@@ -55,26 +63,27 @@ public Optional<Itinerary> route(
   /**
    * Checks that the route request is configured to allow direct street results.
    */
-  abstract boolean isRequestValidForRouting(RouteRequest request);
+  abstract boolean isRequestInvalidForRouting(RouteRequest request);
 
   /**
    * Checks that as the crow flies distance between locations in the search are within the maximum
    * distance limit.
    */
-  abstract boolean isStraightLineDistanceIsWithinLimit(
+  abstract boolean isStraightLineDistanceWithinLimit(
     LinkingContext linkingContext,
     RouteRequest request,
     double maxDistanceLimit
   );
 
   /**
-   * Find a graph path between the locations in the request.
+   * Find an ordered set of graph paths between the locations in the request starting from the
+   * origin and ending in the destination. If there are no via locations, there is exactly one path.
+   * With via locations, there is one path between each location.
    */
-  abstract GraphPath<State, Edge, Vertex> findPath(
-    OtpServerRequestContext serverContext,
+  abstract List<GraphPath<State, Edge, Vertex>> findPaths(
+    GraphPathFinder graphPathFinder,
     LinkingContext linkingContext,
-    RouteRequest request,
-    float maxCarSpeed
+    RouteRequest request
   );
 
   static Coordinate getFirstCoordinateForLocation(
@@ -110,18 +119,21 @@ private static double calculateDistanceMaxLimit(RouteRequest request, float maxC
     throw new IllegalStateException("Could not set max limit for StreetMode");
   }
 
+  /**
+   * Creates an itinerary where one graph path generates one or more legs.
+   */
   private static Optional<Itinerary> mapToItinerary(
     OtpServerRequestContext serverContext,
     RouteRequest request,
-    GraphPath<State, Edge, Vertex> path
+    List<GraphPath<State, Edge, Vertex>> paths
   ) {
     final GraphPathToItineraryMapper graphPathToItineraryMapper = new GraphPathToItineraryMapper(
       new TransitServiceResolver(serverContext.transitService()),
       serverContext.transitService().getTimeZone(),
       serverContext.graph().streetNotesService,
       serverContext.graph().ellipsoidToGeoidDifference
     );
-    var response = graphPathToItineraryMapper.mapToItinerary(path, request);
+    var response = graphPathToItineraryMapper.mapToItinerary(paths, request);
     return response.map(itinerary ->
       ItinerariesHelper.decorateItineraryWithRequestData(
         itinerary,

application/src/main/java/org/opentripplanner/routing/algorithm/raptoradapter/router/street/DirectStreetRouterFactory.java

@@ -0,0 +1,17 @@
+package org.opentripplanner.routing.algorithm.raptoradapter.router.street;
+
+import org.opentripplanner.routing.api.request.RouteRequest;
+
+/**
+ * This factory encapsulates the logic for deciding which direct street router to use.
+ */
+public class DirectStreetRouterFactory {
+
+  /**
+   * @return {@link DefaultDirectStreetRouter} if there are no via locations, otherwise
+   * {@link ViaDirectStreetRouter}.
+   */
+  public static DirectStreetRouter create(RouteRequest request) {
+    return request.isViaSearch() ? new ViaDirectStreetRouter() : new DefaultDirectStreetRouter();
+  }
+}