public void testRoutingOverMidnight() throws Exception {
// this route only runs on weekdays
Vertex stop_g = graph.getVertex("agency:G_depart");
Vertex stop_h = graph.getVertex("agency:H_arrive");
ShortestPathTree spt;
GraphPath path;
RoutingRequest options = new RoutingRequest();
// Friday evening
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 18, 23, 20, 0);
options.setRoutingContext(graph, stop_g, stop_h);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_h, false);
assertNotNull(path);
assertEquals(4, path.states.size());
// Saturday morning
long startTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 19, 0, 5, 0);
options.dateTime = startTime;
options.setRoutingContext(graph, stop_g.getLabel(), stop_h.getLabel());
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_h, false);
assertNotNull(path);
assertEquals(4, path.states.size());
long endTime = path.getEndTime();
assertTrue(endTime < startTime + 60 * 60);
}
public void testFewestTransfers() {
Vertex stop_c = graph.getVertex("agency:C");
Vertex stop_d = graph.getVertex("agency:D");
RoutingRequest options = new RoutingRequest();
options.optimize = OptimizeType.QUICK;
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 16, 0, 0);
options.setRoutingContext(graph, stop_c, stop_d);
ShortestPathTree spt = aStar.getShortestPathTree(options);
// when optimizing for speed, take the fast two-bus path
GraphPath path = spt.getPath(stop_d, false);
assertNotNull(path);
assertEquals(
TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 16, 20, 0), path.getEndTime());
// when optimizing for fewest transfers, take the slow one-bus path
options.transferPenalty = 1800;
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_d, false);
assertNotNull(path);
assertEquals(
TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 16, 50, 0), path.getEndTime());
}
public void testRouting() throws Exception {
Vertex stop_a = graph.getVertex("agency:A");
Vertex stop_b = graph.getVertex("agency:B");
Vertex stop_c = graph.getVertex("agency:C");
Vertex stop_d = graph.getVertex("agency:D");
Vertex stop_e = graph.getVertex("agency:E");
RoutingRequest options = new RoutingRequest();
// test feed is designed for instantaneous transfers
options.transferSlack = (0);
long startTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 0, 0, 0);
options.dateTime = startTime;
ShortestPathTree spt;
GraphPath path;
// A to B
options.setRoutingContext(graph, stop_a, stop_b);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_b, false);
assertNotNull(path);
assertEquals(6, path.states.size());
// A to C
options.setRoutingContext(graph, stop_a, stop_c);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_c, false);
assertNotNull(path);
assertEquals(8, path.states.size());
// A to D (change at C)
options.setRoutingContext(graph, stop_a, stop_d);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_d, false);
assertNotNull(path);
// there are two paths of different lengths
// both arrive at 40 minutes after midnight
List<TransitStop> stops = extractStopVertices(path);
assertEquals(stops.size(), 3);
assertEquals(stops.get(1), stop_c);
long endTime = startTime + 40 * 60;
assertEquals(endTime, path.getEndTime());
// A to E (change at C)
options.setRoutingContext(graph, stop_a, stop_e);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_e, false);
assertNotNull(path);
stops = extractStopVertices(path);
assertEquals(stops.size(), 3);
assertEquals(stops.get(1), stop_c);
endTime = startTime + 70 * 60;
assertEquals(endTime, path.getEndTime());
}
/** Make sure that stops are properly linked into the graph */
@Test
public void testStopLinking() throws Exception {
AddTripPattern atp = getAddTripPattern(RouteSelector.BROAD_HIGH);
atp.timetables.add(getTimetable(true));
// get a graph
Graph g = buildGraphNoTransit();
link(g);
g.index(new DefaultStreetVertexIndexFactory());
// materialize the trip pattern
atp.materialize(g);
// there should be five stops because one point is not a stop
assertEquals(5, atp.temporaryStops.length);
// they should all be linked into the graph
for (int i = 0; i < atp.temporaryStops.length; i++) {
assertNotNull(atp.temporaryStops[i].sample);
assertNotNull(atp.temporaryStops[i].sample.v0);
assertNotNull(atp.temporaryStops[i].sample.v1);
}
// no services running: not needed for trips added on the fly.
TimeWindow window = new TimeWindow(7 * 3600, 9 * 3600, new BitSet(), DayOfWeek.WEDNESDAY);
Scenario scenario = new Scenario(0);
scenario.modifications = Lists.newArrayList(atp);
ProfileRequest req = new ProfileRequest();
req.scenario = scenario;
req.boardingAssumption = RaptorWorkerTimetable.BoardingAssumption.WORST_CASE;
RaptorWorkerData data = new RaptorWorkerData(g, window, req);
assertEquals(5, data.nStops);
// make sure we can find the stops
AStar aStar = new AStar();
RoutingRequest rr = new RoutingRequest(TraverseMode.WALK);
rr.from = new GenericLocation(39.963417, -82.980799);
rr.batch = true;
rr.setRoutingContext(g);
rr.batch = true;
ShortestPathTree spt = aStar.getShortestPathTree(rr);
TIntIntMap stops = data.findStopsNear(spt, g);
// we should have found stops
assertFalse(stops.isEmpty());
// ensure that the times made it into the data
// This assumes worst-case departure, and the first worst departure is 10:30 after the service
// starts running (dwell + headway)
assertEquals(
4 * 3600 + 600 + 30,
data.timetablesForPattern.get(0).getFrequencyDeparture(0, 0, 39 * 360, -1, null));
}
public void testWheelchairAccessible() throws Exception {
Vertex near_a = graph.getVertex("near_1_agency_entrance_a");
Vertex near_b = graph.getVertex("near_1_agency_entrance_b");
Vertex near_c = graph.getVertex("near_1_agency_C");
Vertex near_e = graph.getVertex("near_1_agency_E");
Vertex stop_d = graph.getVertex("agency:D");
Vertex split_d = null;
for (StreetTransitLink e : Iterables.filter(stop_d.getOutgoing(), StreetTransitLink.class)) {
split_d = e.getToVertex();
}
RoutingRequest options = new RoutingRequest();
options.wheelchairAccessible = true;
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 18, 0, 0, 0);
ShortestPathTree spt;
GraphPath path;
// stop B is accessible, so there should be a path.
options.setRoutingContext(graph, near_a, near_b);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(near_b, false);
assertNotNull(path);
// stop C is not accessible, so there should be no path.
options.setRoutingContext(graph, near_a, near_c);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(near_c, false);
assertNull(path);
// stop E has no accessibility information, but we should still be able to route to it.
options.setRoutingContext(graph, near_a, near_e);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(near_e, false);
assertNotNull(path);
// from stop A to stop D would normally be trip 1.1 to trip 2.1, arriving at 00:30. But trip
// 2 is not accessible, so we'll do 1.1 to 3.1, arriving at 01:00
GregorianCalendar time = new GregorianCalendar(2009, 8, 18, 0, 0, 0);
time.setTimeZone(TimeZone.getTimeZone("America/New_York"));
options.dateTime = TestUtils.toSeconds(time);
options.setRoutingContext(graph, near_a, split_d);
spt = aStar.getShortestPathTree(options);
time.add(Calendar.HOUR, 1);
time.add(Calendar.SECOND, 1); // for the StreetTransitLink
path = spt.getPath(split_d, false);
assertNotNull(path);
assertEquals(TestUtils.toSeconds(time), path.getEndTime());
}
public void testFrequencies() {
Vertex stop_u = graph.getVertex("agency:U_depart");
Vertex stop_v = graph.getVertex("agency:V_arrive");
ShortestPathTree spt;
GraphPath path;
RoutingRequest options = new RoutingRequest();
options.setModes(new TraverseModeSet("TRANSIT"));
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 0, 0, 0);
options.setRoutingContext(graph, stop_u, stop_v);
// U to V - original stop times - shouldn't be used
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_v, false);
assertNotNull(path);
assertEquals(4, path.states.size());
long endTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 6, 40, 0);
assertEquals(endTime, path.getEndTime());
// U to V - first frequency
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 7, 0, 0);
options.setRoutingContext(graph, stop_u, stop_v);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_v, false);
assertNotNull(path);
assertEquals(4, path.states.size());
endTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 7, 40, 0);
assertEquals(endTime, path.getEndTime());
// U to V - second frequency
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 14, 0, 0);
options.setRoutingContext(graph, stop_u, stop_v);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_v, false);
assertNotNull(path);
assertEquals(4, path.states.size());
endTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 7, 14, 40, 0);
assertEquals(endTime, path.getEndTime());
// TODO more detailed testing of frequencies
}
public void testTraverseMode() throws Exception {
Vertex stop_a = graph.getVertex("agency:A_depart");
Vertex stop_b = graph.getVertex("agency:B_arrive");
ShortestPathTree spt;
RoutingRequest options = new RoutingRequest();
options.setModes(new TraverseModeSet("TRAINISH"));
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 0, 0, 0, 0);
options.setRoutingContext(graph, stop_a, stop_b);
spt = aStar.getShortestPathTree(options);
// a to b is bus only
assertNull(spt.getPath(stop_b, false));
options.setModes(new TraverseModeSet("TRAINISH,BUSISH"));
spt = aStar.getShortestPathTree(options);
assertNotNull(spt.getPath(stop_b, false));
}
public void testTimelessStops() throws Exception {
Vertex stop_d = graph.getVertex("agency:D");
Vertex stop_c = graph.getVertex("agency:C");
RoutingRequest options = new RoutingRequest();
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 10, 0, 0);
options.setRoutingContext(graph, stop_d, stop_c);
ShortestPathTree spt = aStar.getShortestPathTree(options);
GraphPath path = spt.getPath(stop_c, false);
assertNotNull(path);
assertEquals(
TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 11, 0, 0), path.getEndTime());
}
public void testTripBikesAllowed() throws Exception {
Vertex stop_a = graph.getVertex("agency:A");
Vertex stop_b = graph.getVertex("agency:B");
Vertex stop_c = graph.getVertex("agency:C");
Vertex stop_d = graph.getVertex("agency:D");
RoutingRequest options = new RoutingRequest();
options.modes.setWalk(false);
options.modes.setBicycle(true);
options.modes.setTransit(true);
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 18, 0, 0, 0);
options.setRoutingContext(graph, stop_a, stop_b);
ShortestPathTree spt;
GraphPath path;
// route: bikes allowed, trip: no value
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_b, false);
assertNotNull(path);
// route: bikes allowed, trip: bikes not allowed
options.setRoutingContext(graph, stop_d, stop_c);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_c, false);
assertNull(path);
// route: bikes not allowed, trip: bikes allowed
options.setRoutingContext(graph, stop_c, stop_d);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_d, false);
assertNotNull(path);
}
public void testPickupDropoff() throws Exception {
Vertex stop_o = graph.getVertex("agency:O_depart");
Vertex stop_p = graph.getVertex("agency:P");
assertEquals(2, stop_o.getOutgoing().size());
long startTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 19, 12, 0, 0);
RoutingRequest options = new RoutingRequest();
options.dateTime = startTime;
options.setRoutingContext(graph, stop_o, stop_p);
ShortestPathTree spt = aStar.getShortestPathTree(options);
GraphPath path = spt.getPath(stop_p, false);
assertNotNull(path);
long endTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 19, 12, 10, 0);
assertEquals(endTime, path.getEndTime());
startTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 19, 12, 0, 1);
options.dateTime = startTime;
options.setRoutingContext(graph, stop_o, stop_p);
spt = aStar.getShortestPathTree(options);
path = spt.getPath(stop_p, false);
assertNotNull(path);
endTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 19, 15, 10, 0);
assertEquals(endTime, path.getEndTime());
}
public void testPathways() throws Exception {
Vertex entrance = graph.getVertex("agency:entrance_a");
assertNotNull(entrance);
Vertex stop = graph.getVertex("agency:A");
assertNotNull(stop);
RoutingRequest options = new RoutingRequest();
options.dateTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 16, 0, 0);
options.setRoutingContext(graph, entrance, stop);
ShortestPathTree spt = aStar.getShortestPathTree(options);
GraphPath path = spt.getPath(stop, false);
assertNotNull(path);
assertEquals(
TestUtils.dateInSeconds("America/New_York", 2009, 8, 1, 16, 0, 34), path.getEndTime());
}
public void testRunForTrain() {
/**
* This is the notorious Byrd bug: we're going from Q to T at 8:30. There's a trip from S to T
* at 8:50 and a second one at 9:50. To get to S by 8:50, we need to take trip 12.1 from Q to R,
* and 13.1 from R to S. If we take the direct-but-slower 11.1, we'll miss the 8:50 and have to
* catch the 9:50.
*/
Vertex destination = graph.getVertex("agency:T");
RoutingRequest options = new RoutingRequest();
// test is designed such that transfers must be instantaneous
options.transferSlack = (0);
GregorianCalendar startTime = new GregorianCalendar(2009, 11, 2, 8, 30, 0);
startTime.setTimeZone(TimeZone.getTimeZone("America/New_York"));
options.dateTime = TestUtils.toSeconds(startTime);
options.setRoutingContext(graph, "agency:Q", destination.getLabel());
ShortestPathTree spt = aStar.getShortestPathTree(options);
GraphPath path = spt.getPath(destination, false);
long endTime = path.getEndTime();
Calendar c = new GregorianCalendar();
c.setTimeInMillis(endTime * 1000L);
assertTrue(endTime - TestUtils.toSeconds(startTime) < 7200);
}
public void testTransfers() throws Exception {
TransferTable transferTable = graph.getTransferTable();
// create dummy routes and trips
Route fromRoute = new Route();
fromRoute.setId(new AgencyAndId("agency", "1"));
Trip fromTrip = new Trip();
fromTrip.setId(new AgencyAndId("agency", "1.1"));
fromTrip.setRoute(fromRoute);
Route toRoute = new Route();
toRoute.setId(new AgencyAndId("agency", "2"));
Trip toTrip = new Trip();
toTrip.setId(new AgencyAndId("agency", "2.1"));
toTrip.setRoute(toRoute);
Trip toTrip2 = new Trip();
toTrip2.setId(new AgencyAndId("agency", "2.2"));
toTrip2.setRoute(toRoute);
// find stops
Stop stopK = ((TransitStopArrive) graph.getVertex("agency:K_arrive")).getStop();
Stop stopN = ((TransitStopDepart) graph.getVertex("agency:N_depart")).getStop();
Stop stopM = ((TransitStopDepart) graph.getVertex("agency:M_depart")).getStop();
assertTrue(transferTable.hasPreferredTransfers());
assertEquals(
StopTransfer.UNKNOWN_TRANSFER,
transferTable.getTransferTime(stopN, stopM, fromTrip, toTrip, true));
assertEquals(
StopTransfer.FORBIDDEN_TRANSFER,
transferTable.getTransferTime(stopK, stopM, fromTrip, toTrip, true));
assertEquals(
StopTransfer.PREFERRED_TRANSFER,
transferTable.getTransferTime(stopN, stopK, toTrip, toTrip2, true));
assertEquals(
StopTransfer.TIMED_TRANSFER,
transferTable.getTransferTime(stopN, stopK, fromTrip, toTrip, true));
assertEquals(15, transferTable.getTransferTime(stopN, stopK, fromTrip, toTrip2, true));
TransitStop e_arrive = (TransitStop) graph.getVertex("agency:E");
TransitStop f_depart = (TransitStop) graph.getVertex("agency:F");
Edge edge = new TransferEdge(e_arrive, f_depart, 10000, 10000);
long startTime = TestUtils.dateInSeconds("America/New_York", 2009, 8, 18, 0, 50, 0);
Vertex stop_b = graph.getVertex("agency:B_depart");
Vertex stop_g = graph.getVertex("agency:G_arrive");
RoutingRequest options = new RoutingRequest();
options.dateTime = startTime;
options.setRoutingContext(graph, stop_b, stop_g);
ShortestPathTree spt = aStar.getShortestPathTree(options);
GraphPath path = spt.getPath(stop_g, false);
assertNotNull(path);
assertTrue(
"expected to use much later trip due to min transfer time",
path.getEndTime() - startTime > 4.5 * 60 * 60);
/* cleanup */
e_arrive.removeOutgoing(edge);
f_depart.removeIncoming(edge);
}
public void testHalfEdges() {
// the shortest half-edge from the start vertex takes you down, but the shortest total path
// is up and over
TraverseOptions options = new TraverseOptions();
HashSet<Edge> turns = new HashSet<Edge>(graph.getOutgoing(left));
turns.addAll(graph.getOutgoing(leftBack));
StreetLocation start =
StreetLocation.createStreetLocation(
"start",
"start",
cast(turns, StreetEdge.class),
new LinearLocation(0, 0.4).getCoordinate(left.getGeometry()));
HashSet<Edge> endTurns = new HashSet<Edge>(graph.getOutgoing(right));
endTurns.addAll(graph.getOutgoing(rightBack));
StreetLocation end =
StreetLocation.createStreetLocation(
"end",
"end",
cast(endTurns, StreetEdge.class),
new LinearLocation(0, 0.8).getCoordinate(right.getGeometry()));
assertTrue(start.getX() < end.getX());
assertTrue(start.getY() < end.getY());
List<DirectEdge> extra = end.getExtra();
assertEquals(12, extra.size());
GregorianCalendar startTime = new GregorianCalendar(2009, 11, 1, 12, 34, 25);
ShortestPathTree spt1 =
AStar.getShortestPathTree(graph, brOut, end, TestUtils.toSeconds(startTime), options);
GraphPath pathBr = spt1.getPath(end, false);
assertNotNull("There must be a path from br to end", pathBr);
ShortestPathTree spt2 =
AStar.getShortestPathTree(graph, trOut, end, TestUtils.toSeconds(startTime), options);
GraphPath pathTr = spt2.getPath(end, false);
assertNotNull("There must be a path from tr to end", pathTr);
assertTrue(
"path from bottom to end must be longer than path from top to end",
pathBr.getWeight() > pathTr.getWeight());
ShortestPathTree spt =
AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);
GraphPath path = spt.getPath(end, false);
assertNotNull("There must be a path from start to end", path);
// the bottom is not part of the shortest path
for (State s : path.states) {
assertNotSame(s.getVertex(), graph.getVertex("bottom"));
assertNotSame(s.getVertex(), graph.getVertex("bottomBack"));
}
startTime = new GregorianCalendar(2009, 11, 1, 12, 34, 25);
options.setArriveBy(true);
spt = AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);
path = spt.getPath(start, false);
assertNotNull("There must be a path from start to end (looking back)", path);
// the bottom edge is not part of the shortest path
for (State s : path.states) {
assertNotSame(s.getVertex(), graph.getVertex("bottom"));
assertNotSame(s.getVertex(), graph.getVertex("bottomBack"));
}
/* Now, the right edge is not bikeable. But the user can walk their bike. So here are some tests
* that prove (a) that walking bikes works, but that (b) it is not preferred to riding a tiny bit longer.
*/
options = new TraverseOptions(new TraverseModeSet(TraverseMode.BICYCLE));
start =
StreetLocation.createStreetLocation(
"start1",
"start1",
cast(turns, StreetEdge.class),
new LinearLocation(0, 0.95).getCoordinate(top.getGeometry()));
end =
StreetLocation.createStreetLocation(
"end1",
"end1",
cast(turns, StreetEdge.class),
new LinearLocation(0, 0.95).getCoordinate(bottom.getGeometry()));
spt = AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);
path = spt.getPath(start, false);
assertNotNull("There must be a path from top to bottom along the right", path);
// the left edge is not part of the shortest path (even though the bike must be walked along the
// right)
for (State s : path.states) {
assertNotSame(s.getVertex(), graph.getVertex("left"));
assertNotSame(s.getVertex(), graph.getVertex("leftBack"));
}
start =
StreetLocation.createStreetLocation(
"start2",
"start2",
cast(turns, StreetEdge.class),
new LinearLocation(0, 0.55).getCoordinate(top.getGeometry()));
end =
StreetLocation.createStreetLocation(
"end2",
"end2",
cast(turns, StreetEdge.class),
new LinearLocation(0, 0.55).getCoordinate(bottom.getGeometry()));
spt = AStar.getShortestPathTree(graph, start, end, TestUtils.toSeconds(startTime), options);
path = spt.getPath(start, false);
assertNotNull("There must be a path from top to bottom", path);
// the right edge is not part of the shortest path, e
for (State s : path.states) {
assertNotSame(s.getVertex(), graph.getVertex("right"));
assertNotSame(s.getVertex(), graph.getVertex("rightBack"));
}
}