RoutingRequest (OpenTripPlanner 1.4.0 API)

java.lang.Object
- org.opentripplanner.routing.core.RoutingRequest

All Implemented Interfaces:

Serializable, Cloneable
```
public class RoutingRequest
extends Object
implements Cloneable, Serializable
```
A trip planning request. Some parameters may not be honored by the trip planner for some or all itineraries. For example, maxWalkDistance may be relaxed if the alternative is to not provide a route. All defaults should be specified here in the RoutingRequest, NOT as annotations on query parameters in web services that create RoutingRequests. This establishes a priority chain for default values: RoutingRequest field initializers, then JSON router config, then query parameters.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`alightSlack`
`boolean`	`allowBikeRental`
`boolean`	`arriveBy` Whether the trip should depart at dateTime (false, the default), or arrive at dateTime.
`HashSet<String>`	`bannedAgencies` Do not use certain named agencies
`RouteMatcher`	`bannedRoutes` Do not use certain named routes.
`StopMatcher`	`bannedStops` Do not use certain stops.
`StopMatcher`	`bannedStopsHard` Do not use certain stops.
`HashMap<FeedScopedId,BannedStopSet>`	`bannedTrips` Do not use certain trips
`boolean`	`batch` when true, do not use goal direction or stop at the target, build a full SPT
`int`	`bikeBoardCost` Separate cost for boarding a vehicle with a bicycle, which is more difficult than on foot.
`boolean`	`bikeParkAndRide`
`int`	`bikeParkCost` Cost of parking a bike.
`int`	`bikeParkTime` Time to park a bike
`int`	`bikeRentalDropoffCost` Cost of dropping-off a rented bike
`int`	`bikeRentalDropoffTime` Time to drop-off a rented bike
`int`	`bikeRentalPickupCost` Cost of renting a bike.
`int`	`bikeRentalPickupTime` Time to rent a bike
`double`	`bikeSpeed`
`int`	`bikeSwitchCost` Cost of getting on and off your own bike
`int`	`bikeSwitchTime` Time to get on and off your own bike
`RoutingRequest`	`bikeWalkingOptions` Options specifically for the case that you are walking a bicycle.
`int`	`boardSlack` Invariant: boardSlack + alightSlack <= transferSlack.
`double`	`carAccelerationSpeed` The acceleration speed of an automobile, in meters per second per second.
`double`	`carDecelerationSpeed` The deceleration speed of an automobile, in meters per second per second.
`int`	`carDropoffTime` Time to park a car in a park and ride, w/o taking into account driving and walking cost (time to park, switch off, pick your stuff, lock the car, etc...)
`double`	`carSpeed`
`long`	`clampInitialWait` The maximum wait time in seconds the user is willing to delay trip start.
`long`	`clockTimeSec` Keep track of epoch time the request was created by OTP.
`boolean`	`compactLegsByReversedSearch` When true, do a full reversed search to compact the legs of the GraphPath.
`long`	`dateTime` The epoch date/time that the trip should depart (or arrive, for requests where arriveBy is true)
`boolean`	`disableAlertFiltering` Option to disable the default filtering of GTFS-RT alerts by time.
`boolean`	`disableRemainingWeightHeuristic` If true, the remaining weight heuristic is disabled.
`DominanceFunction`	`dominanceFunction` The function that compares paths converging on the same vertex to decide which ones continue to be explored.
`boolean`	`driveOnRight` If true, cost turns as they would be in a country where driving occurs on the right; otherwise, cost them as they would be in a country where driving occurs on the left.
`int`	`elevatorBoardCost` What is the cost of boarding an elevator?
`int`	`elevatorBoardTime` How long does it take to get an elevator, on average (actually, it probably should be a bit more than average, to prevent optimistic trips)? Setting it to "seems like forever," while accurate, will probably prevent OTP from working correctly.
`int`	`elevatorHopCost` What is the cost of travelling one floor on an elevator?
`int`	`elevatorHopTime` How long does it take to advance one floor on an elevator?
`boolean`	`enterStationsWithCar` This parameter is used in GTFS-Flex routing.
`Map<Object,Object>`	`extensions` Extensions to the trip planner will require additional traversal options beyond the default set.
`double`	`flexCallAndRideReluctance` Reluctance for call-n-ride.
`int`	`flexDeviatedRouteExtraPenalty` Extra penalty added for deviated-route boarding/alighting.
`double`	`flexFlagStopBufferSize` Control the size of flag-stop buffer returned in API response.
`int`	`flexFlagStopExtraPenalty` Extra penalty added for flag-stop boarding/alighting.
`boolean`	`flexIgnoreDrtAdvanceBookMin` Whether to ignore DRT time limits.
`int`	`flexMaxCallAndRideSeconds` Total time which can be spent on a call-n-ride leg.
`int`	`flexMinPartialHopLength` Minimum length in meters of partial hop edges.
`double`	`flexReduceCallAndRideRatio` Control the reduction of call-and-ride time.
`int`	`flexReduceCallAndRideSeconds` Control the reduction of call-and-ride time.
`boolean`	`flexUseEligibilityServices` Whether to use eligibility-based services.
`boolean`	`flexUseReservationServices` Whether to use reservation-based services.
`GenericLocation`	`from` The start location
`boolean`	`geoidElevation` Whether to apply the ellipsoid->geoid offset to all elevations in the response
`boolean`	`ignoreRealtimeUpdates` When true, realtime updates are ignored during this search.
`List<GenericLocation>`	`intermediatePlaces` An ordered list of intermediate locations to be visited.
`boolean`	`kissAndRide`
`Locale`	`locale`
`boolean`	`longDistance`
`double`	`maxHours` The maximum duration of a returned itinerary, in hours.
`int`	`maxPreTransitTime` The maximum time (in seconds) of pre-transit travel when using drive-to-transit (park and ride or kiss and ride).
`double`	`maxSlope` The maximum slope of streets for wheelchair trips.
`int`	`maxTransfers`
`double`	`maxTransferWalkDistance` The maximum distance (in meters) the user is willing to walk for transfer legs.
`double`	`maxWalkDistance` The maximum distance (in meters) the user is willing to walk for access/egress legs.
`double`	`maxWeight` The worst possible weight that we will accept when planning a trip.
`static int`	`MIN_SIMILARITY`
`TraverseModeSet`	`modes` The set of TraverseModes that a user is willing to use.
`int`	`nonpreferredTransferPenalty` Penalty for using a non-preferred transfer
`int`	`numItineraries` The maximum number of itineraries to return.
`boolean`	`onlyTransitTrips` Accept only paths that use transit (no street-only paths).
`OptimizeType`	`optimize` The set of characteristics that the user wants to optimize for -- defaults to QUICK, or optimize for transit time.
`int`	`otherThanPreferredRoutesPenalty` Penalty added for using every route that is not preferred if user set any route as preferred.
`HashMap<String,String>`	`parameters` The complete list of incoming query parameters.
`boolean`	`parkAndRide`
`String`	`pathComparator` Which path comparator to use
`HashSet<String>`	`preferredAgencies` Set of preferred agencies by user.
`RouteMatcher`	`preferredRoutes` Set of preferred routes by user.
`double`	`preTransitOverageRate`
`double`	`preTransitPenalty`
`RoutingContext`	`rctx` The routing context used to actually carry out this search.
`boolean`	`reverseOptimizeOnTheFly` When true, reverse optimize this search on the fly whenever needed, rather than reverse-optimizing the entire path when it's done.
`boolean`	`reverseOptimizing` This is true when a GraphPath is being traversed in reverse for optimization purposes.
`String`	`routerId` The router ID -- internal ID to switch between router implementation (or graphs)
`int`	`serviceDayLookout` How many extra ServiceDays to look in the future (or back, if arriveBy=true) This parameter allows the configuration of how far, in service days, OTP should look for transit service when evaluating the next departure (or arrival) at a stop.
`boolean`	`showIntermediateStops` Whether the planner should return intermediate stops lists for transit legs.
`boolean`	`softPreTransitLimiting`
`boolean`	`softWalkLimiting`
`double`	`softWalkOverageRate`
`double`	`softWalkPenalty`
`double`	`stairsReluctance` Used instead of walk reluctance for stairs
`FeedScopedId`	`startingTransitStopId` A transit stop that this trip must start from
`FeedScopedId`	`startingTransitTripId` A trip where this trip must start from (depart-onboard routing)
`GenericLocation`	`to` The end location
`int`	`transferPenalty` An extra penalty added on transfers (i.e.
`int`	`transferSlack` A global minimum transfer time (in seconds) that specifies the minimum amount of time that must pass between exiting one transit vehicle and boarding another.
`IntersectionTraversalCostModel`	`traversalCostModel` The model that computes turn/traversal costs.
`double`	`triangleSafetyFactor` For the bike triangle, how important safety is
`double`	`triangleSlopeFactor` For the bike triangle, how important slope is
`double`	`triangleTimeFactor` For the bike triangle, how important time is.
`double`	`turnReluctance` Multiplicative factor on expected turning time.
`HashSet<String>`	`unpreferredAgencies` Set of unpreferred agencies for given user.
`RouteMatcher`	`unpreferredRoutes` Set of unpreferred routes for given user.
`boolean`	`useBikeRentalAvailabilityInformation` Whether or not bike rental availability information will be used to plan bike rental trips
`boolean`	`useRequestedDateTimeInMaxHours` Whether maxHours limit should consider wait/idle time between the itinerary and the requested arrive/depart time.
`boolean`	`useTraffic` Should traffic congestion be considered when driving?
`int`	`useUnpreferredRoutesPenalty` Penalty added for using every unpreferred route.
`double`	`waitAtBeginningFactor` How much less bad is waiting at the beginning of the trip (replaces waitReluctance on the first boarding)
`double`	`waitReluctance` How much worse is waiting for a transit vehicle than being on a transit vehicle, as a multiplier.
`int`	`walkBoardCost` This prevents unnecessary transfers by adding a cost for boarding a vehicle.
`boolean`	`walkingBike`
`double`	`walkReluctance` A multiplier for how bad walking is, compared to being in transit for equal lengths of time.
`double`	`walkSpeed` max walk/bike speed along streets, in meters per second
`boolean`	`wheelchairAccessible` Whether the trip must be wheelchair accessible.
`HashSet<String>`	`whiteListedAgencies` Only use certain named agencies
`RouteMatcher`	`whiteListedRoutes` Only use certain named routes
`long`	`worstTime` The worst possible time (latest for depart-by and earliest for arrive-by) to accept

Constructor Summary

Constructors
Constructor and Description
`RoutingRequest()` Constructor for options; modes defaults to walk and transit
`RoutingRequest(QualifiedModeSet qmodes)`
`RoutingRequest(String qmodes)`
`RoutingRequest(TraverseMode mode)`
`RoutingRequest(TraverseMode mode, OptimizeType optimize)`
`RoutingRequest(TraverseModeSet modes)`
`RoutingRequest(TraverseModeSet modeSet, OptimizeType optimize)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addIntermediatePlace(GenericLocation location)` Adds a GenericLocation to the end of the intermediatePlaces list.
`void`	`addMode(List<TraverseMode> mList)` Add multiple modes to the set of allowed modes.
`void`	`addMode(TraverseMode mode)` Add a TraverseMode to the set of allowed modes.
`void`	`banTrip(FeedScopedId trip)`
`void`	`canSplitEdge(StreetEdge edge)` Does nothing if different edge is split in origin/destination search But throws TrivialPathException if same edge is split in origin/destination search.
`void`	`cleanup()` Tear down any routing context (remove temporary edges from edge lists)
`void`	`clearIntermediatePlaces()` Clears any intermediate places from this request.
`void`	`clearModes()` Clear the allowed modes.
`RoutingRequest`	`clone()`
`boolean`	`containsExtension(Object key)` Determine if a particular extension parameter is present for the specified key.
`boolean`	`equals(Object o)` Equality does not mean that the fields of the two RoutingRequests are identical, but that they will produce the same SPT.
`void`	`freezeTraverseMode()` only allow traversal by the specified mode; don't allow walking bikes.
`int`	`getAlightTime(TraverseMode transitMode)`
`int`	`getBoardCost(TraverseMode mode)`
`int`	`getBoardCostLowerBound()`
`int`	`getBoardTime(TraverseMode transitMode)`
`Date`	`getDateTime()`
`<T> T`	`getExtension(Object key)` Get the extension parameter with the specified key.
`NamedPlace`	`getFromPlace()`
`IntersectionTraversalCostModel`	`getIntersectionTraversalCostModel()` Returns the model that computes the cost of intersection traversal.
`double`	`getMaxWalkDistance()`
`ShortestPathTree`	`getNewShortestPathTree()` Create a new ShortestPathTree instance using the DominanceFunction specified in this RoutingRequest.
`int`	`getNumItineraries()`
`Comparator<GraphPath>`	`getPathComparator(boolean compareStartTimes)`
`RoutingContext`	`getRoutingContext()`
`long`	`getSecondsSinceEpoch()`
`double`	`getSpeed(TraverseMode mode)`
`double`	`getStreetSpeedUpperBound()`
`NamedPlace`	`getToPlace()`
`double`	`getTransitSpeedUpperBound()` Get the maximum expected speed over all transit modes.
`int`	`hashCode()` Equality and hashCode should not consider the routing context, to allow SPT caching.
`boolean`	`hasIntermediatePlaces()` Returns true if there are any intermediate places set.
`long`	`preferencesPenaltyForRoute(Route route)` Check if route is preferred according to this request.
`void`	`putExtension(Object key, Object value)` Add an extension parameter with the specified key.
`void`	`removeMode(TraverseMode mode)`
`void`	`resetClockTime()`
`RoutingRequest`	`reversedClone()`
`boolean`	`routeIsBanned(Route route)`
`void`	`setArriveBy(boolean arriveBy)`
`void`	`setBannedAgencies(String s)`
`void`	`setBannedRoutes(String s)`
`void`	`setBannedStops(String s)`
`void`	`setBannedStopsHard(String s)`
`void`	`setBikeBoardCost(int bikeBoardCost)`
`void`	`setDateTime(Date dateTime)`
`void`	`setDateTime(String date, String time, TimeZone tz)`
`void`	`setDummyRoutingContext(Graph graph)` Used in internals API.
`void`	`setFromString(String from)`
`void`	`setIntermediatePlacesFromStrings(List<String> intermediates)` Sets intermediatePlaces by parsing GenericLocations from a list of string.
`void`	`setMaxPreTransitTime(int maxPreTransitTime)`
`void`	`setMaxWalkDistance(double maxWalkDistance)`
`void`	`setMode(TraverseMode mode)`
`void`	`setModes(TraverseModeSet modes)`
`void`	`setNumItineraries(int numItineraries)`
`void`	`setOptimize(OptimizeType optimize)`
`void`	`setOtherThanPreferredRoutesPenalty(int penalty)`
`void`	`setPreferredAgencies(String s)`
`void`	`setPreferredRoutes(String s)`
`void`	`setRoutingContext(Graph graph)`
`void`	`setRoutingContext(Graph graph, Collection<Vertex> temporaryVertices)`
`void`	`setRoutingContext(Graph graph, Edge fromBackEdge, Vertex from, Vertex to)` For use in tests.
`void`	`setRoutingContext(Graph graph, String from, String to)` For use in tests.
`void`	`setRoutingContext(Graph graph, Vertex from, Vertex to)`
`void`	`setServiceDayLookout(int serviceDayLookout)`
`void`	`setToString(String to)`
`void`	`setTriangleNormalized(double safe, double slope, double time)` Sets the bicycle triangle routing parameters -- the relative importance of safety, flatness, and speed.
`void`	`setTriangleSafetyFactor(double triangleSafetyFactor)`
`void`	`setTriangleSlopeFactor(double triangleSlopeFactor)`
`void`	`setTriangleTimeFactor(double triangleTimeFactor)`
`void`	`setUnpreferredAgencies(String s)`
`void`	`setUnpreferredRoutes(String s)`
`void`	`setWaitAtBeginningFactor(double waitAtBeginningFactor)`
`void`	`setWaitReluctance(double waitReluctance)`
`void`	`setWalkBoardCost(int walkBoardCost)`
`void`	`setWalkReluctance(double walkReluctance)`
`void`	`setWheelchairAccessible(boolean wheelchairAccessible)`
`void`	`setWhiteListedAgencies(String s)`
`void`	`setWhiteListedRoutes(String s)`
`String`	`toString()`
`String`	`toString(String sep)`
`boolean`	`transitAllowed()`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - traversalCostModel
```
public IntersectionTraversalCostModel traversalCostModel
```
    The model that computes turn/traversal costs. TODO: move this to the Router or the Graph if it doesn't clutter the code too much
  - parameters
```
public final HashMap<String,String> parameters
```
    The complete list of incoming query parameters.
  - routerId
```
public String routerId
```
    The router ID -- internal ID to switch between router implementation (or graphs)
  - from
```
public GenericLocation from
```
    The start location
  - to
```
public GenericLocation to
```
    The end location
  - intermediatePlaces
```
public List<GenericLocation> intermediatePlaces
```
    An ordered list of intermediate locations to be visited.
  - maxWalkDistance
```
public double maxWalkDistance
```
    The maximum distance (in meters) the user is willing to walk for access/egress legs. Defaults to unlimited.
  - maxTransferWalkDistance
```
public double maxTransferWalkDistance
```
    The maximum distance (in meters) the user is willing to walk for transfer legs. Defaults to unlimited. Currently set to be the same value as maxWalkDistance.
  - maxPreTransitTime
```
public int maxPreTransitTime
```
    The maximum time (in seconds) of pre-transit travel when using drive-to-transit (park and ride or kiss and ride). By default limited to 30 minutes driving, because if it's unlimited on large graphs the search becomes very slow.
  - worstTime
```
public long worstTime
```
    The worst possible time (latest for depart-by and earliest for arrive-by) to accept
  - maxWeight
```
public double maxWeight
```
    The worst possible weight that we will accept when planning a trip.
  - maxHours
```
public double maxHours
```
    The maximum duration of a returned itinerary, in hours.
  - useRequestedDateTimeInMaxHours
```
public boolean useRequestedDateTimeInMaxHours
```
    Whether maxHours limit should consider wait/idle time between the itinerary and the requested arrive/depart time.
  - modes
```
public TraverseModeSet modes
```
    The set of TraverseModes that a user is willing to use. Defaults to WALK | TRANSIT.
  - optimize
```
public OptimizeType optimize
```
    The set of characteristics that the user wants to optimize for -- defaults to QUICK, or optimize for transit time.
  - dateTime
```
public long dateTime
```
    The epoch date/time that the trip should depart (or arrive, for requests where arriveBy is true)
  - arriveBy
```
public boolean arriveBy
```
    Whether the trip should depart at dateTime (false, the default), or arrive at dateTime.
  - wheelchairAccessible
```
public boolean wheelchairAccessible
```
    Whether the trip must be wheelchair accessible.
  - numItineraries
```
public int numItineraries
```
    The maximum number of itineraries to return.
  - maxSlope
```
public double maxSlope
```
    The maximum slope of streets for wheelchair trips.
  - showIntermediateStops
```
public boolean showIntermediateStops
```
    Whether the planner should return intermediate stops lists for transit legs.
  - walkSpeed
```
public double walkSpeed
```
    max walk/bike speed along streets, in meters per second
  - bikeSpeed
```
public double bikeSpeed
```
  - carSpeed
```
public double carSpeed
```
  - locale
```
public Locale locale
```
  - transferPenalty
```
public int transferPenalty
```
    An extra penalty added on transfers (i.e. all boardings except the first one). Not to be confused with bikeBoardCost and walkBoardCost, which are the cost of boarding a vehicle with and without a bicycle. The boardCosts are used to model the 'usual' perceived cost of using a transit vehicle, and the transferPenalty is used when a user requests even less transfers. In the latter case, we don't actually optimize for fewest transfers, as this can lead to absurd results. Consider a trip in New York from Grand Army Plaza (the one in Brooklyn) to Kalustyan's at noon. The true lowest transfers route is to wait until midnight, when the 4 train runs local the whole way. The actual fastest route is the 2/3 to the 4/5 at Nevins to the 6 at Union Square, which takes half an hour. Even someone optimizing for fewest transfers doesn't want to wait until midnight. Maybe they would be willing to walk to 7th Ave and take the Q to Union Square, then transfer to the 6. If this takes less than optimize_transfer_penalty seconds, then that's what we'll return.
  - walkReluctance
```
public double walkReluctance
```
    A multiplier for how bad walking is, compared to being in transit for equal lengths of time. Defaults to 2. Empirically, values between 10 and 20 seem to correspond well to the concept of not wanting to walk too much without asking for totally ridiculous itineraries, but this observation should in no way be taken as scientific or definitive. Your mileage may vary.
  - stairsReluctance
```
public double stairsReluctance
```
    Used instead of walk reluctance for stairs
  - turnReluctance
```
public double turnReluctance
```
    Multiplicative factor on expected turning time.
  - elevatorBoardTime
```
public int elevatorBoardTime
```
    How long does it take to get an elevator, on average (actually, it probably should be a bit *more* than average, to prevent optimistic trips)? Setting it to "seems like forever," while accurate, will probably prevent OTP from working correctly.
  - elevatorBoardCost
```
public int elevatorBoardCost
```
    What is the cost of boarding an elevator?
  - elevatorHopTime
```
public int elevatorHopTime
```
    How long does it take to advance one floor on an elevator?
  - elevatorHopCost
```
public int elevatorHopCost
```
    What is the cost of travelling one floor on an elevator?
  - bikeSwitchTime
```
public int bikeSwitchTime
```
    Time to get on and off your own bike
  - bikeSwitchCost
```
public int bikeSwitchCost
```
    Cost of getting on and off your own bike
  - bikeRentalPickupTime
```
public int bikeRentalPickupTime
```
    Time to rent a bike
  - bikeRentalPickupCost
```
public int bikeRentalPickupCost
```
    Cost of renting a bike. The cost is a bit more than actual time to model the associated cost and trouble.
  - bikeRentalDropoffTime
```
public int bikeRentalDropoffTime
```
    Time to drop-off a rented bike
  - bikeRentalDropoffCost
```
public int bikeRentalDropoffCost
```
    Cost of dropping-off a rented bike
  - bikeParkTime
```
public int bikeParkTime
```
    Time to park a bike
  - bikeParkCost
```
public int bikeParkCost
```
    Cost of parking a bike.
  - carDropoffTime
```
public int carDropoffTime
```
    Time to park a car in a park and ride, w/o taking into account driving and walking cost (time to park, switch off, pick your stuff, lock the car, etc...)
  - waitReluctance
```
public double waitReluctance
```
    How much worse is waiting for a transit vehicle than being on a transit vehicle, as a multiplier. The default value treats wait and on-vehicle time as the same. It may be tempting to set this higher than walkReluctance (as studies often find this kind of preferences among riders) but the planner will take this literally and walk down a transit line to avoid waiting at a stop. This used to be set less than 1 (0.95) which would make waiting offboard preferable to waiting onboard in an interlined trip. That is also undesirable. If we only tried the shortest possible transfer at each stop to neighboring stop patterns, this problem could disappear.
  - waitAtBeginningFactor
```
public double waitAtBeginningFactor
```
    How much less bad is waiting at the beginning of the trip (replaces waitReluctance on the first boarding)
  - walkBoardCost
```
public int walkBoardCost
```
    This prevents unnecessary transfers by adding a cost for boarding a vehicle.
  - bikeBoardCost
```
public int bikeBoardCost
```
    Separate cost for boarding a vehicle with a bicycle, which is more difficult than on foot.
  - bannedRoutes
```
public RouteMatcher bannedRoutes
```
    Do not use certain named routes. The paramter format is: feedId_routeId,feedId_routeId,feedId_routeId This parameter format is completely nonstandard and should be revised for the 2.0 API, see issue #1671.
  - whiteListedRoutes
```
public RouteMatcher whiteListedRoutes
```
    Only use certain named routes
  - bannedAgencies
```
public HashSet<String> bannedAgencies
```
    Do not use certain named agencies
  - whiteListedAgencies
```
public HashSet<String> whiteListedAgencies
```
    Only use certain named agencies
  - bannedTrips
```
public HashMap<FeedScopedId,BannedStopSet> bannedTrips
```
    Do not use certain trips
  - bannedStops
```
public StopMatcher bannedStops
```
    Do not use certain stops. See for more information the bannedStops property in the RoutingResource class.
  - bannedStopsHard
```
public StopMatcher bannedStopsHard
```
    Do not use certain stops. See for more information the bannedStopsHard property in the RoutingResource class.
  - preferredRoutes
```
public RouteMatcher preferredRoutes
```
    Set of preferred routes by user.
  - preferredAgencies
```
public HashSet<String> preferredAgencies
```
    Set of preferred agencies by user.
  - otherThanPreferredRoutesPenalty
```
public int otherThanPreferredRoutesPenalty
```
    Penalty added for using every route that is not preferred if user set any route as preferred. We return number of seconds that we are willing to wait for preferred route.
  - unpreferredRoutes
```
public RouteMatcher unpreferredRoutes
```
    Set of unpreferred routes for given user.
  - unpreferredAgencies
```
public HashSet<String> unpreferredAgencies
```
    Set of unpreferred agencies for given user.
  - useUnpreferredRoutesPenalty
```
public int useUnpreferredRoutesPenalty
```
    Penalty added for using every unpreferred route. We return number of seconds that we are willing to wait for preferred route.
  - transferSlack
```
public int transferSlack
```
    A global minimum transfer time (in seconds) that specifies the minimum amount of time that must pass between exiting one transit vehicle and boarding another. This time is in addition to time it might take to walk between transit stops. This time should also be overridden by specific transfer timing information in transfers.txt
  - boardSlack
```
public int boardSlack
```
    Invariant: boardSlack + alightSlack <= transferSlack.
  - alightSlack
```
public int alightSlack
```
  - maxTransfers
```
public int maxTransfers
```
  - extensions
```
public Map<Object,Object> extensions
```
    Extensions to the trip planner will require additional traversal options beyond the default set. We provide an extension point for adding arbitrary parameters with an extension-specific key.
  - nonpreferredTransferPenalty
```
public int nonpreferredTransferPenalty
```
    Penalty for using a non-preferred transfer
  - triangleTimeFactor
```
public double triangleTimeFactor
```
    For the bike triangle, how important time is. triangleTimeFactor+triangleSlopeFactor+triangleSafetyFactor == 1
  - triangleSlopeFactor
```
public double triangleSlopeFactor
```
    For the bike triangle, how important slope is
  - triangleSafetyFactor
```
public double triangleSafetyFactor
```
    For the bike triangle, how important safety is
  - bikeWalkingOptions
```
public RoutingRequest bikeWalkingOptions
```
    Options specifically for the case that you are walking a bicycle.
  - reverseOptimizing
```
public boolean reverseOptimizing
```
    This is true when a GraphPath is being traversed in reverse for optimization purposes.
  - batch
```
public boolean batch
```
    when true, do not use goal direction or stop at the target, build a full SPT
  - useBikeRentalAvailabilityInformation
```
public boolean useBikeRentalAvailabilityInformation
```
    Whether or not bike rental availability information will be used to plan bike rental trips
  - clampInitialWait
```
public long clampInitialWait
```
    The maximum wait time in seconds the user is willing to delay trip start. Only effective in Analyst.
  - reverseOptimizeOnTheFly
```
public boolean reverseOptimizeOnTheFly
```
    When true, reverse optimize this search on the fly whenever needed, rather than reverse-optimizing the entire path when it's done.
  - compactLegsByReversedSearch
```
public boolean compactLegsByReversedSearch
```
    When true, do a full reversed search to compact the legs of the GraphPath.
  - driveOnRight
```
public boolean driveOnRight
```
    If true, cost turns as they would be in a country where driving occurs on the right; otherwise, cost them as they would be in a country where driving occurs on the left.
  - carDecelerationSpeed
```
public double carDecelerationSpeed
```
    The deceleration speed of an automobile, in meters per second per second.
  - carAccelerationSpeed
```
public double carAccelerationSpeed
```
    The acceleration speed of an automobile, in meters per second per second.
  - ignoreRealtimeUpdates
```
public boolean ignoreRealtimeUpdates
```
    When true, realtime updates are ignored during this search.
  - disableRemainingWeightHeuristic
```
public boolean disableRemainingWeightHeuristic
```
    If true, the remaining weight heuristic is disabled. Currently only implemented for the long distance path service.
  - flexFlagStopExtraPenalty
```
public int flexFlagStopExtraPenalty
```
    Extra penalty added for flag-stop boarding/alighting. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. In GTFS-Flex, a flag stop is a point at which a vehicle is boarded or alighted which is not a defined stop, e.g. the bus is flagged down in between stops. This parameter is an additional cost added when a board/alight occurs at a flag stop. Increasing this parameter increases the cost of using a flag stop relative to a regular scheduled stop.
  - flexDeviatedRouteExtraPenalty
```
public int flexDeviatedRouteExtraPenalty
```
    Extra penalty added for deviated-route boarding/alighting. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. In GTFS-Flex, deviated-route service is when a vehicle can deviate a certain distance (or within a certain area) in order to drop off or pick up a passenger. This parameter is an additional cost added when a board/alight occurs before/after a deviation. Increasing this parameter increases the cost of using deviated-route service relative to fixed-route.
  - flexCallAndRideReluctance
```
public double flexCallAndRideReluctance
```
    Reluctance for call-n-ride. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. Call-and-ride service is when a vehicle picks up and drops off a passenger at their origin and destination, without regard to a fixed route. In the GTFS-Flex data standard, call-and- ride service is defined analogously to deviated-route service, but with more permissive parameters. Depending on the particular origin and destination and the size of the area in which a route can deviate, a single route could be used for both deviated-route and call- and-ride service. This parameter is multiplied with the time on board call-and-ride in order to increase the cost of call-and-ride's use relative to normal transit.
  - flexMaxCallAndRideSeconds
```
public int flexMaxCallAndRideSeconds
```
    Total time which can be spent on a call-n-ride leg. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. "Trip-banning" as a method of obtaining different itinerary results does not work for call- and-ride service: the same trip can be used in different ways, for example to drop off a passenger at different transfer points. Thus, rather than trip-banning, after each itinerary is found, flexMaxCallAndRideSeconds is reduced in order to obtain different itineraries. The new value of the parameter to calculated according to the following formula: min(duration - options.flexReduceCallAndRideSeconds, duration * flexReduceCallAndRideRatio)
  - flexReduceCallAndRideSeconds
```
public int flexReduceCallAndRideSeconds
```
    Control the reduction of call-and-ride time. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. Seconds to reduce flexMaxCallAndRideSeconds after a complete call-n-ride itinerary. The rationale for this parameter is given in the docs for flexMaxCallAndRideSeconds.
  - flexReduceCallAndRideRatio
```
public double flexReduceCallAndRideRatio
```
    Control the reduction of call-and-ride time. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. Percentage to reduce flexMaxCallAndRideSeconds after a complete call-n-ride itinerary. The rationale for this parameter is given in the docs for flexMaxCallAndRideSeconds.
  - flexFlagStopBufferSize
```
public double flexFlagStopBufferSize
```
    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. This allows the UI to specify the length in meters of a segment around flag stops it wants to display, as an indication to the user that the vehicle may be flagged down anywhere on the segment. The backend will supply such a cropped geometry in its response (`Place.flagStopArea`). The segment will be up to flexFlagStopBufferSize meters ahead or behind the board/alight location. The actual length may be less if the board/alight location is near the beginning or end of a route.
  - flexUseReservationServices
```
public boolean flexUseReservationServices
```
    Whether to use reservation-based services. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. In GTFS-Flex, some trips may be defined as "reservation services," which indicates that they require a reservation in order to be used. Such services will only be used if this parameter is true.
  - flexUseEligibilityServices
```
public boolean flexUseEligibilityServices
```
    Whether to use eligibility-based services. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. In GTFS-Flex, some trips may be defined as "eligibility services," which indicates that they require customers to meet a certain set of requirements in order to be used. Such services will only be used if this parameter is true.
  - flexIgnoreDrtAdvanceBookMin
```
public boolean flexIgnoreDrtAdvanceBookMin
```
    Whether to ignore DRT time limits. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router-config.json. In GTFS-Flex, deviated-route and call-and-ride service can define a trip-level parameter `drt_advance_book_min`, which determines how far in advance the flexible segment must be scheduled. If `flexIgnoreDrtAdvanceBookMin = false`, OTP will only provide itineraries which are feasible based on that constraint. For example, if the current time is 1:00pm and a particular service must be scheduled one hour in advance, the earliest time the service is usable is 2:00pm.
  - rctx
```
public RoutingContext rctx
```
    The routing context used to actually carry out this search. It is important to build States from TraverseOptions rather than RoutingContexts,and just keep a reference to the context in the TraverseOptions, rather than using RoutingContexts for everything because in some testing and graph building situations we need to build a bunch of initial states with different times and vertices from a single TraverseOptions, without setting all the transit context or building temporary vertices (with all the exception-throwing checks that entails). While they are conceptually separate, TraverseOptions does maintain a reference to its accompanying RoutingContext (and vice versa) so that both do not need to be passed/injected separately into tight inner loops within routing algorithms. These references should be set to null when the request scope is torn down -- the routing context becomes irrelevant at that point, since temporary graph elements have been removed and the graph may have been reloaded.
  - startingTransitStopId
```
public FeedScopedId startingTransitStopId
```
    A transit stop that this trip must start from
  - startingTransitTripId
```
public FeedScopedId startingTransitTripId
```
    A trip where this trip must start from (depart-onboard routing)
  - walkingBike
```
public boolean walkingBike
```
  - softWalkLimiting
```
public boolean softWalkLimiting
```
  - softPreTransitLimiting
```
public boolean softPreTransitLimiting
```
  - softWalkPenalty
```
public double softWalkPenalty
```
  - softWalkOverageRate
```
public double softWalkOverageRate
```
  - preTransitPenalty
```
public double preTransitPenalty
```
  - preTransitOverageRate
```
public double preTransitOverageRate
```
  - allowBikeRental
```
public boolean allowBikeRental
```
  - bikeParkAndRide
```
public boolean bikeParkAndRide
```
  - parkAndRide
```
public boolean parkAndRide
```
  - kissAndRide
```
public boolean kissAndRide
```
  - longDistance
```
public boolean longDistance
```
  - useTraffic
```
public boolean useTraffic
```
    Should traffic congestion be considered when driving?
  - dominanceFunction
```
public DominanceFunction dominanceFunction
```
    The function that compares paths converging on the same vertex to decide which ones continue to be explored.
  - onlyTransitTrips
```
public boolean onlyTransitTrips
```
    Accept only paths that use transit (no street-only paths).
  - disableAlertFiltering
```
public boolean disableAlertFiltering
```
    Option to disable the default filtering of GTFS-RT alerts by time.
  - geoidElevation
```
public boolean geoidElevation
```
    Whether to apply the ellipsoid->geoid offset to all elevations in the response
  - serviceDayLookout
```
public int serviceDayLookout
```
    How many extra ServiceDays to look in the future (or back, if arriveBy=true) This parameter allows the configuration of how far, in service days, OTP should look for transit service when evaluating the next departure (or arrival) at a stop. In some cases, for example for services which run weekly or monthly, it may make sense to increase this value. Larger values will increase the search time. This does not affect a case where a trip starts multiple service days in the past (e.g. a multiday ferry trip will not be board-able after the 2nd day in the current implementation).
  - pathComparator
```
public String pathComparator
```
    Which path comparator to use
  - enterStationsWithCar
```
public boolean enterStationsWithCar
```
    This parameter is used in GTFS-Flex routing. Preliminary searches before the main search need to be able to discover TransitStops in order to create call-and-ride legs which allow transfers to fixed-route services.
  - flexMinPartialHopLength
```
public int flexMinPartialHopLength
```
    Minimum length in meters of partial hop edges. This parameter only applies to GTFS-Flex routing, which must be explicitly turned on via the useFlexService parameter in router- config.json. Flag stop and deviated-route service require creating partial PatternHops from points along the route to a scheduled stop. This parameter provides a minimum length of such partial hops, in order to reduce the amount of hops created when they redundant with regular service.
  - clockTimeSec
```
public long clockTimeSec
```
    Keep track of epoch time the request was created by OTP. This is currently only used by the GTFS-Flex implementation. In GTFS-Flex, deviated-route and call-and-ride service can define a trip-level parameter `drt_advance_book_min`, which determines how far in advance the flexible segment must be scheduled. If `flexIgnoreDrtAdvanceBookMin = false`, OTP will only provide itineraries which are feasible based on that constraint. For example, if the current time is 1:00pm and a particular service must be scheduled one hour in advance, the earliest time the service is usable is 2:00pm.
  - MIN_SIMILARITY
```
public static final int MIN_SIMILARITY
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RoutingRequest
```
public RoutingRequest()
```
    Constructor for options; modes defaults to walk and transit
  - RoutingRequest
```
public RoutingRequest(TraverseModeSet modes)
```
  - RoutingRequest
```
public RoutingRequest(QualifiedModeSet qmodes)
```
  - RoutingRequest
```
public RoutingRequest(String qmodes)
```
  - RoutingRequest
```
public RoutingRequest(TraverseMode mode)
```
  - RoutingRequest
```
public RoutingRequest(TraverseMode mode,
                      OptimizeType optimize)
```
  - RoutingRequest
```
public RoutingRequest(TraverseModeSet modeSet,
                      OptimizeType optimize)
```
- Method Detail
  - transitAllowed
```
public boolean transitAllowed()
```
  - getSecondsSinceEpoch
```
public long getSecondsSinceEpoch()
```
  - setArriveBy
```
public void setArriveBy(boolean arriveBy)
```
  - setMode
```
public void setMode(TraverseMode mode)
```
  - setModes
```
public void setModes(TraverseModeSet modes)
```
  - setOptimize
```
public void setOptimize(OptimizeType optimize)
```
  - setWheelchairAccessible
```
public void setWheelchairAccessible(boolean wheelchairAccessible)
```
  - freezeTraverseMode
```
public void freezeTraverseMode()
```
    only allow traversal by the specified mode; don't allow walking bikes. This is used during contraction to reduce the number of possible paths.
  - putExtension
```
public void putExtension(Object key,
                         Object value)
```
    Add an extension parameter with the specified key. Extensions allow you to add arbitrary traversal options.
  - containsExtension
```
public boolean containsExtension(Object key)
```
    Determine if a particular extension parameter is present for the specified key.
  - getExtension
```
public <T> T getExtension(Object key)
```
    Get the extension parameter with the specified key.
  - getIntersectionTraversalCostModel
```
public IntersectionTraversalCostModel getIntersectionTraversalCostModel()
```
    Returns the model that computes the cost of intersection traversal.
  - getMaxWalkDistance
```
public double getMaxWalkDistance()
```
    Returns:
    
    the (soft) maximum walk distance
  - setWalkBoardCost
```
public void setWalkBoardCost(int walkBoardCost)
```
  - setBikeBoardCost
```
public void setBikeBoardCost(int bikeBoardCost)
```
  - setPreferredAgencies
```
public void setPreferredAgencies(String s)
```
  - setPreferredRoutes
```
public void setPreferredRoutes(String s)
```
  - setOtherThanPreferredRoutesPenalty
```
public void setOtherThanPreferredRoutesPenalty(int penalty)
```
  - setUnpreferredAgencies
```
public void setUnpreferredAgencies(String s)
```
  - setUnpreferredRoutes
```
public void setUnpreferredRoutes(String s)
```
  - setBannedRoutes
```
public void setBannedRoutes(String s)
```
  - setWhiteListedRoutes
```
public void setWhiteListedRoutes(String s)
```
  - setBannedStops
```
public void setBannedStops(String s)
```
  - setBannedStopsHard
```
public void setBannedStopsHard(String s)
```
  - setBannedAgencies
```
public void setBannedAgencies(String s)
```
  - setWhiteListedAgencies
```
public void setWhiteListedAgencies(String s)
```
  - setFromString
```
public void setFromString(String from)
```
  - setToString
```
public void setToString(String to)
```
  - clearModes
```
public void clearModes()
```
    Clear the allowed modes.
  - addMode
```
public void addMode(TraverseMode mode)
```
    Add a TraverseMode to the set of allowed modes.
  - addMode
```
public void addMode(List<TraverseMode> mList)
```
    Add multiple modes to the set of allowed modes.
  - getDateTime
```
public Date getDateTime()
```
  - setDateTime
```
public void setDateTime(Date dateTime)
```
  - setDateTime
```
public void setDateTime(String date,
                        String time,
                        TimeZone tz)
```
  - getNumItineraries
```
public int getNumItineraries()
```
  - setNumItineraries
```
public void setNumItineraries(int numItineraries)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(String sep)
```
  - removeMode
```
public void removeMode(TraverseMode mode)
```
  - setIntermediatePlacesFromStrings
```
public void setIntermediatePlacesFromStrings(List<String> intermediates)
```
    Sets intermediatePlaces by parsing GenericLocations from a list of string.
  - clearIntermediatePlaces
```
public void clearIntermediatePlaces()
```
    Clears any intermediate places from this request.
  - hasIntermediatePlaces
```
public boolean hasIntermediatePlaces()
```
    Returns true if there are any intermediate places set.
  - addIntermediatePlace
```
public void addIntermediatePlace(GenericLocation location)
```
    Adds a GenericLocation to the end of the intermediatePlaces list. Will initialize intermediatePlaces if it is null.
  - setTriangleSafetyFactor
```
public void setTriangleSafetyFactor(double triangleSafetyFactor)
```
  - setTriangleSlopeFactor
```
public void setTriangleSlopeFactor(double triangleSlopeFactor)
```
  - setTriangleTimeFactor
```
public void setTriangleTimeFactor(double triangleTimeFactor)
```
  - getFromPlace
```
public NamedPlace getFromPlace()
```
  - getToPlace
```
public NamedPlace getToPlace()
```
  - clone
```
public RoutingRequest clone()
```
    Overrides:
    
    clone in class Object
  - reversedClone
```
public RoutingRequest reversedClone()
```
  - setRoutingContext
```
public void setRoutingContext(Graph graph,
                              Collection<Vertex> temporaryVertices)
```
  - setRoutingContext
```
public void setRoutingContext(Graph graph)
```
  - setRoutingContext
```
public void setRoutingContext(Graph graph,
                              Edge fromBackEdge,
                              Vertex from,
                              Vertex to)
```
    For use in tests. Force RoutingContext to specific vertices rather than making temp edges.
  - setRoutingContext
```
public void setRoutingContext(Graph graph,
                              Vertex from,
                              Vertex to)
```
  - setRoutingContext
```
public void setRoutingContext(Graph graph,
                              String from,
                              String to)
```
    For use in tests. Force RoutingContext to specific vertices rather than making temp edges.
  - setDummyRoutingContext
```
public void setDummyRoutingContext(Graph graph)
```
    Used in internals API. Make a RoutingContext with no origin or destination vertices specified.
  - getRoutingContext
```
public RoutingContext getRoutingContext()
```
  - equals
```
public boolean equals(Object o)
```
    Equality does not mean that the fields of the two RoutingRequests are identical, but that they will produce the same SPT. This is particularly important when the batch field is set to 'true'. Does not consider the RoutingContext, to allow SPT caching. Intermediate places are also not included because the TSP solver will factor a single intermediate places routing request into several routing requests without intermediates before searching.
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Equality and hashCode should not consider the routing context, to allow SPT caching. When adding fields to the hash code, pick a random large prime number that's not yet in use.
    
    Overrides:
    
    hashCode in class Object
  - cleanup
```
public void cleanup()
```
    Tear down any routing context (remove temporary edges from edge lists)
  - getSpeed
```
public double getSpeed(TraverseMode mode)
```
    Parameters:
    
    mode -
    
    Returns:
    
    The road speed for a specific traverse mode.
  - getStreetSpeedUpperBound
```
public double getStreetSpeedUpperBound()
```
    Returns:
    
    The highest speed for all possible road-modes.
  - getBoardCost
```
public int getBoardCost(TraverseMode mode)
```
    Parameters:
    
    mode -
    
    Returns:
    
    The board cost for a specific traverse mode.
  - getBoardCostLowerBound
```
public int getBoardCostLowerBound()
```
    Returns:
    
    The lower boarding cost for all possible road-modes.
  - getBoardTime
```
public int getBoardTime(TraverseMode transitMode)
```
    Returns:
    
    The time it actually takes to board a vehicle. Could be significant eg. on airplanes and ferries
  - getAlightTime
```
public int getAlightTime(TraverseMode transitMode)
```
    Returns:
    
    The time it actually takes to alight a vehicle. Could be significant eg. on airplanes and ferries
  - setMaxWalkDistance
```
public void setMaxWalkDistance(double maxWalkDistance)
```
  - setMaxPreTransitTime
```
public void setMaxPreTransitTime(int maxPreTransitTime)
```
  - setWalkReluctance
```
public void setWalkReluctance(double walkReluctance)
```
  - setWaitReluctance
```
public void setWaitReluctance(double waitReluctance)
```
  - setWaitAtBeginningFactor
```
public void setWaitAtBeginningFactor(double waitAtBeginningFactor)
```
  - banTrip
```
public void banTrip(FeedScopedId trip)
```
  - routeIsBanned
```
public boolean routeIsBanned(Route route)
```
  - preferencesPenaltyForRoute
```
public long preferencesPenaltyForRoute(Route route)
```
    Check if route is preferred according to this request.
  - getTransitSpeedUpperBound
```
public double getTransitSpeedUpperBound()
```
    Get the maximum expected speed over all transit modes. TODO derive actual speeds from GTFS feeds. On the other hand, that's what the bidirectional heuristic does on the fly.
  - setTriangleNormalized
```
public void setTriangleNormalized(double safe,
                                  double slope,
                                  double time)
```
    Sets the bicycle triangle routing parameters -- the relative importance of safety, flatness, and speed. These three fields of the RoutingRequest should have values between 0 and 1, and should add up to 1. This setter function accepts any three numbers and will normalize them to add up to 1.
  - getNewShortestPathTree
```
public ShortestPathTree getNewShortestPathTree()
```
    Create a new ShortestPathTree instance using the DominanceFunction specified in this RoutingRequest.
  - canSplitEdge
```
public void canSplitEdge(StreetEdge edge)
```
    Does nothing if different edge is split in origin/destination search But throws TrivialPathException if same edge is split in origin/destination search. used in SimpleStreetSplitter in SimpleStreetSplitter.link(Vertex, StreetEdge, double, RoutingRequest)
    
    Parameters:
    
    edge -
  - resetClockTime
```
public void resetClockTime()
```
  - setServiceDayLookout
```
public void setServiceDayLookout(int serviceDayLookout)
```
  - getPathComparator
```
public Comparator<GraphPath> getPathComparator(boolean compareStartTimes)
```

Class RoutingRequest

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

traversalCostModel

parameters

routerId

from

to

intermediatePlaces

maxWalkDistance

maxTransferWalkDistance

maxPreTransitTime

worstTime

maxWeight

maxHours

useRequestedDateTimeInMaxHours

modes

optimize

dateTime

arriveBy

wheelchairAccessible

numItineraries

maxSlope

showIntermediateStops

walkSpeed

bikeSpeed

carSpeed

locale

transferPenalty

walkReluctance

stairsReluctance

turnReluctance

elevatorBoardTime

elevatorBoardCost

elevatorHopTime

elevatorHopCost

bikeSwitchTime

bikeSwitchCost

bikeRentalPickupTime

bikeRentalPickupCost

bikeRentalDropoffTime

bikeRentalDropoffCost

bikeParkTime

bikeParkCost

carDropoffTime

waitReluctance

waitAtBeginningFactor

walkBoardCost

bikeBoardCost

bannedRoutes

whiteListedRoutes

bannedAgencies

whiteListedAgencies

bannedTrips

bannedStops

bannedStopsHard

preferredRoutes

preferredAgencies

otherThanPreferredRoutesPenalty

unpreferredRoutes

unpreferredAgencies

useUnpreferredRoutesPenalty

transferSlack

boardSlack

alightSlack

maxTransfers

extensions

nonpreferredTransferPenalty

triangleTimeFactor

triangleSlopeFactor

triangleSafetyFactor

bikeWalkingOptions

reverseOptimizing

batch

useBikeRentalAvailabilityInformation

clampInitialWait

reverseOptimizeOnTheFly