use of org.opentripplanner.routing.edgetype.OnBoardDepartPatternHop in project OpenTripPlanner by opentripplanner.
the class OnBoardDepartServiceImpl method setupDepartOnBoard.
@Override
public Vertex setupDepartOnBoard(RoutingContext ctx) {
RoutingRequest opt = ctx.opt;
opt.rctx = ctx;
/* 1. Get the list of PatternHop for the given trip ID. */
AgencyAndId tripId = opt.startingTransitTripId;
Trip trip = ctx.graph.index.tripForId.get(tripId);
TripPattern tripPattern = ctx.graph.index.patternForTrip.get(trip);
if (tripPattern == null) {
// TODO Shouldn't we bailout on a normal trip plan here, returning null ?
throw new IllegalArgumentException("Unknown/invalid trip ID: " + tripId);
}
List<PatternHop> hops = tripPattern.getPatternHops();
// Origin point, optional
Double lon = opt.from.lng;
Double lat = opt.from.lat;
PatternStopVertex nextStop;
TripTimes bestTripTimes = null;
ServiceDay bestServiceDay = null;
int bestStopIndex = 0;
double fractionCovered;
LineString geomRemaining;
Coordinate point = lon == null || lat == null ? null : new Coordinate(lon, lat);
if (point != null) {
/*
* 2. Get the best hop from the list, given the parameters. Currently look for nearest hop,
* taking into account shape if available. If no shape are present, the computed hop and
* fraction may be a bit away from what it should be.
*/
PatternHop bestHop = null;
double minDist = Double.MAX_VALUE;
for (PatternHop hop : hops) {
LineString line = hop.getGeometry();
double dist = SphericalDistanceLibrary.fastDistance(point, line);
if (dist < minDist) {
minDist = dist;
bestHop = hop;
}
}
if (minDist > 1000)
LOG.warn("On-board depart: origin point suspiciously away from nearest trip shape ({} meters)", minDist);
else
LOG.info("On-board depart: origin point {} meters away from hop shape", minDist);
/*
* 3. Compute the fraction covered percentage of the current hop. This assume a constant
* trip speed alongside the whole hop: this should be quite precise for small hops
* (buses), a bit less for longer ones (long distance train). Shape linear distance is
* of no help here, as the unit is arbitrary (and probably usually a distance).
*/
LineString geometry = bestHop.getGeometry();
P2<LineString> geomPair = GeometryUtils.splitGeometryAtPoint(geometry, point);
geomRemaining = geomPair.second;
double total = SphericalDistanceLibrary.fastLength(geometry);
double remaining = SphericalDistanceLibrary.fastLength(geomRemaining);
fractionCovered = total > 0.0 ? (double) (1.0 - remaining / total) : 0.0;
nextStop = (PatternStopVertex) bestHop.getToVertex();
bestStopIndex = bestHop.getStopIndex();
/*
* 4. Compute service day based on given departure day/time relative to
* scheduled/real-time trip time for hop. This is needed as for some trips any service
* day can apply.
*/
int minDelta = Integer.MAX_VALUE;
int actDelta = 0;
for (ServiceDay serviceDay : ctx.serviceDays) {
TripPattern pattern = nextStop.getTripPattern();
Timetable timetable = pattern.getUpdatedTimetable(opt, serviceDay);
// Get the tripTimes including real-time updates for the serviceDay
TripTimes tripTimes = timetable.getTripTimes(timetable.getTripIndex(tripId));
int depTime = tripTimes.getDepartureTime(bestStopIndex);
int arrTime = tripTimes.getArrivalTime(bestStopIndex + 1);
int estTime = (int) Math.round(depTime * fractionCovered + arrTime * (1 - fractionCovered));
int time = serviceDay.secondsSinceMidnight(opt.dateTime);
/*
* TODO Weight differently early vs late time, as the probability of any transit
* being late is higher than being early. However, this has impact if your bus is
* more than 12h late, I don't think this would happen really often.
*/
int deltaTime = Math.abs(time - estTime);
if (deltaTime < minDelta) {
minDelta = deltaTime;
actDelta = time - estTime;
bestTripTimes = tripTimes;
bestServiceDay = serviceDay;
}
}
if (minDelta > 60000)
// Being more than 1h late should not happen often
LOG.warn("On-board depart: delta between scheduled/real-time and actual time suspiciously large: {} seconds.", actDelta);
else
LOG.info("On-board depart: delta between scheduled/real-time and actual time is {} seconds.", actDelta);
} else {
/* 2. Compute service day */
for (ServiceDay serviceDay : ctx.serviceDays) {
Timetable timetable = tripPattern.getUpdatedTimetable(opt, serviceDay);
// Get the tripTimes including real-time updates for the serviceDay
TripTimes tripTimes = timetable.getTripTimes(timetable.getTripIndex(tripId));
int depTime = tripTimes.getDepartureTime(0);
int arrTime = tripTimes.getArrivalTime(tripTimes.getNumStops() - 1);
int time = serviceDay.secondsSinceMidnight(opt.dateTime);
if (depTime <= time && time <= arrTime) {
bestTripTimes = tripTimes;
bestServiceDay = serviceDay;
}
}
if (bestServiceDay == null) {
throw new RuntimeException("Unable to determine on-board depart service day.");
}
int time = bestServiceDay.secondsSinceMidnight(opt.dateTime);
/*
* 3. Get the best hop from the list, given the parameters. This is done by finding the
* last hop that has not yet departed.
*/
PatternHop bestHop = null;
for (PatternHop hop : hops) {
int stopIndex = hop.getStopIndex();
int depTime = bestTripTimes.getDepartureTime(stopIndex);
int arrTime = bestTripTimes.getArrivalTime(stopIndex + 1);
if (time == arrTime) {
return ctx.graph.getVertex(hop.getEndStop().getId().toString());
} else if (depTime < time) {
bestHop = hop;
bestStopIndex = stopIndex;
} else if (time == depTime || bestTripTimes.getArrivalTime(bestStopIndex + 1) < time) {
return ctx.graph.getVertex(hop.getBeginStop().getId().toString());
} else {
break;
}
}
nextStop = (PatternStopVertex) bestHop.getToVertex();
LineString geometry = bestHop.getGeometry();
/*
* 4. Compute the fraction covered percentage of the current hop. Once again a constant
* trip speed is assumed. The linear distance of the shape is used, so the results are
* not 100% accurate. On the flip side, they are easy to compute and very well testable.
*/
int depTime = bestTripTimes.getDepartureTime(bestStopIndex);
int arrTime = bestTripTimes.getArrivalTime(bestStopIndex + 1);
fractionCovered = ((double) (time - depTime)) / ((double) (arrTime - depTime));
P2<LineString> geomPair = GeometryUtils.splitGeometryAtFraction(geometry, fractionCovered);
geomRemaining = geomPair.second;
if (geometry.isEmpty()) {
lon = Double.NaN;
lat = Double.NaN;
} else {
Coordinate start;
if (geomRemaining.isEmpty()) {
start = geometry.getCoordinateN(geometry.getNumPoints() - 1);
} else {
start = geomRemaining.getCoordinateN(0);
}
lon = start.x;
lat = start.y;
}
}
OnboardDepartVertex onboardDepart = new OnboardDepartVertex("on_board_depart", lon, lat);
OnBoardDepartPatternHop startHop = new OnBoardDepartPatternHop(onboardDepart, nextStop, bestTripTimes, bestServiceDay, bestStopIndex, fractionCovered);
startHop.setGeometry(geomRemaining);
return onboardDepart;
}
use of org.opentripplanner.routing.edgetype.OnBoardDepartPatternHop in project OpenTripPlanner by opentripplanner.
the class TestOnBoardRouting method testOnBoardRouting.
/**
* Compute a set of path between two random stop locations in a test GTFS.
*
* For each departure/arrival location, compute a normal path (depart alighted). Then re-run the
* same itinerary but with departure while on-board at a randomly-picked up trip alongside the
* path.
*
* We assert that the two itineraries will arrive at the same time, at the same place, with at
* least one less boarding, and take a less or equals amount of time.
*/
@SuppressWarnings("deprecation")
public void testOnBoardRouting() throws Exception {
String feedId = graph.getFeedIds().iterator().next();
// Seed the random generator to make consistent set of tests
Random rand = new Random(42);
// Number of tests to run
final int NTESTS = 100;
int n = 0;
while (true) {
/* Compute a normal path between two random stops... */
Vertex origin, destination;
do {
/* See FAKE_GTFS for available locations */
origin = graph.getVertex(feedId + ":" + (char) (65 + rand.nextInt(20)));
destination = graph.getVertex(feedId + ":" + (char) (65 + rand.nextInt(20)));
} while (origin.equals(destination));
/* ...at a random date/time */
RoutingRequest options = new RoutingRequest();
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 5 + rand.nextInt(4), 1 + rand.nextInt(20), 4 + rand.nextInt(10), rand.nextInt(60), 0);
ShortestPathTree spt;
GraphPath path;
options.setRoutingContext(graph, origin, destination);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(destination, false);
if (path == null)
continue;
System.out.println("Testing path between " + origin.getLabel() + " and " + destination.getLabel() + " at " + new Date(options.dateTime * 1000));
long arrivalTime1 = 0L;
long elapsedTime1 = 0L;
int numBoardings1 = 0;
Vertex arrivalVertex1 = null;
if (verbose)
System.out.println("PATH 1 ---------------------");
for (State s : path.states) {
if (verbose)
System.out.println(s + " [" + s.getVertex().getClass().getName() + "]");
arrivalTime1 = s.getTimeSeconds();
arrivalVertex1 = s.getVertex();
elapsedTime1 = s.getElapsedTimeSeconds();
numBoardings1 = s.getNumBoardings();
}
/* Get a random transit hop from the computed path */
Stop end = null;
PatternStopVertex nextV = null;
TripTimes tripTimes = null;
int stopIndex = 0;
long newStart = 0L;
int nhop = 0;
for (State s : path.states) {
if (s.getVertex() instanceof PatternArriveVertex && s.getBackEdge() instanceof PatternHop)
nhop++;
}
int hop = rand.nextInt(nhop);
nhop = 0;
float k = rand.nextFloat();
for (State s : path.states) {
Vertex v = s.getVertex();
if (v instanceof PatternArriveVertex && s.getBackEdge() instanceof PatternHop) {
if (hop == nhop) {
PatternArriveVertex pav = (PatternArriveVertex) v;
end = pav.getStop();
nextV = pav;
PatternHop phe = (PatternHop) s.getBackEdge();
stopIndex = phe.getStopIndex();
tripTimes = s.getTripTimes();
int hopDuration = tripTimes.getRunningTime(stopIndex);
/*
* New start time at k% of hop. Note: do not try to make: round(time +
* k.hop) as it will be off few seconds due to floating-point rounding
* errors.
*/
newStart = s.getBackState().getTimeSeconds() + Math.round(hopDuration * k);
break;
}
nhop++;
}
}
System.out.println("Boarded depart: trip=" + tripTimes.trip + ", nextStop=" + nextV.getStop() + " stopIndex=" + stopIndex + " startTime=" + new Date(newStart * 1000L));
/* And use it for onboard departure */
double lat = end.getLat();
// Mock location, not really important here.
double lon = end.getLon();
OnboardDepartVertex onboardOrigin = new OnboardDepartVertex("OnBoard_Origin", lat, lon);
@SuppressWarnings("unused") OnBoardDepartPatternHop currentHop = new OnBoardDepartPatternHop(onboardOrigin, nextV, tripTimes, options.rctx.serviceDays.get(1), stopIndex, k);
options.dateTime = newStart;
options.setRoutingContext(graph, onboardOrigin, destination);
spt = aStar.getShortestPathTree(options);
/* Re-compute a new path starting boarded */
GraphPath path2 = spt.getPath(destination, false);
assertNotNull(path2);
if (verbose)
System.out.println("PATH 2 ---------------------");
long arrivalTime2 = 0L;
long elapsedTime2 = 0L;
int numBoardings2 = 0;
Vertex arrivalVertex2 = null;
for (State s : path2.states) {
if (verbose)
System.out.println(s + " [" + s.getVertex().getClass().getName() + "]");
arrivalTime2 = s.getTimeSeconds();
arrivalVertex2 = s.getVertex();
elapsedTime2 = s.getElapsedTimeSeconds();
numBoardings2 = s.getNumBoardings();
}
/* Arrival time and vertex *must* match */
assertEquals(arrivalTime1, arrivalTime2);
assertEquals(arrivalVertex1, destination);
assertEquals(arrivalVertex2, destination);
/* On-board *must* be shorter in time */
assertTrue(elapsedTime2 <= elapsedTime1);
/* On-board *must* have less boardings */
assertTrue(numBoardings2 < numBoardings1);
/* Cleanup edges */
for (Edge edge : onboardOrigin.getOutgoing()) {
graph.removeEdge(edge);
}
n++;
if (n > NTESTS)
break;
}
}
use of org.opentripplanner.routing.edgetype.OnBoardDepartPatternHop in project OpenTripPlanner by opentripplanner.
the class GraphPathToTripPlanConverterTest method buildPaths.
/**
* Build three GraphPath objects that can be used for testing for forward, backward and onboard.
* This method doesn't rely on any routing code.
* Leg 0: Walking towards the train station
* Leg 1: First train leg, interlined with leg 2
* Leg 2: Second train leg, interlined with leg 1
* Leg 3: Simple transfer from the train station to the ferry
* Leg 4: Ferry leg
* Leg 5: Walking towards the bike rental station
* Leg 6: Cycling on a rented bike
* Leg 7: Cycling on a rented bike, continued (to demonstrate a {@link LegSwitchingEdge})
* Leg 8: Leaving the bike rental station on foot
* @return An array containing the generated GraphPath objects: forward, then backward, onboard.
*/
private GraphPath[] buildPaths() {
// This set of requested traverse modes implies that bike rental is a possibility.
RoutingRequest options = new RoutingRequest("BICYCLE_RENT,TRANSIT");
String feedId = "FEED";
Graph graph = new Graph();
// Vertices for leg 0
ExitVertex v0 = new ExitVertex(graph, "Vertex 0", 0, 0, 0);
IntersectionVertex v2 = new IntersectionVertex(graph, "Vertex 2", 0, 0);
IntersectionVertex v4 = new IntersectionVertex(graph, "Vertex 4", 1, 1);
// Stops for legs 1, 2 and 4, plus initialization and storage in a list
Stop trainStopDepart = new Stop();
Stop trainStopDwell = new Stop();
Stop trainStopInterline = new Stop();
Stop trainStopArrive = new Stop();
Stop ferryStopDepart = new Stop();
Stop ferryStopArrive = new Stop();
trainStopDepart.setId(new AgencyAndId(feedId, "Depart"));
trainStopDepart.setName("Train stop depart");
trainStopDepart.setLon(1);
trainStopDepart.setLat(1);
trainStopDepart.setCode("Train depart code");
trainStopDepart.setPlatformCode("Train depart platform");
trainStopDepart.setZoneId("Train depart zone");
trainStopDwell.setId(new AgencyAndId(feedId, "Dwell"));
trainStopDwell.setName("Train stop dwell");
trainStopDwell.setLon(45);
trainStopDwell.setLat(23);
trainStopDwell.setCode("Train dwell code");
trainStopDwell.setPlatformCode("Train dwell platform");
trainStopDwell.setZoneId("Train dwell zone");
trainStopInterline.setId(new AgencyAndId(feedId, "Interline"));
trainStopInterline.setName("Train stop interline");
trainStopInterline.setLon(89);
trainStopInterline.setLat(45);
trainStopInterline.setCode("Train interline code");
trainStopInterline.setPlatformCode("Train interline platform");
trainStopInterline.setZoneId("Train interline zone");
trainStopArrive.setId(new AgencyAndId(feedId, "Arrive"));
trainStopArrive.setName("Train stop arrive");
trainStopArrive.setLon(133);
trainStopArrive.setLat(67);
trainStopArrive.setCode("Train arrive code");
trainStopArrive.setPlatformCode("Train arrive platform");
trainStopArrive.setZoneId("Train arrive zone");
ferryStopDepart.setId(new AgencyAndId(feedId, "Depart"));
ferryStopDepart.setName("Ferry stop depart");
ferryStopDepart.setLon(135);
ferryStopDepart.setLat(67);
ferryStopDepart.setCode("Ferry depart code");
ferryStopDepart.setPlatformCode("Ferry depart platform");
ferryStopDepart.setZoneId("Ferry depart zone");
ferryStopArrive.setId(new AgencyAndId(feedId, "Arrive"));
ferryStopArrive.setName("Ferry stop arrive");
ferryStopArrive.setLon(179);
ferryStopArrive.setLat(89);
ferryStopArrive.setCode("Ferry arrive code");
ferryStopArrive.setPlatformCode("Ferry arrive platform");
ferryStopArrive.setZoneId("Ferry arrive zone");
ArrayList<Stop> firstStops = new ArrayList<Stop>();
ArrayList<Stop> secondStops = new ArrayList<Stop>();
ArrayList<Stop> thirdStops = new ArrayList<Stop>();
firstStops.add(trainStopDepart);
firstStops.add(trainStopDwell);
firstStops.add(trainStopInterline);
secondStops.add(trainStopInterline);
secondStops.add(trainStopArrive);
thirdStops.add(ferryStopDepart);
thirdStops.add(ferryStopArrive);
// Agencies for legs 1, 2 and 4, plus initialization
Agency trainAgency = new Agency();
Agency ferryAgency = new Agency();
trainAgency.setId("Train");
trainAgency.setName("John Train");
trainAgency.setUrl("http://www.train.org/");
ferryAgency.setId("Ferry");
ferryAgency.setName("Brian Ferry");
ferryAgency.setUrl("http://www.ferry.org/");
// Routes for legs 1, 2 and 4, plus initialization
Route firstRoute = new Route();
Route secondRoute = new Route();
Route thirdRoute = new Route();
firstRoute.setId(new AgencyAndId(feedId, "A"));
firstRoute.setAgency(trainAgency);
firstRoute.setShortName("A");
firstRoute.setLongName("'A' Train");
firstRoute.setType(2);
firstRoute.setColor("White");
firstRoute.setTextColor("Black");
secondRoute.setId(new AgencyAndId(feedId, "B"));
secondRoute.setAgency(trainAgency);
secondRoute.setShortName("B");
secondRoute.setLongName("Another Train");
secondRoute.setType(2);
secondRoute.setColor("Cyan");
secondRoute.setTextColor("Yellow");
thirdRoute.setId(new AgencyAndId(feedId, "C"));
thirdRoute.setAgency(ferryAgency);
thirdRoute.setShortName("C");
thirdRoute.setLongName("Ferry Cross the Mersey");
thirdRoute.setType(4);
thirdRoute.setColor("Black");
thirdRoute.setTextColor("White");
// Trips for legs 1, 2 and 4, plus initialization
Trip firstTrip = new Trip();
Trip secondTrip = new Trip();
Trip thirdTrip = new Trip();
firstTrip.setId(new AgencyAndId(feedId, "A"));
firstTrip.setTripShortName("A");
firstTrip.setBlockId("Alock");
firstTrip.setRoute(firstRoute);
BikeAccess.setForTrip(firstTrip, BikeAccess.ALLOWED);
firstTrip.setTripHeadsign("Street Fighting Man");
secondTrip.setId(new AgencyAndId(feedId, "B"));
secondTrip.setTripShortName("B");
secondTrip.setBlockId("Block");
secondTrip.setRoute(secondRoute);
BikeAccess.setForTrip(secondTrip, BikeAccess.ALLOWED);
secondTrip.setTripHeadsign("No Expectations");
thirdTrip.setId(new AgencyAndId(feedId, "C"));
thirdTrip.setTripShortName("C");
thirdTrip.setBlockId("Clock");
thirdTrip.setRoute(thirdRoute);
BikeAccess.setForTrip(thirdTrip, BikeAccess.ALLOWED);
thirdTrip.setTripHeadsign("Handsome Molly");
// Scheduled stop times for legs 1, 2 and 4, plus initialization and storage in a list
StopTime trainStopDepartTime = new StopTime();
StopTime trainStopDwellTime = new StopTime();
StopTime trainStopInterlineFirstTime = new StopTime();
StopTime trainStopInterlineSecondTime = new StopTime();
StopTime trainStopArriveTime = new StopTime();
StopTime ferryStopDepartTime = new StopTime();
StopTime ferryStopArriveTime = new StopTime();
trainStopDepartTime.setTrip(firstTrip);
trainStopDepartTime.setStop(trainStopDepart);
trainStopDepartTime.setStopSequence(Integer.MIN_VALUE);
trainStopDepartTime.setDepartureTime(4);
trainStopDepartTime.setPickupType(3);
trainStopDwellTime.setTrip(firstTrip);
trainStopDwellTime.setStop(trainStopDwell);
trainStopDwellTime.setStopSequence(0);
trainStopDwellTime.setArrivalTime(8);
trainStopDwellTime.setDepartureTime(12);
trainStopInterlineFirstTime.setTrip(firstTrip);
trainStopInterlineFirstTime.setStop(trainStopInterline);
trainStopInterlineFirstTime.setStopSequence(Integer.MAX_VALUE);
trainStopInterlineFirstTime.setArrivalTime(16);
trainStopInterlineSecondTime.setTrip(secondTrip);
trainStopInterlineSecondTime.setStop(trainStopInterline);
trainStopInterlineSecondTime.setStopSequence(0);
trainStopInterlineSecondTime.setDepartureTime(20);
trainStopArriveTime.setTrip(secondTrip);
trainStopArriveTime.setStop(trainStopArrive);
trainStopArriveTime.setStopSequence(1);
trainStopArriveTime.setArrivalTime(24);
trainStopArriveTime.setDropOffType(2);
ferryStopDepartTime.setTrip(thirdTrip);
ferryStopDepartTime.setStop(ferryStopDepart);
ferryStopDepartTime.setStopSequence(-1);
ferryStopDepartTime.setDepartureTime(32);
ferryStopDepartTime.setPickupType(2);
ferryStopArriveTime.setTrip(thirdTrip);
ferryStopArriveTime.setStop(ferryStopArrive);
ferryStopArriveTime.setStopSequence(0);
ferryStopArriveTime.setArrivalTime(36);
ferryStopArriveTime.setDropOffType(3);
ArrayList<StopTime> firstStopTimes = new ArrayList<StopTime>();
ArrayList<StopTime> secondStopTimes = new ArrayList<StopTime>();
ArrayList<StopTime> thirdStopTimes = new ArrayList<StopTime>();
firstStopTimes.add(trainStopDepartTime);
firstStopTimes.add(trainStopDwellTime);
firstStopTimes.add(trainStopInterlineFirstTime);
secondStopTimes.add(trainStopInterlineSecondTime);
secondStopTimes.add(trainStopArriveTime);
thirdStopTimes.add(ferryStopDepartTime);
thirdStopTimes.add(ferryStopArriveTime);
// Various patterns that are required to construct a full graph path, plus initialization
StopPattern firstStopPattern = new StopPattern(firstStopTimes);
StopPattern secondStopPattern = new StopPattern(secondStopTimes);
StopPattern thirdStopPattern = new StopPattern(thirdStopTimes);
TripPattern firstTripPattern = new TripPattern(firstRoute, firstStopPattern);
TripPattern secondTripPattern = new TripPattern(secondRoute, secondStopPattern);
TripPattern thirdTripPattern = new TripPattern(thirdRoute, thirdStopPattern);
TripTimes firstTripTimes = new TripTimes(firstTrip, firstStopTimes, new Deduplicator());
TripTimes secondTripTimes = new TripTimes(secondTrip, secondStopTimes, new Deduplicator());
TripTimes thirdTripTimes = new TripTimes(thirdTrip, thirdStopTimes, new Deduplicator());
firstTripPattern.add(firstTripTimes);
secondTripPattern.add(secondTripTimes);
thirdTripPattern.add(thirdTripTimes);
// Vertices for legs 1, 2 and 3
TransitStop v6 = new TransitStop(graph, trainStopDepart);
TransitStopDepart v8 = new TransitStopDepart(graph, trainStopDepart, v6);
// To understand the stop indexes in the vertex constructors, look at firstStopTimes.add() etc. above
PatternDepartVertex v10 = new PatternDepartVertex(graph, firstTripPattern, 0);
PatternArriveVertex v12 = new PatternArriveVertex(graph, firstTripPattern, 1);
PatternDepartVertex v14 = new PatternDepartVertex(graph, firstTripPattern, 1);
PatternArriveVertex v16 = new PatternArriveVertex(graph, firstTripPattern, 2);
PatternDepartVertex v18 = new PatternDepartVertex(graph, secondTripPattern, 0);
PatternArriveVertex v20 = new PatternArriveVertex(graph, secondTripPattern, 1);
TransitStop v24 = new TransitStop(graph, trainStopArrive);
TransitStopArrive v22 = new TransitStopArrive(graph, trainStopArrive, v24);
// Vertices for legs 3 and 4
TransitStop v26 = new TransitStop(graph, ferryStopDepart);
TransitStopDepart v28 = new TransitStopDepart(graph, ferryStopDepart, v26);
PatternDepartVertex v30 = new PatternDepartVertex(graph, thirdTripPattern, 0);
PatternArriveVertex v32 = new PatternArriveVertex(graph, thirdTripPattern, 1);
TransitStop v36 = new TransitStop(graph, ferryStopArrive);
TransitStopArrive v34 = new TransitStopArrive(graph, ferryStopArrive, v36);
// Vertices for leg 5
IntersectionVertex v38 = new IntersectionVertex(graph, "Vertex 38", 179, 89);
IntersectionVertex v40 = new IntersectionVertex(graph, "Vertex 40", 180, 89);
IntersectionVertex v42 = new IntersectionVertex(graph, "Vertex 42", 180, 90);
// Bike rental stations for legs 5, 6 and 7, plus initialization
BikeRentalStation enterPickupStation = new BikeRentalStation();
BikeRentalStation exitPickupStation = new BikeRentalStation();
BikeRentalStation enterDropoffStation = new BikeRentalStation();
BikeRentalStation exitDropoffStation = new BikeRentalStation();
enterPickupStation.id = "Enter pickup";
enterPickupStation.name = new NonLocalizedString("Enter pickup station");
enterPickupStation.x = 180;
enterPickupStation.y = 90;
exitPickupStation.id = "Exit pickup";
exitPickupStation.name = new NonLocalizedString("Exit pickup station");
exitPickupStation.x = 180;
exitPickupStation.y = 90;
enterDropoffStation.id = "Enter dropoff";
enterDropoffStation.name = new NonLocalizedString("Enter dropoff station");
enterDropoffStation.x = 0;
enterDropoffStation.y = 90;
exitDropoffStation.id = "Exit dropoff";
exitDropoffStation.name = new NonLocalizedString("Exit dropoff station");
exitDropoffStation.x = 0;
exitDropoffStation.y = 90;
// Vertices for legs 5 and 6
BikeRentalStationVertex v44 = new BikeRentalStationVertex(graph, enterPickupStation);
BikeRentalStationVertex v46 = new BikeRentalStationVertex(graph, exitPickupStation);
IntersectionVertex v48 = new IntersectionVertex(graph, "Vertex 48", 180, 90);
IntersectionVertex v50 = new IntersectionVertex(graph, "Vertex 50", 90, 90);
// Vertices for leg 7
IntersectionVertex v52 = new IntersectionVertex(graph, "Vertex 52", 90, 90);
IntersectionVertex v54 = new IntersectionVertex(graph, "Vertex 54", 0, 90);
// Vertices for legs 7 and 8
BikeRentalStationVertex v56 = new BikeRentalStationVertex(graph, enterDropoffStation);
BikeRentalStationVertex v58 = new BikeRentalStationVertex(graph, exitDropoffStation);
StreetLocation v60 = new StreetLocation("Vertex 60", new Coordinate(0, 90), "Vertex 60");
// Vertex initialization that can't be done using the constructor
v0.setExitName("Ausfahrt");
v2.freeFlowing = (true);
v4.freeFlowing = (true);
v38.freeFlowing = (true);
v40.freeFlowing = (true);
v42.freeFlowing = (true);
v48.freeFlowing = (true);
v50.freeFlowing = (true);
v52.freeFlowing = (true);
v54.freeFlowing = (true);
// Elevation profiles for the street edges that will be created later
PackedCoordinateSequence elevation3 = new PackedCoordinateSequence.Double(new double[] { 0.0, 0.0, 3.0, 9.9 }, 2);
PackedCoordinateSequence elevation39 = new PackedCoordinateSequence.Double(new double[] { 0.0, 9.9, 2.1, 0.1 }, 2);
PackedCoordinateSequence elevation41 = new PackedCoordinateSequence.Double(new double[] { 0.0, 0.1, 1.9, 2.8 }, 2);
PackedCoordinateSequence elevation49 = new PackedCoordinateSequence.Double(new double[] { 0.0, 2.8, 2.0, 2.6 }, 2);
PackedCoordinateSequence elevation53 = new PackedCoordinateSequence.Double(new double[] { 0.0, 2.6, 1.0, 6.0 }, 2);
// Coordinate sequences and line strings for those same edges
PackedCoordinateSequence coordinates3 = new PackedCoordinateSequence.Double(new double[] { 0, 0, 1, 1 }, 2);
PackedCoordinateSequence coordinates25 = new PackedCoordinateSequence.Double(new double[] { 133, 67, 135, 67 }, 2);
PackedCoordinateSequence coordinates39 = new PackedCoordinateSequence.Double(new double[] { 179, 89, 180, 89 }, 2);
PackedCoordinateSequence coordinates41 = new PackedCoordinateSequence.Double(new double[] { 180, 89, 180, 90 }, 2);
PackedCoordinateSequence coordinates49 = new PackedCoordinateSequence.Double(new double[] { 180, 90, 90, 90 }, 2);
PackedCoordinateSequence coordinates53 = new PackedCoordinateSequence.Double(new double[] { 90, 90, 0, 90 }, 2);
GeometryFactory geometryFactory = new GeometryFactory();
LineString l3 = new LineString(coordinates3, geometryFactory);
LineString l25 = new LineString(coordinates25, geometryFactory);
LineString l39 = new LineString(coordinates39, geometryFactory);
LineString l41 = new LineString(coordinates41, geometryFactory);
LineString l49 = new LineString(coordinates49, geometryFactory);
LineString l53 = new LineString(coordinates53, geometryFactory);
// Edges for leg 0
FreeEdge e1 = new FreeEdge(v0, v2);
StreetWithElevationEdge e3 = new StreetWithElevationEdge(v2, v4, l3, "Edge 3", 3.0, StreetTraversalPermission.ALL, false);
// Edges for legs 1 and 2
StreetTransitLink e5 = new StreetTransitLink(v4, v6, false);
PreBoardEdge e7 = new PreBoardEdge(v6, v8);
TransitBoardAlight e9 = new TransitBoardAlight(v8, v10, 0, TraverseMode.RAIL);
PatternHop e11 = new PatternHop(v10, v12, trainStopDepart, trainStopDwell, 0);
PatternDwell e13 = new PatternDwell(v12, v14, 1, firstTripPattern);
PatternHop e15 = new PatternHop(v14, v16, trainStopDwell, trainStopInterline, 1);
PatternInterlineDwell e17 = new PatternInterlineDwell(v16, v18);
PatternHop e19 = new PatternHop(v18, v20, trainStopInterline, trainStopArrive, 0);
TransitBoardAlight e21 = new TransitBoardAlight(v20, v22, 1, TraverseMode.RAIL);
PreAlightEdge e23 = new PreAlightEdge(v22, v24);
// Edges for legs 3 and 4
SimpleTransfer e25 = new SimpleTransfer(v24, v26, 7, l25);
PreBoardEdge e27 = new PreBoardEdge(v26, v28);
TransitBoardAlight e29 = new TransitBoardAlight(v28, v30, 0, TraverseMode.FERRY);
PatternHop e31 = new PatternHop(v30, v32, ferryStopDepart, ferryStopArrive, 0);
TransitBoardAlight e33 = new TransitBoardAlight(v32, v34, 1, TraverseMode.FERRY);
PreAlightEdge e35 = new PreAlightEdge(v34, v36);
StreetTransitLink e37 = new StreetTransitLink(v36, v38, true);
// Edges for legs 5 and 6, where edges 39 and 41 have the same name to trigger stayOn = true
AreaEdge e39 = new AreaEdge(v38, v40, l39, "Edge 39 / 41", 2.1, StreetTraversalPermission.ALL, false, new AreaEdgeList());
StreetWithElevationEdge e41 = new StreetWithElevationEdge(v40, v42, l41, "Edge 39 / 41", 1.9, StreetTraversalPermission.ALL, false);
StreetBikeRentalLink e43 = new StreetBikeRentalLink(v42, v44);
RentABikeOnEdge e45 = new RentABikeOnEdge(v44, v46, Collections.singleton(""));
StreetBikeRentalLink e47 = new StreetBikeRentalLink(v46, v48);
StreetWithElevationEdge e49 = new StreetWithElevationEdge(v48, v50, l49, "Edge 49", 2.0, StreetTraversalPermission.ALL, false);
// Edges for legs 6, 7 and 8
LegSwitchingEdge e51 = new LegSwitchingEdge(v50, v52);
StreetEdge e53p = new StreetEdge(v52, v54, l53, "Edge 53", 1.0, StreetTraversalPermission.ALL, false);
PartialStreetEdge e53 = new PartialStreetEdge(e53p, v52, v54, l53, "Edge 53", 1.0);
StreetBikeRentalLink e55 = new StreetBikeRentalLink(v54, v56);
RentABikeOffEdge e57 = new RentABikeOffEdge(v56, v58, Collections.singleton(""));
StreetBikeRentalLink e59 = new StreetBikeRentalLink(v58, v60);
// Alert for testing GTFS-RT
AlertPatch alertPatch = new AlertPatch();
alertPatch.setTimePeriods(Collections.singletonList(new TimePeriod(0, Long.MAX_VALUE)));
alertPatch.setAlert(Alert.createSimpleAlerts(alertsExample));
// Edge initialization that can't be done using the constructor
e3.setElevationProfile(elevation3, false);
e17.add(firstTrip, secondTrip);
e39.setElevationProfile(elevation39, false);
e41.setElevationProfile(elevation41, false);
e41.setHasBogusName(true);
e49.setElevationProfile(elevation49, false);
e53.setElevationProfile(elevation53, false);
graph.streetNotesService.addStaticNote(e53p, Alert.createSimpleAlerts(alertsExample), StreetNotesService.ALWAYS_MATCHER);
// Add an extra edge to the graph in order to generate stayOn = true for one walk step.
new StreetEdge(v40, new IntersectionVertex(graph, "Extra vertex", 180, 88), new LineString(new PackedCoordinateSequence.Double(new double[] { 180, 89, 180, 88 }, 2), geometryFactory), "Extra edge", 1.9, StreetTraversalPermission.NONE, true);
// Various bookkeeping operations
graph.serviceCodes.put(firstTrip.getId(), 0);
graph.serviceCodes.put(secondTrip.getId(), 1);
graph.serviceCodes.put(thirdTrip.getId(), 2);
firstTripTimes.serviceCode = graph.serviceCodes.get(firstTrip.getId());
secondTripTimes.serviceCode = graph.serviceCodes.get(secondTrip.getId());
thirdTripTimes.serviceCode = graph.serviceCodes.get(thirdTrip.getId());
CalendarServiceData calendarServiceData = new CalendarServiceDataStub(graph.serviceCodes.keySet());
CalendarServiceImpl calendarServiceImpl = new CalendarServiceImpl(calendarServiceData);
calendarServiceData.putTimeZoneForAgencyId(feedId, timeZone);
calendarServiceData.putTimeZoneForAgencyId(feedId, timeZone);
FareServiceStub fareServiceStub = new FareServiceStub();
ServiceDate serviceDate = new ServiceDate(1970, 1, 1);
// Updates for leg 4, the ferry leg
TripDescriptor.Builder tripDescriptorBuilder = TripDescriptor.newBuilder();
tripDescriptorBuilder.setTripId("C");
StopTimeEvent.Builder ferryStopDepartTimeEventBuilder = StopTimeEvent.newBuilder();
StopTimeEvent.Builder ferryStopArriveTimeEventBuilder = StopTimeEvent.newBuilder();
ferryStopDepartTimeEventBuilder.setTime(40L);
ferryStopArriveTimeEventBuilder.setTime(43L);
StopTimeUpdate.Builder ferryStopDepartUpdateBuilder = StopTimeUpdate.newBuilder();
StopTimeUpdate.Builder ferryStopArriveUpdateBuilder = StopTimeUpdate.newBuilder();
ferryStopDepartUpdateBuilder.setStopSequence(-1);
ferryStopDepartUpdateBuilder.setDeparture(ferryStopDepartTimeEventBuilder);
ferryStopDepartUpdateBuilder.setArrival(ferryStopDepartTimeEventBuilder);
ferryStopDepartUpdateBuilder.setScheduleRelationship(ScheduleRelationship.SCHEDULED);
ferryStopArriveUpdateBuilder.setStopSequence(0);
ferryStopArriveUpdateBuilder.setDeparture(ferryStopArriveTimeEventBuilder);
ferryStopArriveUpdateBuilder.setArrival(ferryStopArriveTimeEventBuilder);
ferryStopArriveUpdateBuilder.setScheduleRelationship(ScheduleRelationship.SCHEDULED);
TripUpdate.Builder tripUpdateBuilder = TripUpdate.newBuilder();
tripUpdateBuilder.setTrip(tripDescriptorBuilder);
tripUpdateBuilder.addStopTimeUpdate(0, ferryStopDepartUpdateBuilder);
tripUpdateBuilder.addStopTimeUpdate(1, ferryStopArriveUpdateBuilder);
TripUpdate tripUpdate = tripUpdateBuilder.build();
// Create dummy TimetableSnapshot
TimetableSnapshot snapshot = new TimetableSnapshot();
// Mock TimetableSnapshotSource to return dummy TimetableSnapshot
TimetableSnapshotSource timetableSnapshotSource = mock(TimetableSnapshotSource.class);
when(timetableSnapshotSource.getTimetableSnapshot()).thenReturn(snapshot);
TripTimes updatedTripTimes = thirdTripPattern.scheduledTimetable.createUpdatedTripTimes(tripUpdate, timeZone, serviceDate);
timetableSnapshotSource.getTimetableSnapshot().update(feedId, thirdTripPattern, updatedTripTimes, serviceDate);
// Further graph initialization
graph.putService(CalendarServiceData.class, calendarServiceData);
graph.putService(FareService.class, fareServiceStub);
graph.addAgency(feedId, trainAgency);
graph.addAgency(feedId, ferryAgency);
graph.timetableSnapshotSource = (timetableSnapshotSource);
graph.addAlertPatch(e29, alertPatch);
// Routing context creation and initialization
ServiceDay serviceDay = new ServiceDay(graph, 0, calendarServiceImpl, feedId);
// Temporary graph objects for onboard depart tests
OnboardDepartVertex onboardDepartVertex = new OnboardDepartVertex("Onboard", 23.0, 12.0);
OnBoardDepartPatternHop onBoardDepartPatternHop = new OnBoardDepartPatternHop(onboardDepartVertex, v12, firstTripPattern.scheduledTimetable.getTripTimes(0), serviceDay, 0, 0.5);
// Traverse the path forward first
RoutingRequest forwardOptions = options.clone();
RoutingContext forwardContext = new RoutingContext(forwardOptions, graph, v0, v60);
forwardContext.serviceDays = new ArrayList<ServiceDay>(1);
forwardContext.serviceDays.add(serviceDay);
forwardOptions.rctx = forwardContext;
forwardOptions.dateTime = 0L;
forwardOptions.bikeRentalPickupTime = 4;
forwardOptions.bikeRentalDropoffTime = 2;
// Forward traversal of all edges
State s0Forward = new State(forwardOptions);
State s2Forward = e1.traverse(s0Forward);
State s4Forward = e3.traverse(s2Forward);
State s6Forward = e5.traverse(s4Forward);
State s8Forward = e7.traverse(s6Forward);
State s10Forward = e9.traverse(s8Forward);
State s12Forward = e11.traverse(s10Forward);
State s14Forward = e13.traverse(s12Forward);
State s16Forward = e15.traverse(s14Forward);
State s18Forward = e17.traverse(s16Forward);
State s20Forward = e19.traverse(s18Forward);
State s22Forward = e21.traverse(s20Forward);
State s24Forward = e23.traverse(s22Forward);
State s26Forward = e25.traverse(s24Forward);
State s28Forward = e27.traverse(s26Forward);
State s30Forward = e29.traverse(s28Forward);
State s32Forward = e31.traverse(s30Forward);
State s34Forward = e33.traverse(s32Forward);
State s36Forward = e35.traverse(s34Forward);
State s38Forward = e37.traverse(s36Forward);
State s40Forward = e39.traverse(s38Forward);
State s42Forward = e41.traverse(s40Forward);
State s44Forward = e43.traverse(s42Forward);
State s46Forward = e45.traverse(s44Forward);
State s48Forward = e47.traverse(s46Forward);
State s50Forward = e49.traverse(s48Forward);
State s52Forward = e51.traverse(s50Forward);
State s54Forward = e53.traverse(s52Forward);
State s56Forward = e55.traverse(s54Forward);
State s58Forward = e57.traverse(s56Forward);
State s60Forward = e59.traverse(s58Forward);
// Also traverse the path backward
RoutingRequest backwardOptions = options.clone();
RoutingContext backwardContext = new RoutingContext(backwardOptions, graph, v60, v0);
backwardContext.serviceDays = new ArrayList<ServiceDay>(1);
backwardContext.serviceDays.add(serviceDay);
backwardOptions.rctx = backwardContext;
backwardOptions.dateTime = 60L;
backwardOptions.bikeRentalPickupTime = 4;
backwardOptions.bikeRentalDropoffTime = 2;
backwardOptions.setArriveBy(true);
// Backward traversal of all edges
State s60Backward = new State(backwardOptions);
State s58Backward = e59.traverse(s60Backward);
State s56Backward = e57.traverse(s58Backward);
State s54Backward = e55.traverse(s56Backward);
State s52Backward = e53.traverse(s54Backward);
State s50Backward = e51.traverse(s52Backward);
State s48Backward = e49.traverse(s50Backward);
State s46Backward = e47.traverse(s48Backward);
State s44Backward = e45.traverse(s46Backward);
State s42Backward = e43.traverse(s44Backward);
State s40Backward = e41.traverse(s42Backward);
State s38Backward = e39.traverse(s40Backward);
State s36Backward = e37.traverse(s38Backward);
State s34Backward = e35.traverse(s36Backward);
State s32Backward = e33.traverse(s34Backward);
State s30Backward = e31.traverse(s32Backward);
State s28Backward = e29.traverse(s30Backward);
State s26Backward = e27.traverse(s28Backward);
State s24Backward = e25.traverse(s26Backward);
State s22Backward = e23.traverse(s24Backward);
State s20Backward = e21.traverse(s22Backward);
State s18Backward = e19.traverse(s20Backward);
State s16Backward = e17.traverse(s18Backward);
State s14Backward = e15.traverse(s16Backward);
State s12Backward = e13.traverse(s14Backward);
State s10Backward = e11.traverse(s12Backward);
State s8Backward = e9.traverse(s10Backward);
State s6Backward = e7.traverse(s8Backward);
State s4Backward = e5.traverse(s6Backward);
State s2Backward = e3.traverse(s4Backward);
State s0Backward = e1.traverse(s2Backward);
// Perform a forward traversal starting onboard
RoutingRequest onboardOptions = options.clone();
RoutingContext onboardContext = new RoutingContext(onboardOptions, graph, onboardDepartVertex, v60);
onboardContext.serviceDays = new ArrayList<ServiceDay>(1);
onboardContext.serviceDays.add(serviceDay);
onboardOptions.rctx = onboardContext;
onboardOptions.dateTime = 6L;
onboardOptions.bikeRentalPickupTime = 4;
onboardOptions.bikeRentalDropoffTime = 2;
// Onboard traversal of all edges
State s10Onboard = new State(onboardOptions);
State s12Onboard = onBoardDepartPatternHop.traverse(s10Onboard);
State s14Onboard = e13.traverse(s12Onboard);
State s16Onboard = e15.traverse(s14Onboard);
State s18Onboard = e17.traverse(s16Onboard);
State s20Onboard = e19.traverse(s18Onboard);
State s22Onboard = e21.traverse(s20Onboard);
State s24Onboard = e23.traverse(s22Onboard);
State s26Onboard = e25.traverse(s24Onboard);
State s28Onboard = e27.traverse(s26Onboard);
State s30Onboard = e29.traverse(s28Onboard);
State s32Onboard = e31.traverse(s30Onboard);
State s34Onboard = e33.traverse(s32Onboard);
State s36Onboard = e35.traverse(s34Onboard);
State s38Onboard = e37.traverse(s36Onboard);
State s40Onboard = e39.traverse(s38Onboard);
State s42Onboard = e41.traverse(s40Onboard);
State s44Onboard = e43.traverse(s42Onboard);
State s46Onboard = e45.traverse(s44Onboard);
State s48Onboard = e47.traverse(s46Onboard);
State s50Onboard = e49.traverse(s48Onboard);
State s52Onboard = e51.traverse(s50Onboard);
State s54Onboard = e53.traverse(s52Onboard);
State s56Onboard = e55.traverse(s54Onboard);
State s58Onboard = e57.traverse(s56Onboard);
State s60Onboard = e59.traverse(s58Onboard);
return new GraphPath[] { new GraphPath(s60Forward, false), new GraphPath(s0Backward, false), new GraphPath(s60Onboard, false) };
}
Aggregations