Direct transit search

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

@@ -32,6 +32,7 @@
 import org.opentripplanner.routing.algorithm.raptoradapter.transit.RoutingAccessEgress;
 import org.opentripplanner.routing.algorithm.raptoradapter.transit.TripSchedule;
 import org.opentripplanner.routing.algorithm.raptoradapter.transit.mappers.AccessEgressMapper;
+import org.opentripplanner.routing.algorithm.raptoradapter.transit.mappers.DirectTransitRequestMapper;
 import org.opentripplanner.routing.algorithm.raptoradapter.transit.mappers.RaptorRequestMapper;
 import org.opentripplanner.routing.algorithm.raptoradapter.transit.request.DefaultTransitDataProviderFilter;
 import org.opentripplanner.routing.algorithm.raptoradapter.transit.request.RaptorRoutingRequestTransitData;
@@ -136,7 +137,8 @@ private TransitRouterResult route() {
     );
 
     // Prepare transit search
-    var raptorRequest = RaptorRequestMapper.<TripSchedule>mapRequest(
+
+    var mapper = RaptorRequestMapper.<TripSchedule>of(
       request,
       transitSearchTimeZero,
       serverContext.raptorConfig().isMultiThreaded(),
@@ -147,8 +149,9 @@ private TransitRouterResult route() {
       this::listStopIndexes,
       linkingContext
     );
+    var raptorRequest = mapper.mapRaptorRequest();
 
-    // Route transit
+    // Transit routing using Raptor
     var raptorService = new RaptorService<>(
       serverContext.raptorConfig(),
       createExtraMcRouterSearch(accessEgresses, raptorTransitData)
@@ -157,9 +160,26 @@ private TransitRouterResult route() {
 
     checkIfTransitConnectionExists(transitResponse);
 
+    Collection<RaptorPath<TripSchedule>> paths = transitResponse.paths();
+
     debugTimingAggregator.finishedRaptorSearch();
 
-    Collection<RaptorPath<TripSchedule>> paths = transitResponse.paths();
+    // Route Direct transit
+    var directRequest = DirectTransitRequestMapper.map(
+      request,
+      transitResponse.requestUsed().searchParams()
+    );
+    if (directRequest.isPresent()) {
+      debugTimingAggregator.startedDirectTransitSearch();
+      var directPaths = raptorService.findAllDirectTransit(
+        directRequest.get(),
+        requestTransitDataProvider
+      );
+      paths = new ArrayList<>(paths);
+      paths.addAll(directPaths);
+      debugTimingAggregator.finishedDirectTransitSearch();
+    }
+    debugTimingAggregator.startedItineraryCreation();
 
     // TODO VIA - Temporarily turn OptimizeTransfers OFF for VIA search until the service support via
     //            Remove '&& !request.isViaSearch()'
@@ -179,7 +199,7 @@ private TransitRouterResult route() {
         request.preferences().transfer().optimization(),
         raptorRequest.searchParams().viaLocations()
       );
-      paths = service.optimize(transitResponse.paths());
+      paths = service.optimize(paths);
     }
 
     // Create itineraries

application/src/main/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/AccessEgressWithExtraCost.java

@@ -0,0 +1,22 @@
+package org.opentripplanner.routing.algorithm.raptoradapter.transit;
+
+import org.opentripplanner.raptor.api.model.AbstractAccessEgressDecorator;
+import org.opentripplanner.raptor.api.model.RaptorAccessEgress;
+
+/**
+ * This decorator will add an extra cost factor to the c1 of the access/egress.
+ */
+public class AccessEgressWithExtraCost extends AbstractAccessEgressDecorator {
+
+  private final double costFactor;
+
+  public AccessEgressWithExtraCost(RaptorAccessEgress delegate, double costFactor) {
+    super(delegate);
+    this.costFactor = costFactor;
+  }
+
+  @Override
+  public int c1() {
+    return (int) (delegate().c1() * costFactor);
+  }
+}

application/src/main/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/mappers/DirectTransitRequestMapper.java

@@ -0,0 +1,83 @@
+package org.opentripplanner.routing.algorithm.raptoradapter.transit.mappers;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import org.opentripplanner.raptor.api.model.RaptorAccessEgress;
+import org.opentripplanner.raptor.api.request.SearchParams;
+import org.opentripplanner.raptor.direct.api.RaptorDirectTransitRequest;
+import org.opentripplanner.routing.algorithm.raptoradapter.transit.AccessEgressWithExtraCost;
+import org.opentripplanner.routing.api.request.RouteRequest;
+
+public class DirectTransitRequestMapper {
+
+  /// Map the request into a request object for the direct transit search. Will return empty if
+  /// the direct transit search shouldn't be run.
+  public static Optional<RaptorDirectTransitRequest> map(
+    RouteRequest request,
+    SearchParams searchParamsUsed
+  ) {
+    var directTransitRequestOpt = request.preferences().transit().directTransit();
+    if (directTransitRequestOpt.isEmpty()) {
+      return Optional.empty();
+    }
+    var rel = directTransitRequestOpt.orElseThrow();
+    Collection<? extends RaptorAccessEgress> access = searchParamsUsed.accessPaths();
+    Collection<? extends RaptorAccessEgress> egress = searchParamsUsed.egressPaths();
+
+    access = filterAccessEgressNoOpeningHours(access);
+    egress = filterAccessEgressNoOpeningHours(egress);
+
+    if (rel.maxAccessEgressDuration().isPresent()) {
+      var maxDuration = rel.maxAccessEgressDuration().get();
+      access = filterAccessEgressByDuration(access, maxDuration);
+      egress = filterAccessEgressByDuration(egress, maxDuration);
+    }
+    if (rel.isExtraReluctanceAddedToAccessAndEgress()) {
+      double f = rel.extraAccessEgressReluctance();
+      access = decorateAccessEgressWithExtraCost(access, f);
+      egress = decorateAccessEgressWithExtraCost(egress, f);
+    }
+    if (access.isEmpty() || egress.isEmpty()) {
+      return Optional.empty();
+    }
+    var directRequest = RaptorDirectTransitRequest.of()
+      .addAccessPaths(access)
+      .addEgressPaths(egress)
+      .searchWindowInSeconds(searchParamsUsed.searchWindowInSeconds())
+      .earliestDepartureTime(searchParamsUsed.earliestDepartureTime())
+      .withRelaxC1(RaptorRequestMapper.mapRelaxCost(rel.costRelaxFunction()))
+      .build();
+    return Optional.of(directRequest);
+  }
+
+  private static List<? extends RaptorAccessEgress> filterAccessEgressByDuration(
+    Collection<? extends RaptorAccessEgress> list,
+    Duration maxDuration
+  ) {
+    return list
+      .stream()
+      .filter(ae -> ae.durationInSeconds() <= maxDuration.toSeconds())
+      .toList();
+  }
+
+  private static List<? extends RaptorAccessEgress> filterAccessEgressNoOpeningHours(
+    Collection<? extends RaptorAccessEgress> list
+  ) {
+    return list
+      .stream()
+      .filter(it -> !it.hasOpeningHours())
+      .toList();
+  }
+
+  private static List<? extends RaptorAccessEgress> decorateAccessEgressWithExtraCost(
+    Collection<? extends RaptorAccessEgress> list,
+    double costFactor
+  ) {
+    return list
+      .stream()
+      .map(it -> new AccessEgressWithExtraCost(it, costFactor))
+      .toList();
+  }
+}

application/src/main/java/org/opentripplanner/routing/algorithm/raptoradapter/transit/mappers/RaptorRequestMapper.java

@@ -76,7 +76,7 @@ private RaptorRequestMapper(
     this.linkingContext = Objects.requireNonNull(linkingContext);
   }
 
-  public static <T extends RaptorTripSchedule> RaptorRequest<T> mapRequest(
+  public static <T extends RaptorTripSchedule> RaptorRequestMapper<T> of(
     RouteRequest request,
     ZonedDateTime transitSearchTimeZero,
     boolean isMultiThreaded,
@@ -97,10 +97,10 @@ public static <T extends RaptorTripSchedule> RaptorRequest<T> mapRequest(
       viaTransferResolver,
       lookUpStopIndex,
       linkingContext
-    ).doMap();
+    );
   }
 
-  private RaptorRequest<T> doMap() {
+  public RaptorRequest<T> mapRaptorRequest() {
     var builder = new RaptorRequestBuilder<T>();
     var searchParams = builder.searchParams();
     var preferences = request.preferences();

application/src/main/java/org/opentripplanner/routing/api/request/preference/DirectTransitPreferences.java

@@ -0,0 +1,173 @@
+package org.opentripplanner.routing.api.request.preference;
+
+import java.time.Duration;
+import java.util.Objects;
+import java.util.Optional;
+import javax.annotation.Nullable;
+import org.opentripplanner.framework.model.Cost;
+import org.opentripplanner.routing.api.request.framework.CostLinearFunction;
+import org.opentripplanner.utils.tostring.ToStringBuilder;
+
+///  All preferences related to the Direct Transit Search
+public class DirectTransitPreferences {
+
+  // The next constants are package-local to be readable in the unit-test.
+  static final double DEFAULT_RELUCTANCE = 1.0;
+  static final CostLinearFunction DEFAULT_COST_RELAX_FUNCTION = CostLinearFunction.of(
+    Cost.costOfMinutes(15),
+    1.5
+  );
+
+  public static final DirectTransitPreferences DEFAULT = new DirectTransitPreferences(
+    false,
+    DEFAULT_COST_RELAX_FUNCTION,
+    DEFAULT_RELUCTANCE,
+    null
+  );
+
+  private final boolean enabled;
+  private final CostLinearFunction costRelaxFunction;
+  private final double extraAccessEgressReluctance;
+
+  @Nullable
+  private final Duration maxAccessEgressDuration;
+
+  private DirectTransitPreferences(
+    boolean enabled,
+    CostLinearFunction costRelaxFunction,
+    double extraAccessEgressReluctance,
+    @Nullable Duration maxAccessEgressDuration
+  ) {
+    this.enabled = enabled;
+    this.costRelaxFunction = Objects.requireNonNull(costRelaxFunction);
+    this.extraAccessEgressReluctance = extraAccessEgressReluctance;
+    this.maxAccessEgressDuration = maxAccessEgressDuration;
+  }
+
+  public static Builder of() {
+    return new Builder(DEFAULT);
+  }
+
+  public Builder copyOf() {
+    return new Builder(this);
+  }
+
+  /// Whether to enable direct transit search
+  public boolean enabled() {
+    return enabled;
+  }
+
+  /// This is used to limit the results from the search. Paths are compared with the cheapest path
+  /// in the search window and are included in the result if they fall within the limit given by the
+  /// costRelaxFunction.
+  public CostLinearFunction costRelaxFunction() {
+    return costRelaxFunction;
+  }
+
+  /// An extra cost that is used to increase the cost of the access/egress legs for this search.
+  public double extraAccessEgressReluctance() {
+    return extraAccessEgressReluctance;
+  }
+
+  ///  Whether there is any extra access/egress reluctance
+  public boolean isExtraReluctanceAddedToAccessAndEgress() {
+    return extraAccessEgressReluctance != DEFAULT_RELUCTANCE;
+  }
+
+  /// A limit on the duration for access/egress for this search. Setting this to 0 will only include
+  /// results that require no access or egress. I.e. a stop-to-stop search.
+  public Optional<Duration> maxAccessEgressDuration() {
+    return Optional.ofNullable(maxAccessEgressDuration);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    DirectTransitPreferences that = (DirectTransitPreferences) o;
+    return (
+      enabled == that.enabled &&
+      Double.compare(extraAccessEgressReluctance, that.extraAccessEgressReluctance) == 0 &&
+      Objects.equals(maxAccessEgressDuration, that.maxAccessEgressDuration) &&
+      Objects.equals(costRelaxFunction, that.costRelaxFunction)
+    );
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(
+      enabled,
+      costRelaxFunction,
+      extraAccessEgressReluctance,
+      maxAccessEgressDuration
+    );
+  }
+
+  @Override
+  public String toString() {
+    if (!enabled) {
+      return "DirectTransitPreferences{not enabled}";
+    }
+    return ToStringBuilder.of(DirectTransitPreferences.class)
+      .addObj("costRelaxFunction", costRelaxFunction, DEFAULT.costRelaxFunction)
+      .addNum(
+        "extraAccessEgressReluctance",
+        extraAccessEgressReluctance,
+        DEFAULT.extraAccessEgressReluctance
+      )
+      .addDuration(
+        "maxAccessEgressDuration",
+        maxAccessEgressDuration,
+        DEFAULT.maxAccessEgressDuration
+      )
+      .toString();
+  }
+
+  public static class Builder {
+
+    private boolean enabled;
+    private CostLinearFunction costRelaxFunction;
+    private double extraAccessEgressReluctance;
+    private Duration maxAccessEgressDuration;
+    public DirectTransitPreferences original;
+
+    public Builder(DirectTransitPreferences original) {
+      this.original = original;
+      this.enabled = original.enabled;
+      this.costRelaxFunction = original.costRelaxFunction;
+      this.extraAccessEgressReluctance = original.extraAccessEgressReluctance;
+      this.maxAccessEgressDuration = original.maxAccessEgressDuration;
+    }
+
+    public Builder withEnabled(boolean enabled) {
+      this.enabled = enabled;
+      return this;
+    }
+
+    public Builder withCostRelaxFunction(CostLinearFunction costRelaxFunction) {
+      this.costRelaxFunction = costRelaxFunction;
+      return this;
+    }
+
+    public Builder withExtraAccessEgressReluctance(double extraAccessEgressReluctance) {
+      this.extraAccessEgressReluctance = extraAccessEgressReluctance;
+      return this;
+    }
+
+    public Builder withMaxAccessEgressDuration(Duration maxAccessEgressDuration) {
+      this.maxAccessEgressDuration = maxAccessEgressDuration;
+      return this;
+    }
+
+    public DirectTransitPreferences build() {
+      var value = new DirectTransitPreferences(
+        enabled,
+        costRelaxFunction,
+        extraAccessEgressReluctance,
+        maxAccessEgressDuration
+      );
+      return original.equals(value) ? original : value;
+    }
+  }
+}