Implement basic flex filtering

Author: leonardehrenfried

application/src/ext-test/java/org/opentripplanner/ext/flex/trip/ScheduledDeviatedTripIntegrationTest.java

@@ -104,6 +104,7 @@ void calculateDirectFare() {
       graph,
       new DefaultTransitService(timetableRepository),
       FlexParameters.defaultValues(),
+      List.of(),
       OffsetDateTime.parse("2021-11-12T10:15:24-05:00").toInstant(),
       null,
       1,

application/src/ext/java/org/opentripplanner/ext/flex/FlexIndex.java

@@ -3,8 +3,10 @@
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import org.opentripplanner.ext.flex.trip.FlexTrip;
 import org.opentripplanner.model.PathTransfer;
@@ -23,7 +25,7 @@ public class FlexIndex {
 
   private final Multimap<StopLocation, FlexTrip<?, ?>> flexTripsByStop = HashMultimap.create();
 
-  private final Map<FeedScopedId, Route> routeById = new HashMap<>();
+  private final List<Route> flexRoutes;
 
   private final Map<FeedScopedId, FlexTrip<?, ?>> tripById = new HashMap<>();
 
@@ -33,8 +35,9 @@ public FlexIndex(TimetableRepository timetableRepository) {
       transfersToStop.put(transfer.to, transfer);
       transfersFromStop.put(transfer.from, transfer);
     }
+    var routes = new ArrayList<Route>();
     for (FlexTrip<?, ?> flexTrip : timetableRepository.getAllFlexTrips()) {
-      routeById.put(flexTrip.getTrip().getRoute().getId(), flexTrip.getTrip().getRoute());
+      routes.add(flexTrip.getTrip().getRoute());
       tripById.put(flexTrip.getTrip().getId(), flexTrip);
       for (StopLocation stop : flexTrip.getStops()) {
         if (stop instanceof GroupStop groupStop) {
@@ -46,6 +49,7 @@ public FlexIndex(TimetableRepository timetableRepository) {
         }
       }
     }
+    this.flexRoutes = List.copyOf(routes);
   }
 
   public Collection<PathTransfer> getTransfersToStop(StopLocation stopLocation) {
@@ -60,12 +64,8 @@ public Collection<PathTransfer> getTransfersFromStop(StopLocation stopLocation)
     return flexTripsByStop.get(stopLocation);
   }
 
-  public Route getRouteById(FeedScopedId id) {
-    return routeById.get(id);
-  }
-
   public Collection<Route> getAllFlexRoutes() {
-    return routeById.values();
+    return flexRoutes;
   }
 
   public FlexTrip<?, ?> getTripById(FeedScopedId id) {

application/src/ext/java/org/opentripplanner/ext/flex/FlexRouter.java

@@ -23,6 +23,7 @@
 import org.opentripplanner.model.PathTransfer;
 import org.opentripplanner.model.plan.Itinerary;
 import org.opentripplanner.routing.algorithm.mapping.GraphPathToItineraryMapper;
+import org.opentripplanner.routing.api.request.request.filter.TransitFilter;
 import org.opentripplanner.routing.graph.Graph;
 import org.opentripplanner.routing.graphfinder.NearbyStop;
 import org.opentripplanner.street.model.vertex.TransitStopVertex;
@@ -39,6 +40,7 @@ public class FlexRouter {
   private final Graph graph;
   private final TransitService transitService;
   private final FlexParameters flexParameters;
+  private final List<TransitFilter> filters;
   private final Collection<NearbyStop> streetAccesses;
   private final Collection<NearbyStop> streetEgresses;
   private final FlexIndex flexIndex;
@@ -57,7 +59,7 @@ public FlexRouter(
     Graph graph,
     TransitService transitService,
     FlexParameters flexParameters,
-    Instant requestedTime,
+    List<TransitFilter> filters, Instant requestedTime,
     @Nullable Instant requestedBookingTime,
     int additionalPastSearchDays,
     int additionalFutureSearchDays,
@@ -67,6 +69,7 @@ public FlexRouter(
     this.graph = graph;
     this.transitService = transitService;
     this.flexParameters = flexParameters;
+    this.filters = filters;
     this.streetAccesses = streetAccesses;
     this.streetEgresses = egressTransfers;
     this.flexIndex = transitService.getFlexIndex();
@@ -114,7 +117,9 @@ public List<Itinerary> createFlexOnlyItineraries(boolean arriveBy) {
       callbackService,
       accessFlexPathCalculator,
       egressFlexPathCalculator,
-      flexParameters.maxTransferDuration()
+      flexParameters.maxTransferDuration(),
+      transitService,
+      filters
     )
       .calculateDirectFlexPaths(streetAccesses, streetEgresses, dates, requestedTime, arriveBy);
 
@@ -139,7 +144,9 @@ public Collection<FlexAccessEgress> createFlexAccesses() {
     return new FlexAccessFactory(
       callbackService,
       accessFlexPathCalculator,
-      flexParameters.maxTransferDuration()
+      flexParameters.maxTransferDuration(),
+      transitService,
+      filters
     )
       .createFlexAccesses(streetAccesses, dates);
   }

application/src/ext/java/org/opentripplanner/ext/flex/template/ClosestTrip.java

@@ -7,6 +7,7 @@
 import java.util.Map;
 import java.util.Objects;
 import org.opentripplanner.ext.flex.trip.FlexTrip;
+import org.opentripplanner.routing.api.request.request.filter.TransitFilter;
 import org.opentripplanner.routing.graphfinder.NearbyStop;
 import org.opentripplanner.transit.model.timetable.booking.RoutingBookingInfo;
 import org.opentripplanner.utils.lang.IntUtils;

application/src/ext/java/org/opentripplanner/ext/flex/template/FlexAccessFactory.java

@@ -5,19 +5,25 @@
 import java.util.List;
 import org.opentripplanner.ext.flex.FlexAccessEgress;
 import org.opentripplanner.ext.flex.flexpathcalculator.FlexPathCalculator;
+import org.opentripplanner.routing.api.request.request.filter.TransitFilter;
 import org.opentripplanner.routing.graphfinder.NearbyStop;
+import org.opentripplanner.transit.service.TransitService;
 
 public class FlexAccessFactory {
 
   private final FlexAccessEgressCallbackAdapter callbackService;
+  private final FlexTransitFilter filter;
   private final FlexTemplateFactory templateFactory;
 
   public FlexAccessFactory(
     FlexAccessEgressCallbackAdapter callbackService,
     FlexPathCalculator pathCalculator,
-    Duration maxTransferDuration
+    Duration maxTransferDuration,
+    TransitService transitService,
+    List<TransitFilter> filters
   ) {
     this.callbackService = callbackService;
+    this.filter = new FlexTransitFilter(transitService, filters);
     this.templateFactory = FlexTemplateFactory.of(pathCalculator, maxTransferDuration);
   }
 
@@ -40,7 +46,9 @@ List<FlexAccessTemplate> calculateFlexAccessTemplates(
     var closestFlexTrips = ClosestTrip.of(callbackService, streetAccesses, dates, true);
     return closestFlexTrips
       .stream()
+      .filter(filter::matchesTransitFilters)
       .flatMap(it -> templateFactory.createAccessTemplates(it).stream())
       .toList();
   }
+
 }

application/src/ext/java/org/opentripplanner/ext/flex/template/FlexDirectPathFactory.java

@@ -10,30 +10,38 @@
 import java.util.List;
 import java.util.Optional;
 import org.opentripplanner.ext.flex.flexpathcalculator.FlexPathCalculator;
+import org.opentripplanner.routing.api.request.request.filter.TransitFilter;
 import org.opentripplanner.routing.graphfinder.NearbyStop;
 import org.opentripplanner.street.model.vertex.Vertex;
 import org.opentripplanner.street.search.state.EdgeTraverser;
 import org.opentripplanner.street.search.state.State;
 import org.opentripplanner.transit.model.site.StopLocation;
 import org.opentripplanner.transit.model.timetable.booking.RoutingBookingInfo;
+import org.opentripplanner.transit.service.TransitService;
 
 public class FlexDirectPathFactory {
 
   private final FlexAccessEgressCallbackAdapter callbackService;
   private final FlexPathCalculator accessPathCalculator;
   private final FlexPathCalculator egressPathCalculator;
   private final Duration maxTransferDuration;
+  private final TransitService transitService;
+  private final List<TransitFilter> filters;
 
   public FlexDirectPathFactory(
     FlexAccessEgressCallbackAdapter callbackService,
     FlexPathCalculator accessPathCalculator,
     FlexPathCalculator egressPathCalculator,
-    Duration maxTransferDuration
+    Duration maxTransferDuration,
+    TransitService transitService,
+    List<TransitFilter> filters
   ) {
     this.callbackService = callbackService;
     this.accessPathCalculator = accessPathCalculator;
     this.egressPathCalculator = egressPathCalculator;
     this.maxTransferDuration = maxTransferDuration;
+    this.transitService = transitService;
+    this.filters = filters;
   }
 
   public Collection<DirectFlexPath> calculateDirectFlexPaths(
@@ -48,7 +56,9 @@ public Collection<DirectFlexPath> calculateDirectFlexPaths(
     var flexAccessTemplates = new FlexAccessFactory(
       callbackService,
       accessPathCalculator,
-      maxTransferDuration
+      maxTransferDuration,
+      transitService,
+      filters
     )
       .calculateFlexAccessTemplates(streetAccesses, dates);
 

application/src/ext/java/org/opentripplanner/ext/flex/template/FlexTransitFilter.java

@@ -0,0 +1,28 @@
+package org.opentripplanner.ext.flex.template;
+
+import java.util.List;
+import java.util.Objects;
+import org.opentripplanner.routing.api.request.request.filter.TransitFilter;
+import org.opentripplanner.transit.service.TransitService;
+
+class FlexTransitFilter {
+
+  private final TransitService transitService;
+  private final List<TransitFilter> filters;
+
+  FlexTransitFilter(TransitService transitService, List<TransitFilter> filters) {
+    this.transitService = transitService;
+    this.filters = filters;
+  }
+
+  boolean matchesTransitFilters(ClosestTrip trip) {
+    var t = trip.flexTrip().getTrip() ;
+    var pattern = Objects.requireNonNull(transitService.findPattern(t), "flex trip doesn't have a pattern.");
+    for (TransitFilter filter : filters) {
+      if (filter.matchTripPattern(pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

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

@@ -58,6 +58,7 @@ public static List<Itinerary> route(
         serverContext.graph(),
         serverContext.transitService(),
         serverContext.flexParameters(),
+        request.journey().transit().filters(),
         request.dateTime(),
         request.bookingTime(),
         additionalSearchDays.additionalSearchDaysInPast(),

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

@@ -61,6 +61,7 @@ public static Collection<FlexAccessEgress> routeAccessEgress(
       serverContext.graph(),
       transitService,
       config,
+      request.journey().transit().filters(),
       request.dateTime(),
       request.bookingTime(),
       searchDays.additionalSearchDaysInPast(),

application/src/main/java/org/opentripplanner/routing/api/request/request/filter/TransitFilter.java

@@ -1,6 +1,7 @@
 package org.opentripplanner.routing.api.request.request.filter;
 
 import org.opentripplanner.transit.model.network.TripPattern;
+import org.opentripplanner.transit.model.timetable.Trip;
 import org.opentripplanner.transit.model.timetable.TripTimes;
 
 public interface TransitFilter {