Examples with ElevatorAlightEdge org.opentripplanner.routing.edgetype.ElevatorAlightEdge used on opensource projects

Example 1 with ElevatorAlightEdge

use of org.opentripplanner.routing.edgetype.ElevatorAlightEdge in project OpenTripPlanner by opentripplanner.

the class AddTransitModelEntitiesToGraph method createElevatorEdgesAndAddThemToGraph.

/**
 * Create elevator edges from pathways. As pathway based elevators are not vertices, but edges
 * in the pathway model, we have to model each possible movement as an onboard-offboard pair,
 * instead of having only one set of vertices per level and edges between them.
 */
private void createElevatorEdgesAndAddThemToGraph(Graph graph, Pathway pathway, Vertex fromVertex, Vertex toVertex) {
    StationElement fromStation = fromVertex.getStationElement();
    String fromVertexLevelName = fromStation == null ? fromVertex.getName() : fromStation.getLevelName();
    Double fromVertexLevelIndex = fromStation == null ? null : fromStation.getLevelIndex();
    StationElement toStation = toVertex.getStationElement();
    String toVertexLevelName = toStation == null ? toVertex.getName() : toStation.getLevelName();
    Double toVertexLevelIndex = toStation == null ? null : toStation.getLevelIndex();
    double levels = 1;
    if (fromVertexLevelIndex != null && toVertexLevelIndex != null && !fromVertexLevelIndex.equals(toVertexLevelIndex)) {
        levels = Math.abs(fromVertexLevelIndex - toVertexLevelIndex);
    }
    ElevatorOffboardVertex fromOffboardVertex = new ElevatorOffboardVertex(graph, fromVertex.getLabel() + "_" + pathway.getId() + "_offboard", fromVertex.getX(), fromVertex.getY(), fromVertexLevelName);
    ElevatorOffboardVertex toOffboardVertex = new ElevatorOffboardVertex(graph, toVertex.getLabel() + "_" + pathway.getId() + "_offboard", toVertex.getX(), toVertex.getY(), toVertexLevelName);
    new PathwayEdge(fromVertex, fromOffboardVertex, fromVertex.getName());
    new PathwayEdge(toOffboardVertex, toVertex, toVertex.getName());
    ElevatorOnboardVertex fromOnboardVertex = new ElevatorOnboardVertex(graph, fromVertex.getLabel() + "_" + pathway.getId() + "_onboard", fromVertex.getX(), fromVertex.getY(), fromVertexLevelName);
    ElevatorOnboardVertex toOnboardVertex = new ElevatorOnboardVertex(graph, toVertex.getLabel() + "_" + pathway.getId() + "_onboard", toVertex.getX(), toVertex.getY(), toVertexLevelName);
    new ElevatorBoardEdge(fromOffboardVertex, fromOnboardVertex);
    new ElevatorAlightEdge(toOnboardVertex, toOffboardVertex, toVertexLevelName);
    StreetTraversalPermission permission = StreetTraversalPermission.PEDESTRIAN_AND_BICYCLE;
    new ElevatorHopEdge(fromOnboardVertex, toOnboardVertex, permission, levels, pathway.getTraversalTime());
    if (pathway.isBidirectional()) {
        new PathwayEdge(fromOffboardVertex, fromVertex, fromVertex.getName());
        new PathwayEdge(toVertex, toOffboardVertex, toVertex.getName());
        new ElevatorBoardEdge(toOffboardVertex, toOnboardVertex);
        new ElevatorAlightEdge(fromOnboardVertex, fromOffboardVertex, fromVertexLevelName);
        new ElevatorHopEdge(toOnboardVertex, fromOnboardVertex, permission, levels, pathway.getTraversalTime());
    }
}

Example 2 with ElevatorAlightEdge

use of org.opentripplanner.routing.edgetype.ElevatorAlightEdge in project OpenTripPlanner by opentripplanner.

the class GraphPathToItineraryMapper method generateWalkSteps.

/**
 * Converts a list of street edges to a list of turn-by-turn directions.
 *
 * @param previous a non-transit leg that immediately precedes this one (bike-walking, say), or null
 */
