private WalkStep createWalkStep(State s) {
EdgeNarrative en = s.getBackEdgeNarrative();
WalkStep step;
step = new WalkStep();
step.streetName = en.getName();
step.lon = en.getFromVertex().getX();
step.lat = en.getFromVertex().getY();
step.elevation = encodeElevationProfile(s.getBackEdge(), 0);
step.bogusName = en.hasBogusName();
step.addAlerts(en.getNotes());
return step;
}
private void fixupTransitLeg(Leg leg, State state, TransitIndexService transitIndex) {
EdgeNarrative en = state.getBackEdgeNarrative();
leg.route = en.getName();
Trip trip = en.getTrip();
if (trip != null) {
leg.headsign = trip.getTripHeadsign();
leg.tripId = trip.getId().getId();
leg.agencyId = trip.getId().getAgencyId();
leg.tripShortName = trip.getTripShortName();
leg.routeShortName = trip.getRoute().getShortName();
leg.routeLongName = trip.getRoute().getLongName();
leg.routeColor = trip.getRoute().getColor();
leg.routeTextColor = trip.getRoute().getTextColor();
if (transitIndex != null) {
Agency agency = transitIndex.getAgency(leg.agencyId);
leg.agencyName = agency.getName();
leg.agencyUrl = agency.getUrl();
}
}
leg.mode = en.getMode().toString();
leg.startTime = makeCalendar(state.getBackState());
}
/**
* Converts a list of street edges to a list of turn-by-turn directions.
*
* @param edges : A list of street edges
* @return
*/
private List<WalkStep> getWalkSteps(List<State> states) {
List<WalkStep> steps = new ArrayList<WalkStep>();
WalkStep step = null;
double lastAngle = 0, distance = 0; // distance used for appending elevation profiles
int roundaboutExit = 0; // track whether we are in a roundabout, and if so the exit number
String roundaboutPreviousStreet = null;
for (State currState : states) {
State backState = currState.getBackState();
Edge edge = currState.getBackEdge();
EdgeNarrative edgeNarrative = currState.getBackEdgeNarrative();
boolean createdNewStep = false;
if (edge instanceof FreeEdge) {
continue;
}
if (!edgeNarrative.getMode().isOnStreetNonTransit()) {
continue; // ignore STLs and the like
}
Geometry geom = edgeNarrative.getGeometry();
if (geom == null) {
continue;
}
// generate a step for getting off an elevator (all
// elevator narrative generation occurs when alighting). We don't need to know what came
// before or will come after
if (edge instanceof ElevatorAlightEdge) {
// don't care what came before or comes after
step = createWalkStep(currState);
// tell the user where to get off the elevator using the exit notation, so the
// i18n interface will say 'Elevator to <exit>'
// what happens is that the webapp sees name == null and ignores that, and it sees
// exit != null and uses to <exit>
// the floor name is the AlightEdge name
// reset to avoid confusion with 'Elevator on floor 1 to floor 1'
step.streetName = ((ElevatorAlightEdge) edge).getName();
step.relativeDirection = RelativeDirection.ELEVATOR;
steps.add(step);
continue;
}
String streetName = edgeNarrative.getName();
int idx = streetName.indexOf('(');
String streetNameNoParens;
if (idx > 0) streetNameNoParens = streetName.substring(0, idx - 1);
else streetNameNoParens = streetName;
if (step == null) {
// first step
step = createWalkStep(currState);
createdNewStep = true;
steps.add(step);
double thisAngle = DirectionUtils.getFirstAngle(geom);
step.setAbsoluteDirection(thisAngle);
// new step, set distance to length of first edge
distance = edgeNarrative.getDistance();
} else if ((step.streetName != null && !step.streetNameNoParens().equals(streetNameNoParens))
&& (!step.bogusName || !edgeNarrative.hasBogusName())) {
/* street name has changed */
if (roundaboutExit > 0) {
// if we were just on a roundabout,
// make note of which exit was taken in the existing step
step.exit = Integer.toString(roundaboutExit); // ordinal numbers from
if (streetNameNoParens.equals(roundaboutPreviousStreet)) {
step.stayOn = true;
}
// localization
roundaboutExit = 0;
}
/* start a new step */
step = createWalkStep(currState);
createdNewStep = true;
steps.add(step);
if (edgeNarrative.isRoundabout()) {
// indicate that we are now on a roundabout
// and use one-based exit numbering
roundaboutExit = 1;
roundaboutPreviousStreet = backState.getBackEdgeNarrative().getName();
idx = roundaboutPreviousStreet.indexOf('(');
if (idx > 0) roundaboutPreviousStreet = roundaboutPreviousStreet.substring(0, idx - 1);
}
double thisAngle = DirectionUtils.getFirstAngle(geom);
step.setDirections(lastAngle, thisAngle, edgeNarrative.isRoundabout());
// new step, set distance to length of first edge
distance = edgeNarrative.getDistance();
} else {
/* street name has not changed */
double thisAngle = DirectionUtils.getFirstAngle(geom);
RelativeDirection direction =
WalkStep.getRelativeDirection(lastAngle, thisAngle, edgeNarrative.isRoundabout());
boolean optionsBefore = backState.multipleOptionsBefore();
if (edgeNarrative.isRoundabout()) {
// we are on a roundabout, and have already traversed at least one edge of it.
if (optionsBefore) {
// increment exit count if we passed one.
roundaboutExit += 1;
}
}
if (edgeNarrative.isRoundabout() || direction == RelativeDirection.CONTINUE) {
// we are continuing almost straight, or continuing along a roundabout.
// just append elevation info onto the existing step.
} else {
// we are not on a roundabout, and not continuing straight through.
// figure out if there were other plausible turn options at the last
// intersection
// to see if we should generate a "left to continue" instruction.
boolean shouldGenerateContinue = false;
if (edge instanceof PlainStreetEdge) {
// the next edges will be TinyTurnEdges or PlainStreetEdges, we hope
double angleDiff = getAbsoluteAngleDiff(thisAngle, lastAngle);
for (Edge alternative : backState.getVertex().getOutgoingStreetEdges()) {
if (alternative instanceof TinyTurnEdge) {
// a tiny turn edge has no geometry, but the next
// edge will be a TurnEdge or PSE and will have direction
alternative = alternative.getToVertex().getOutgoingStreetEdges().get(0);
}
if (alternative.getName().equals(streetName)) {
// alternatives that have the same name
// are usually caused by street splits
continue;
}
double altAngle = DirectionUtils.getFirstAngle(alternative.getGeometry());
double altAngleDiff = getAbsoluteAngleDiff(altAngle, lastAngle);
if (angleDiff > Math.PI / 4 || altAngleDiff - angleDiff < Math.PI / 16) {
shouldGenerateContinue = true;
break;
}
}
} else if (edge instanceof TinyTurnEdge) {
// do nothing as this will be handled in other cases
} else {
double angleDiff = getAbsoluteAngleDiff(lastAngle, thisAngle);
// in the case of a turn edge, we actually have to go back two steps to see
// where
// else we might be, as once we are on the streetvertex leading into this
// edge,
// we are stuck
State twoStatesBack = backState.getBackState();
Vertex backVertex = twoStatesBack.getVertex();
for (Edge alternative : backVertex.getOutgoingStreetEdges()) {
List<Edge> alternatives = alternative.getToVertex().getOutgoingStreetEdges();
if (alternatives.size() == 0) {
continue; // this is not an alternative
}
alternative = alternatives.get(0);
if (alternative.getName().equals(streetName)) {
// alternatives that have the same name
// are usually caused by street splits
continue;
}
double altAngle = DirectionUtils.getFirstAngle(alternative.getGeometry());
double altAngleDiff = getAbsoluteAngleDiff(altAngle, lastAngle);
if (angleDiff > Math.PI / 4 || altAngleDiff - angleDiff < Math.PI / 16) {
shouldGenerateContinue = true;
break;
}
}
}
if (shouldGenerateContinue) {
// turn to stay on same-named street
step = createWalkStep(currState);
createdNewStep = true;
steps.add(step);
step.setDirections(lastAngle, thisAngle, false);
step.stayOn = true;
// new step, set distance to length of first edge
distance = edgeNarrative.getDistance();
}
}
}
if (createdNewStep) {
// check last three steps for zag
int last = steps.size() - 1;
if (last >= 2) {
WalkStep threeBack = steps.get(last - 2);
WalkStep twoBack = steps.get(last - 1);
WalkStep lastStep = steps.get(last);
if (twoBack.distance < MAX_ZAG_DISTANCE
&& lastStep.streetNameNoParens().equals(threeBack.streetNameNoParens())) {
// total hack to remove zags.
steps.remove(last);
steps.remove(last - 1);
step = threeBack;
step.distance += twoBack.distance;
if (twoBack.elevation != null) {
if (step.elevation == null) {
step.elevation = twoBack.elevation;
} else {
for (P2<Double> d : twoBack.elevation) {
step.elevation.add(new P2<Double>(d.getFirst() + step.distance, d.getSecond()));
}
}
}
}
}
} else {
if (step.elevation != null) {
List<P2<Double>> s = encodeElevationProfile(edge, distance);
if (step.elevation != null && step.elevation.size() > 0) {
step.elevation.addAll(s);
} else {
step.elevation = s;
}
}
distance += edgeNarrative.getDistance();
}
// increment the total length for this step
step.distance += edgeNarrative.getDistance();
step.addAlerts(edgeNarrative.getNotes());
lastAngle = DirectionUtils.getLastAngle(geom);
}
return steps;
}
/**
* Generate an itinerary from a @{link GraphPath}. The algorithm here is to walk over each state
* in the graph path, accumulating geometry, time, and length data from the incoming edge. When
* the incoming edge and outgoing edge have different modes (or when a vehicle changes names due
* to interlining) a new leg is generated. Street legs undergo an additional processing step to
* generate turn-by-turn directions.
*
* @param path
* @param showIntermediateStops whether intermediate stops are included in the generated itinerary
* @return itinerary
*/
private Itinerary generateItinerary(GraphPath path, boolean showIntermediateStops) {
Graph graph = path.getRoutingContext().graph;
TransitIndexService transitIndex = graph.getService(TransitIndexService.class);
Itinerary itinerary = makeEmptyItinerary(path);
EdgeNarrative postponedAlerts = null;
Leg leg = null;
CoordinateArrayListSequence coordinates = new CoordinateArrayListSequence();
double previousElevation = Double.MAX_VALUE;
int startWalk = -1;
int i = -1;
PlanGenState pgstate = PlanGenState.START;
String nextName = null;
for (State state : path.states) {
i += 1;
Edge backEdge = state.getBackEdge();
EdgeNarrative backEdgeNarrative = state.getBackEdgeNarrative();
if (backEdge == null) {
continue;
}
TraverseMode mode = backEdgeNarrative.getMode();
if (mode != null) {
long dt = state.getAbsTimeDeltaSec();
if (mode == TraverseMode.BOARDING
|| mode == TraverseMode.ALIGHTING
|| mode == TraverseMode.STL) {
itinerary.waitingTime += dt;
} else if (mode.isOnStreetNonTransit()) {
itinerary.walkDistance += backEdgeNarrative.getDistance();
itinerary.walkTime += dt;
} else if (mode.isTransit()) {
itinerary.transitTime += dt;
}
}
if (backEdge instanceof FreeEdge) {
if (backEdge instanceof PreBoardEdge) {
// Add boarding alerts to the next leg
postponedAlerts = backEdgeNarrative;
} else if (backEdge instanceof PreAlightEdge) {
// Add alighting alerts to the previous leg
addNotesToLeg(itinerary.legs.get(itinerary.legs.size() - 1), backEdgeNarrative);
}
continue;
}
if (backEdge instanceof EdgeWithElevation) {
PackedCoordinateSequence profile = ((EdgeWithElevation) backEdge).getElevationProfile();
previousElevation = applyElevation(profile, itinerary, previousElevation);
}
switch (pgstate) {
case START:
if (mode == TraverseMode.WALK) {
pgstate = PlanGenState.WALK;
leg = makeLeg(itinerary, state);
leg.from.orig = nextName;
startWalk = i;
} else if (mode == TraverseMode.BICYCLE) {
pgstate = PlanGenState.BICYCLE;
leg = makeLeg(itinerary, state);
leg.from.orig = nextName;
startWalk = i;
} else if (mode == TraverseMode.CAR) {
pgstate = PlanGenState.CAR;
leg = makeLeg(itinerary, state);
leg.from.orig = nextName;
startWalk = i;
} else if (mode == TraverseMode.BOARDING) {
// this itinerary starts with transit
pgstate = PlanGenState.PRETRANSIT;
leg = makeLeg(itinerary, state);
leg.from.orig = nextName;
startWalk = -1;
} else if (mode == TraverseMode.STL) {
// this comes after an alight; do nothing
} else if (mode == TraverseMode.TRANSFER) {
// handle the whole thing in one step
leg = makeLeg(itinerary, state);
coordinates = new CoordinateArrayListSequence();
coordinates.add(state.getBackState().getVertex().getCoordinate());
coordinates.add(state.getVertex().getCoordinate());
finalizeLeg(leg, state, path.states, i, i, coordinates);
coordinates.clear();
} else {
LOG.error("Unexpected state (in START): " + mode);
}
break;
case WALK:
if (leg == null) {
leg = makeLeg(itinerary, state);
}
if (mode == TraverseMode.WALK) {
// do nothing
} else if (mode == TraverseMode.BICYCLE) {
finalizeLeg(leg, state, path.states, startWalk, i, coordinates);
startWalk = i;
leg = makeLeg(itinerary, state);
if (backEdge instanceof RentABikeOnEdge) {
leg.rentedBike = true;
}
pgstate = PlanGenState.BICYCLE;
} else if (mode == TraverseMode.STL) {
finalizeLeg(leg, state, path.states, startWalk, i, coordinates);
leg = null;
pgstate = PlanGenState.PRETRANSIT;
} else if (mode == TraverseMode.BOARDING) {
// this only happens in case of a timed transfer.
pgstate = PlanGenState.PRETRANSIT;
finalizeLeg(leg, state, path.states, startWalk, i, coordinates);
leg = makeLeg(itinerary, state);
itinerary.transfers++;
} else if (backEdgeNarrative instanceof LegSwitchingEdge) {
nextName = state.getBackState().getBackState().getBackState().getVertex().getName();
finalizeLeg(leg, state, path.states, startWalk, i - 1, coordinates);
leg = null;
pgstate = PlanGenState.START;
} else {
LOG.error("Unexpected state (in WALK): " + mode);
}
break;
case BICYCLE:
if (leg == null) {
leg = makeLeg(itinerary, state);
}
if (mode == TraverseMode.BICYCLE) {
// do nothing
} else if (mode == TraverseMode.WALK) {
finalizeLeg(leg, state, path.states, startWalk, i, coordinates);
leg = makeLeg(itinerary, state);
startWalk = i;
pgstate = PlanGenState.WALK;
} else if (mode == TraverseMode.STL) {
finalizeLeg(leg, state, path.states, startWalk, i, coordinates);
leg = null;
pgstate = PlanGenState.PRETRANSIT;
} else if (backEdgeNarrative instanceof LegSwitchingEdge) {
finalizeLeg(leg, state, path.states, startWalk, i - 1, coordinates);
leg = null;
pgstate = PlanGenState.START;
} else {
LOG.error("Unexpected state (in BICYCLE): " + mode);
}
break;
case CAR:
if (leg == null) {
leg = makeLeg(itinerary, state);
}
if (mode == TraverseMode.CAR) {
// do nothing
} else if (mode == TraverseMode.STL) {
finalizeLeg(leg, state, path.states, startWalk, i, coordinates);
leg = null;
pgstate = PlanGenState.PRETRANSIT;
} else if (backEdgeNarrative instanceof LegSwitchingEdge) {
finalizeLeg(leg, state, path.states, startWalk, i - 1, coordinates);
leg = null;
pgstate = PlanGenState.START;
} else {
LOG.error("Unexpected state (in CAR): " + mode);
}
break;
case PRETRANSIT:
if (mode == TraverseMode.BOARDING) {
if (leg != null) {
LOG.error("leg unexpectedly not null (boarding loop)");
} else {
leg = makeLeg(itinerary, state);
leg.stop = new ArrayList<Place>();
itinerary.transfers++;
leg.boardRule = (String) state.getExtension("boardAlightRule");
}
} else if (backEdge instanceof HopEdge) {
pgstate = PlanGenState.TRANSIT;
fixupTransitLeg(leg, state, transitIndex);
leg.stop = new ArrayList<Place>();
} else {
LOG.error("Unexpected state (in PRETRANSIT): " + mode);
}
break;
case TRANSIT:
String route = backEdgeNarrative.getName();
if (mode == TraverseMode.ALIGHTING) {
if (showIntermediateStops && leg.stop != null && leg.stop.size() > 0) {
if (leg.stop.isEmpty()) {
leg.stop = null;
}
}
leg.alightRule = (String) state.getExtension("boardAlightRule");
finalizeLeg(leg, state, null, -1, -1, coordinates);
leg = null;
pgstate = PlanGenState.START;
} else if (mode.toString().equals(leg.mode)) {
// no mode change, handle intermediate stops
if (showIntermediateStops) {
/*
* any further transit edge, add "from" vertex to intermediate stops
*/
if (!(backEdge instanceof DwellEdge)) {
Place stop = makePlace(state.getBackState(), true);
leg.stop.add(stop);
} else if (leg.stop.size() > 0) {
leg.stop.get(leg.stop.size() - 1).departure = makeCalendar(state);
}
}
if (!route.equals(leg.route)) {
// interline dwell
finalizeLeg(leg, state, null, -1, -1, coordinates);
leg = makeLeg(itinerary, state);
leg.stop = new ArrayList<Place>();
fixupTransitLeg(leg, state, transitIndex);
leg.startTime = makeCalendar(state);
leg.interlineWithPreviousLeg = true;
}
} else {
LOG.error("Unexpected state (in TRANSIT): " + mode);
}
break;
}
if (leg != null) {
leg.distance += backEdgeNarrative.getDistance();
Geometry edgeGeometry = backEdgeNarrative.getGeometry();
if (edgeGeometry != null) {
Coordinate[] edgeCoordinates = edgeGeometry.getCoordinates();
if (coordinates.size() > 0
&& coordinates.getCoordinate(coordinates.size() - 1).equals(edgeCoordinates[0])) {
coordinates.extend(edgeCoordinates, 1);
} else {
coordinates.extend(edgeCoordinates);
}
}
if (postponedAlerts != null) {
addNotesToLeg(leg, postponedAlerts);
postponedAlerts = null;
}
addNotesToLeg(leg, backEdgeNarrative);
}
} /* end loop over graphPath edge list */
if (leg != null) {
finalizeLeg(leg, path.states.getLast(), path.states, startWalk, i, coordinates);
}
itinerary.removeBogusLegs();
itinerary.fixupDates(graph.getService(CalendarServiceData.class));
if (itinerary.legs.size() == 0) throw new TrivialPathException();
return itinerary;
}