GTFS flex support: flag stops, deviated-route service, call-and-ride

docs/Changelog.md

@@ -6,6 +6,7 @@
 - Update onebusaway-gtfs to latest version from OBA project (#2636)
 - Remove the coupling to OneBusAway GTFS within OTP's internal model by creating new classes replacing the external classes (#2494)
 - Allow itineraries in response to be sorted by duration (#2593)
+- Add support for GTFS-flex services: flag stops, deviated-route service, and call-and-ride (#2603)
 
 ## 1.3 (2018-08-03)
 

src/main/java/org/opentripplanner/api/common/RoutingResource.java

@@ -346,6 +346,36 @@ public abstract class RoutingResource {
     @QueryParam("disableRemainingWeightHeuristic")
     protected Boolean disableRemainingWeightHeuristic;
 
+    /*
+     * Control the size of flag-stop buffer returned in API response. This parameter only applies
+     * to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in
+     * router-config.json.
+     */
+    @QueryParam("flexFlagStopBufferSize")
+    protected Double flexFlagStopBufferSize;
+
+    /**
+     * Whether to use reservation-based services
+     */
+    @QueryParam("flexUseReservationServices")
+    protected Boolean flexUseReservationServices = true;
+
+    /**
+     * Whether to use eligibility-based services
+     */
+    @QueryParam("flexUseEligibilityServices")
+    protected Boolean flexUseEligibilityServices = true;
+
+    /**
+     * Whether to ignore DRT time limits.
+     *
+     * According to the GTFS-flex spec, demand-response transit (DRT) service must be reserved
+     * at least `drt_advance_book_min` minutes in advance. OTP not allow DRT service to be used
+     * inside that time window, unless this parameter is set to true.
+     */
+    @QueryParam("flexIgnoreDrtAdvanceBookMin")
+    protected Boolean flexIgnoreDrtAdvanceBookMin;
+
     @QueryParam("maxHours")
     private Double maxHours;
 
@@ -418,6 +448,8 @@ protected RoutingRequest buildRequest() throws ParameterException {
             } else {
                 request.setDateTime(date, time, tz);
             }
+
+            request.resetClockTime();
         }
 
         if (wheelchair != null)
@@ -429,6 +461,9 @@ protected RoutingRequest buildRequest() throws ParameterException {
         if (maxWalkDistance != null) {
             request.setMaxWalkDistance(maxWalkDistance);
             request.maxTransferWalkDistance = maxWalkDistance;
+            if (maxWalkDistance == 0.0) {
+                request.excludeWalking = true;
+            }
         }
 
         if (maxPreTransitTime != null)
@@ -595,6 +630,18 @@ protected RoutingRequest buildRequest() throws ParameterException {
         if (disableRemainingWeightHeuristic != null)
             request.disableRemainingWeightHeuristic = disableRemainingWeightHeuristic;
 
+        if (flexFlagStopBufferSize != null)
+            request.flexFlagStopBufferSize = flexFlagStopBufferSize;
+
+        if (flexUseReservationServices != null)
+            request.flexUseReservationServices = flexUseReservationServices;
+
+        if (flexUseEligibilityServices != null)
+            request.flexUseEligibilityServices = flexUseEligibilityServices;
+
+        if (flexIgnoreDrtAdvanceBookMin != null)
+            request.flexIgnoreDrtAdvanceBookMin = flexIgnoreDrtAdvanceBookMin;
+
         if (maxHours != null)
             request.maxHours = maxHours;
 

src/main/java/org/opentripplanner/api/model/BoardAlightType.java

@@ -0,0 +1,26 @@
+package org.opentripplanner.api.model;
+
+/**
+ * Represent type of board/alight at a stop. The majority of boarding and alightings will be of
+ * type "default" -- a regular boarding or alighting at a regular transit stop. Currently, the
+ * only non-default types are related to GTFS-Flex, but this pattern can be extended as necessary.
+ */
+public enum BoardAlightType {
+
+    /**
+     * A regular boarding or alighting at a fixed-route transit stop.
+     */
+    DEFAULT,
+
+    /**
+     * A flag-stop boarding or alighting, e.g. flagging the bus down or a passegner asking the bus
+     * driver for a drop-off between stops. This is specific to GTFS-Flex.
+     */
+    FLAG_STOP,
+
+    /**
+     * A boarding or alighting at which the vehicle deviates from its fixed route to drop off a
+     * passenger. This is specific to GTFS-Flex.
+     */
+    DEVIATED;
+}

src/main/java/org/opentripplanner/api/model/Leg.java

@@ -247,6 +247,60 @@ public class Leg {
     @JsonSerialize
     public Boolean rentedBike;
 
+     /**
+      * True if this is a call-and-ride leg.
+      */
+    @XmlAttribute
+    @JsonSerialize
+    public Boolean callAndRide;
+
+    /* For call-n-ride leg, supply maximum start time based on calculation. */
+    @XmlAttribute
+    @JsonSerialize
+    public Calendar flexCallAndRideMaxStartTime = null;
+
+     /* For call-n-ride leg, supply minimum end time based on calculation. */
+    @XmlAttribute
+    @JsonSerialize
+    public Calendar flexCallAndRideMinEndTime = null;
+
+    /** trip.drt_advance_book_min if this is a demand-response leg */
+    @XmlAttribute
+    @JsonSerialize
+    public double flexDrtAdvanceBookMin;
+
+     /**
+      *  Agency message if this is leg has a demand-response pickup and the Trip has
+      *  `drt_pickup_message` defined.
+      */
+     @XmlAttribute
+     @JsonSerialize
+     public String flexDrtPickupMessage;
+
+     /**
+      * Agency message if this is leg has a demand-response dropoff and the Trip has
+      * `drt_drop_off_message` defined.
+      */
+     @XmlAttribute
+     @JsonSerialize
+     public String flexDrtDropOffMessage;
+
+     /**
+      * Agency message if this is leg has a flag stop pickup and the Trip has
+      * `continuous_pickup_message` defined.
+      */
+     @XmlAttribute
+     @JsonSerialize
+     public String flexFlagStopPickupMessage;
+
+     /**
+      * Agency message if this is leg has a flag stop dropoff and the Trip has
+      * `continuous_drop_off_message` defined.
+      */
+     @XmlAttribute
+     @JsonSerialize
+     public String flexFlagStopDropOffMessage;
+
     /**
      * Whether this leg is a transit leg or not.
      * @return Boolean true if the leg is a transit leg

src/main/java/org/opentripplanner/api/model/Place.java

@@ -8,6 +8,7 @@
 import org.opentripplanner.util.Constants;
 
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import org.opentripplanner.util.model.EncodedPolylineBean;
 
 /** 
 * A Place is where a journey starts or ends, or a transit stop along the way.
@@ -91,6 +92,17 @@ public class Place {
      */
     public String bikeShareId;
 
+    /**
+     * Type of board or alight. This will be "default" in most cases. Currently the only non-
+     * default values are for GTFS-Flex.
+     */
+    public BoardAlightType boardAlightType;
+
+    /**
+     * Board or alight area for flag stops
+     */
+    public EncodedPolylineBean flagStopArea;
+
     /**
      * Returns the geometry in GeoJSON format
      * @return

src/main/java/org/opentripplanner/api/resource/GraphPathToTripPlanConverter.java

@@ -17,6 +17,8 @@
 import org.opentripplanner.routing.alertpatch.AlertPatch;
 import org.opentripplanner.routing.core.*;
 import org.opentripplanner.routing.edgetype.*;
+import org.opentripplanner.routing.edgetype.flex.PartialPatternHop;
+import org.opentripplanner.routing.edgetype.flex.TemporaryDirectPatternHop;
 import org.opentripplanner.routing.error.TrivialPathException;
 import org.opentripplanner.routing.graph.Edge;
 import org.opentripplanner.routing.graph.Graph;
@@ -182,9 +184,13 @@ public static Itinerary generateItinerary(GraphPath path, boolean showIntermedia
 
     private static Calendar makeCalendar(State state) {
         RoutingContext rctx = state.getContext();
-        TimeZone timeZone = rctx.graph.getTimeZone(); 
+        TimeZone timeZone = rctx.graph.getTimeZone();
+        return makeCalendar(timeZone, state.getTimeInMillis());
+    }
+
+    private static Calendar makeCalendar(TimeZone timeZone, long timeMillis) {
         Calendar calendar = Calendar.getInstance(timeZone);
-        calendar.setTimeInMillis(state.getTimeInMillis());
+        calendar.setTimeInMillis(timeMillis);
         return calendar;
     }
 
@@ -194,11 +200,11 @@ private static Calendar makeCalendar(State state) {
      * @param edges The array of input edges
      * @return The coordinates of the points on the edges
      */
-    private static CoordinateArrayListSequence makeCoordinates(Edge[] edges) {
+    public static CoordinateArrayListSequence makeCoordinates(Edge[] edges) {
         CoordinateArrayListSequence coordinates = new CoordinateArrayListSequence();
 
         for (Edge edge : edges) {
-            LineString geometry = edge.getGeometry();
+            LineString geometry = edge.getDisplayGeometry();
 
             if (geometry != null) {
                 if (coordinates.size() == 0) {
@@ -585,6 +591,11 @@ private static void addTripFields(Leg leg, State[] states, Locale requestedLocal
             leg.tripId = trip.getId();
             leg.tripShortName = trip.getTripShortName();
             leg.tripBlockId = trip.getBlockId();
+            leg.flexDrtAdvanceBookMin = trip.getDrtAdvanceBookMin();
+            leg.flexDrtPickupMessage = trip.getDrtPickupMessage();
+            leg.flexDrtDropOffMessage = trip.getDrtDropOffMessage();
+            leg.flexFlagStopPickupMessage = trip.getContinuousPickupMessage();
+            leg.flexFlagStopDropOffMessage = trip.getContinuousDropOffMessage();
 
             if (serviceDay != null) {
                 leg.serviceDate = serviceDay.getServiceDate().getAsString();
@@ -593,6 +604,30 @@ private static void addTripFields(Leg leg, State[] states, Locale requestedLocal
             if (leg.headsign == null) {
                 leg.headsign = trip.getTripHeadsign();
             }
+
+            Edge edge = states[states.length - 1].backEdge;
+            if (edge instanceof TemporaryDirectPatternHop) {
+                leg.callAndRide = true;
+            }
+            if (edge instanceof PartialPatternHop) {
+                PartialPatternHop hop = (PartialPatternHop) edge;
+                int directTime = hop.getDirectVehicleTime();
+                TripTimes tt = states[states.length - 1].getTripTimes();
+                int maxTime = tt.getDemandResponseMaxTime(directTime);
+                int avgTime = tt.getDemandResponseAvgTime(directTime);
+                int delta = maxTime - avgTime;
+                if (directTime != 0 && delta > 0) {
+                    if (hop.isDeviatedRouteBoard()) {
+                        long maxStartTime = leg.startTime.getTimeInMillis() + (delta * 1000);
+                        leg.flexCallAndRideMaxStartTime = makeCalendar(leg.startTime.getTimeZone(), maxStartTime);
+                    }
+                    if (hop.isDeviatedRouteAlight()) {
+                        long minEndTime = leg.endTime.getTimeInMillis() - (delta * 1000);
+                        leg.flexCallAndRideMinEndTime = makeCalendar(leg.endTime.getTimeZone(), minEndTime);
+                    }
+                }
+            }
+
         }
     }
 
@@ -686,6 +721,22 @@ private static Place makePlace(State state, Vertex vertex, Edge edge, Stop stop,
                 place.stopSequence = tripTimes.getStopSequence(place.stopIndex);
             }
             place.vertexType = VertexType.TRANSIT;
+            place.boardAlightType = BoardAlightType.DEFAULT;
+            if (edge instanceof PartialPatternHop) {
+                PartialPatternHop hop = (PartialPatternHop) edge;
+                if (hop.hasBoardArea() && !endOfLeg) {
+                    place.flagStopArea = PolylineEncoder.createEncodings(hop.getBoardArea());
+                }
+                if (hop.hasAlightArea() && endOfLeg) {
+                    place.flagStopArea = PolylineEncoder.createEncodings(hop.getAlightArea());
+                }
+                if ((endOfLeg && hop.isFlagStopAlight()) || (!endOfLeg && hop.isFlagStopBoard())) {
+                    place.boardAlightType = BoardAlightType.FLAG_STOP;
+                }
+                if ((endOfLeg && hop.isDeviatedRouteAlight()) || (!endOfLeg && hop.isDeviatedRouteBoard())) {
+                    place.boardAlightType = BoardAlightType.DEVIATED;
+                }
+            }
         } else if(vertex instanceof BikeRentalStationVertex) {
             place.bikeShareId = ((BikeRentalStationVertex) vertex).getId();
             LOG.trace("Added bike share Id {} to place", place.bikeShareId);

src/main/java/org/opentripplanner/common/geometry/GeometryUtils.java

@@ -1,6 +1,8 @@
 package org.opentripplanner.common.geometry;
 
 import com.vividsolutions.jts.geom.*;
+import com.vividsolutions.jts.io.ParseException;
+import com.vividsolutions.jts.io.WKTReader;
 import com.vividsolutions.jts.linearref.LengthLocationMap;
 import com.vividsolutions.jts.linearref.LinearLocation;
 import com.vividsolutions.jts.linearref.LocationIndexedLine;
@@ -181,4 +183,13 @@ private static Coordinate[] convertPath(List<LngLatAlt> path) {
         }
         return coords;
     }
+
+    public static Geometry parseWkt(String wkt) {
+        try {
+            return new WKTReader(GeometryUtils.getGeometryFactory()).read(wkt);
+        } catch(ParseException e) {
+            LOG.error("Unable to parse wkt: " + e);
+        }
+        return null;
+    }
 }

src/main/java/org/opentripplanner/gtfs/mapping/AreaMapper.java

@@ -0,0 +1,32 @@
+package org.opentripplanner.gtfs.mapping;
+
+import org.opentripplanner.model.FlexArea;
+import org.opentripplanner.util.MapUtils;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Map from the OBA model of GTFS-flex areas to the OTP internal model of areas. */
+class AreaMapper {
+
+    private final Map<org.onebusaway.gtfs.model.Area, FlexArea> mappedAreas = new HashMap<>();
+
+    Collection<FlexArea> map(Collection<org.onebusaway.gtfs.model.Area> agencies) {
+        return MapUtils.mapToList(agencies, this::map);
+    }
+
+    /** Map from the OBA model of GTFS-flex areas to the OTP internal model of areas.  */
+    FlexArea map(org.onebusaway.gtfs.model.Area orginal) {
+        return orginal == null ? null : mappedAreas.computeIfAbsent(orginal, this::doMap);
+    }
+
+    private FlexArea doMap(org.onebusaway.gtfs.model.Area rhs) {
+        FlexArea lhs = new FlexArea();
+
+        lhs.setId(AgencyAndIdMapper.mapAgencyAndId(rhs.getId()));
+        lhs.setWkt(rhs.getWkt());
+
+        return lhs;
+    }
+}

src/main/java/org/opentripplanner/gtfs/mapping/GTFSToOtpTransitServiceMapper.java

@@ -42,6 +42,8 @@ public class GTFSToOtpTransitServiceMapper {
             routeMapper, fareAttributeMapper
     );
 
+    private final AreaMapper areaMapper = new AreaMapper();
+
     /**
      * Map from GTFS data to the internal OTP model
      */
@@ -66,6 +68,7 @@ private OtpTransitService map(org.onebusaway.gtfs.services.GtfsRelationalDao dat
         builder.getStopTimes().addAll(stopTimeMapper.map(data.getAllStopTimes()));
         builder.getTransfers().addAll(transferMapper.map(data.getAllTransfers()));
         builder.getTrips().addAll(tripMapper.map(data.getAllTrips()));
+        builder.getFlexAreas().addAll(areaMapper.map(data.getAllAreas()));
 
         return builder.build();
     }

src/main/java/org/opentripplanner/gtfs/mapping/RouteMapper.java

@@ -42,6 +42,7 @@ private Route doMap(org.onebusaway.gtfs.model.Route rhs) {
         lhs.setBikesAllowed(rhs.getBikesAllowed());
         lhs.setSortOrder(rhs.getSortOrder());
         lhs.setBrandingUrl(rhs.getBrandingUrl());
+        lhs.setEligibilityRestricted(rhs.getEligibilityRestricted());
 
         return lhs;
     }

src/main/java/org/opentripplanner/gtfs/mapping/StopTimeMapper.java

@@ -44,6 +44,12 @@ private StopTime doMap(org.onebusaway.gtfs.model.StopTime rhs) {
         lhs.setDropOffType(rhs.getDropOffType());
         lhs.setShapeDistTraveled(rhs.getShapeDistTraveled());
         lhs.setFarePeriodId(rhs.getFarePeriodId());
+        lhs.setContinuousPickup(rhs.getContinuousPickup());
+        lhs.setContinuousDropOff(rhs.getContinuousDropOff());
+        lhs.setStartServiceArea(rhs.getStartServiceArea());
+        lhs.setEndServiceArea(rhs.getEndServiceArea());
+        lhs.setStartServiceAreaRadius(rhs.getStartServiceAreaRadius());
+        lhs.setEndServiceAreaRadius(rhs.getEndServiceAreaRadius());
 
         // Skip mapping of proxy
         // private transient StopTimeProxy proxy;