public static List<WalkStep> generateWalkSteps(Graph graph, State[] states, WalkStep previous, Locale requestedLocale) {
    List<WalkStep> steps = new ArrayList<>();
    WalkStep step = null;
    // distance used for appending elevation profiles
    double lastAngle = 0, distance = 0;
    // track whether we are in a roundabout, and if so the exit number
    int roundaboutExit = 0;
    String roundaboutPreviousStreet = null;
    State onBikeRentalState = null, offBikeRentalState = null;
    for (int i = 0; i < states.length - 1; i++) {
        State backState = states[i];
        State forwardState = states[i + 1];
        Edge edge = forwardState.getBackEdge();
        if (edge instanceof RentABikeOnEdge)
            onBikeRentalState = forwardState;
        if (edge instanceof RentABikeOffEdge)
            offBikeRentalState = forwardState;
        boolean createdNewStep = false, disableZagRemovalForThisStep = false;
        if (edge instanceof FreeEdge) {
            continue;
        }
        if (forwardState.getBackMode() == null || !forwardState.getBackMode().isOnStreetNonTransit()) {
            // ignore STLs and the like
            continue;
        }
        Geometry geom = edge.getGeometry();
        if (geom == null) {
            continue;
        }
        // before or will come after
        if (edge instanceof ElevatorAlightEdge) {
            // don't care what came before or comes after
            step = createWalkStep(graph, forwardState, requestedLocale);
            createdNewStep = true;
            disableZagRemovalForThisStep = true;
            // 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(requestedLocale);
            step.relativeDirection = RelativeDirection.ELEVATOR;
            steps.add(step);
            continue;
        }
        String streetName = edge.getName(requestedLocale);
        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(graph, forwardState, requestedLocale);
            createdNewStep = true;
            steps.add(step);
            double thisAngle = DirectionUtils.getFirstAngle(geom);
            if (previous == null) {
                step.setAbsoluteDirection(thisAngle);
                step.relativeDirection = RelativeDirection.DEPART;
            } else {
                step.setDirections(previous.angle, thisAngle, false);
            }
            // new step, set distance to length of first edge
            distance = edge.getDistanceMeters();
        } else if (((step.streetName != null && !step.streetNameNoParens().equals(streetNameNoParens)) && (!step.bogusName || !edge.hasBogusName())) || // went on to or off of a roundabout
        edge.isRoundabout() != (roundaboutExit > 0) || isLink(edge) && !isLink(backState.getBackEdge())) {
            // Street name has changed, or we've gone on to or off of a roundabout.
            if (roundaboutExit > 0) {
                // if we were just on a roundabout,
                // make note of which exit was taken in the existing step
                // ordinal numbers from
                step.exit = Integer.toString(roundaboutExit);
                if (streetNameNoParens.equals(roundaboutPreviousStreet)) {
                    step.stayOn = true;
                }
                roundaboutExit = 0;
            }
            /* start a new step */
            step = createWalkStep(graph, forwardState, requestedLocale);
            createdNewStep = true;
            steps.add(step);
            if (edge.isRoundabout()) {
                // indicate that we are now on a roundabout
                // and use one-based exit numbering
                roundaboutExit = 1;
                roundaboutPreviousStreet = backState.getBackEdge().getName(requestedLocale);
                idx = roundaboutPreviousStreet.indexOf('(');
                if (idx > 0)
                    roundaboutPreviousStreet = roundaboutPreviousStreet.substring(0, idx - 1);
            }
            double thisAngle = DirectionUtils.getFirstAngle(geom);
            step.setDirections(lastAngle, thisAngle, edge.isRoundabout());
            // new step, set distance to length of first edge
            distance = edge.getDistanceMeters();
        } else {
            /* street name has not changed */
            double thisAngle = DirectionUtils.getFirstAngle(geom);
            RelativeDirection direction = WalkStep.getRelativeDirection(lastAngle, thisAngle, edge.isRoundabout());
            boolean optionsBefore = backState.multipleOptionsBefore();
            if (edge.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 (edge.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 StreetEdge) {
                    // the next edges will be PlainStreetEdges, we hope
                    double angleDiff = getAbsoluteAngleDiff(thisAngle, lastAngle);
                    for (Edge alternative : backState.getVertex().getOutgoingStreetEdges()) {
                        if (alternative.getName(requestedLocale).equals(streetName)) {
                            // 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 {
                    double angleDiff = getAbsoluteAngleDiff(lastAngle, thisAngle);
                    // FIXME: this code might be wrong with the removal of the edge-based graph
                    State twoStatesBack = backState.getBackState();
                    Vertex backVertex = twoStatesBack.getVertex();
                    for (Edge alternative : backVertex.getOutgoingStreetEdges()) {
                        List<Edge> alternatives = alternative.getToVertex().getOutgoingStreetEdges();
                        if (alternatives.size() == 0) {
                            // this is not an alternative
                            continue;
                        }
                        alternative = alternatives.get(0);
                        if (alternative.getName(requestedLocale).equals(streetName)) {
                            // 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(graph, forwardState, requestedLocale);
                    createdNewStep = true;
                    steps.add(step);
                    step.setDirections(lastAngle, thisAngle, false);
                    step.stayOn = true;
                    // new step, set distance to length of first edge
                    distance = edge.getDistanceMeters();
                }
            }
        }
        State exitState = backState;
        Edge exitEdge = exitState.getBackEdge();
        while (exitEdge instanceof FreeEdge) {
            exitState = exitState.getBackState();
            exitEdge = exitState.getBackEdge();
        }
        if (exitState.getVertex() instanceof ExitVertex) {
            step.exit = ((ExitVertex) exitState.getVertex()).getExitName();
        }
        if (createdNewStep && !disableZagRemovalForThisStep && forwardState.getBackMode() == backState.getBackMode()) {
            // 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())) {
                    if (((lastStep.relativeDirection == RelativeDirection.RIGHT || lastStep.relativeDirection == RelativeDirection.HARD_RIGHT) && (twoBack.relativeDirection == RelativeDirection.RIGHT || twoBack.relativeDirection == RelativeDirection.HARD_RIGHT)) || ((lastStep.relativeDirection == RelativeDirection.LEFT || lastStep.relativeDirection == RelativeDirection.HARD_LEFT) && (twoBack.relativeDirection == RelativeDirection.LEFT || twoBack.relativeDirection == RelativeDirection.HARD_LEFT))) {
                        // in this case, we have two left turns or two right turns in quick
                        // succession; this is probably a U-turn.
                        steps.remove(last - 1);
                        lastStep.distance += twoBack.distance;
                        // A U-turn to the left, typical in the US.
                        if (lastStep.relativeDirection == RelativeDirection.LEFT || lastStep.relativeDirection == RelativeDirection.HARD_LEFT)
                            lastStep.relativeDirection = RelativeDirection.UTURN_LEFT;
                        else
                            lastStep.relativeDirection = RelativeDirection.UTURN_RIGHT;
                        // in this case, we're definitely staying on the same street
                        // (since it's zag removal, the street names are the same)
                        lastStep.stayOn = true;
                    } else {
                        // What is a zag? TODO write meaningful documentation for this.
                        // It appears to mean simplifying out several rapid turns in succession
                        // from the description.
                        // total hack to remove zags.
                        steps.remove(last);
                        steps.remove(last - 1);
                        step = threeBack;
                        step.distance += twoBack.distance;
                        distance += step.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.first + step.distance, d.second));
                                }
                            }
                        }
                    }
                }
            }
        } else {
            if (!createdNewStep && step.elevation != null) {
                List<P2<Double>> s = encodeElevationProfile(edge, distance, backState.getOptions().geoidElevation ? -graph.ellipsoidToGeoidDifference : 0);
                if (step.elevation != null && step.elevation.size() > 0) {
                    step.elevation.addAll(s);
                } else {
                    step.elevation = s;
                }
            }
            distance += edge.getDistanceMeters();
        }
        // increment the total length for this step
        step.distance += edge.getDistanceMeters();
        step.addStreetNotes(graph.streetNotesService.getNotes(forwardState));
        lastAngle = DirectionUtils.getLastAngle(geom);
        step.edges.add(edge);
    }
    // add bike rental information if applicable
    if (onBikeRentalState != null && !steps.isEmpty()) {
        steps.get(steps.size() - 1).bikeRentalOnStation = new BikeRentalStationInfo((BikeRentalStationVertex) onBikeRentalState.getBackEdge().getToVertex());
    }
    if (offBikeRentalState != null && !steps.isEmpty()) {
        steps.get(0).bikeRentalOffStation = new BikeRentalStationInfo((BikeRentalStationVertex) offBikeRentalState.getBackEdge().getFromVertex());
    }
    return steps;
}