@Override public double calcWeight(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { return edgeState.getDistance(); }
@Override public double getDistance() { return edges.get(current).getDistance(); }
@Override public double calcWeight(EdgeIteratorState edge, boolean reverse, int prevOrNextEdgeId) { double time = super.calcWeight(edge, reverse, prevOrNextEdgeId); return time * timeFactor + edge.getDistance() * distanceFactor; }
@Override public boolean isEdgeDifferentToLastEdge(EdgeIteratorState edge) { if (edge.getEdge() != edgeId) { edgeId = edge.getEdge(); distance = edge.getDistance(); return true; } return false; }
@Override public double calcWeight(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { int adj = edgeState.getAdjNode(); int base = edgeState.getBaseNode(); if (reverse) { int tmp = base; base = adj; adj = tmp; } // a 'hill' at node 6 if (adj == 6) return 3 * edgeState.getDistance(); else if (base == 6) return edgeState.getDistance() * 0.9; else if (adj == 4) return 2 * edgeState.getDistance(); return edgeState.getDistance() * 0.8; }
/** * Calculates the distance and time of the specified edgeId. Also it adds the edgeId to the path list. * * @param prevEdgeId here the edge that comes before edgeId is necessary. I.e. for the reverse search we need the * next edge. */ protected void processEdge(int edgeId, int adjNode, int prevEdgeId) { EdgeIteratorState iter = graph.getEdgeIteratorState(edgeId, adjNode); distance += iter.getDistance(); time += weighting.calcMillis(iter, false, prevEdgeId); addEdge(edgeId); }
@Override public long calcMillis(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { long flags = edgeState.getFlags(); if (reverse && !flagEncoder.isBackward(flags) || !reverse && !flagEncoder.isForward(flags)) throw new IllegalStateException("Calculating time should not require to read speed from edge in wrong direction. " + "Reverse:" + reverse + ", fwd:" + flagEncoder.isForward(flags) + ", bwd:" + flagEncoder.isBackward(flags)); double speed = reverse ? flagEncoder.getReverseSpeed(flags) : flagEncoder.getSpeed(flags); if (Double.isInfinite(speed) || Double.isNaN(speed) || speed < 0) throw new IllegalStateException("Invalid speed stored in edge! " + speed); if (speed == 0) throw new IllegalStateException("Speed cannot be 0 for unblocked edge, use access properties to mark edge blocked! Should only occur for shortest path calculation. See #242."); return (long) (edgeState.getDistance() * 3600 / speed); }
@Override public long calcMillis(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { // TODO to avoid expensive reverse flags include oneway accessibility // but how to include e.g. maxspeed as it depends on direction? Does highway depend on direction? // reverse = edge.isReverse()? !reverse : reverse; double speed = weightingConfig.getSpeed(edgeState); if (speed == 0) return Long.MAX_VALUE; // TODO inner city guessing -> lit, maxspeed <= 50, residential etc => create new encoder.isInnerCity(edge) // See #472 use edge.getDouble((encoder), K_MAXSPEED_MOTORVEHICLE_FORWARD, _default) or edge.getMaxSpeed(...) instead? // encoder could be made optional via passing to EdgeExplorer double maxspeed = gEncoder.getMaxspeed(edgeState, accessType, reverse); if (maxspeed > 0 && speed > maxspeed) speed = maxspeed; // TODO test performance difference for rounding long timeInMillis = (long) (edgeState.getDistance() / speed * SPEED_CONV); // add direction penalties at start/stop/via points boolean unfavoredEdge = edgeState.getBool(EdgeIteratorState.K_UNFAVORED_EDGE, false); if (unfavoredEdge) timeInMillis += headingPenaltyMillis; // TODO avoid a certain (or multiple) bounding boxes (less efficient for just a few edges) or a list of edgeIDs (not good for large areas) // bbox.contains(nodeAccess.getLatitude(edge.getBaseNode()), nodeAccess.getLongitude(edge.getBaseNode())) time+=avoidPenalty; // TODO surfaces can reduce average speed // TODO prefer or avoid bike and hike routes if (timeInMillis < 0) throw new IllegalStateException("Some problem with weight calculation: time:" + timeInMillis + ", speed:" + speed); return timeInMillis; }
@Override public double calcWeight(EdgeIteratorState edge, boolean reverse, int prevOrNextEdgeId) { double priority = flagEncoder.getDouble(edge.getFlags(), KEY); double bendiness = flagEncoder.getDouble(edge.getFlags(), MotorcycleFlagEncoder.CURVATURE_KEY); double speed = getRoadSpeed(edge, reverse); double roadDistance = edge.getDistance(); // We use the log of the speed to decrease the impact of the speed, therefore we don't use the highway double regularWeight = roadDistance / Math.log(speed); return (bendiness * regularWeight) / (0.5 + priority); }
private static void printUnitTestEdge(FlagEncoder flagEncoder, EdgeIteratorState edge) { boolean fwd = edge.isForward(flagEncoder); boolean bwd = edge.isBackward(flagEncoder); if (!fwd && !bwd) { return; } int from = fwd ? edge.getBaseNode() : edge.getAdjNode(); int to = fwd ? edge.getAdjNode() : edge.getBaseNode(); System.out.printf(Locale.ROOT, "graph.edge(%d, %d, %f, %s);\n", from, to, edge.getDistance(), fwd && bwd ? "true" : "false"); }
@Override public double calcWeight(EdgeIteratorState edge, boolean reverse, int prevOrNextEdgeId) { double speed = reverse ? flagEncoder.getReverseSpeed(edge.getFlags()) : flagEncoder.getSpeed(edge.getFlags()); if (speed == 0) return Double.POSITIVE_INFINITY; double time = edge.getDistance() / speed * SPEED_CONV; // add direction penalties at start/stop/via points boolean unfavoredEdge = edge.getBool(EdgeIteratorState.K_UNFAVORED_EDGE, false); if (unfavoredEdge) time += headingPenalty; return time; }
private Shortcut expectedShortcut(int baseNode, int adjNode, EdgeIteratorState edge1, EdgeIteratorState edge2, boolean fwd, boolean bwd) { //todo: weight calculation might have to be adjusted for different encoders/weightings/reverse speed double weight = weighting.calcWeight(edge1, false, EdgeIterator.NO_EDGE) + weighting.calcWeight(edge2, false, EdgeIterator.NO_EDGE); double distance = edge1.getDistance() + edge2.getDistance(); return new Shortcut(baseNode, adjNode, weight, distance, fwd, bwd, edge1.getEdge(), edge2.getEdge()); }
@Test public void testSetTooBigDistance_435() { graph = createGHStorage(); double maxDist = EdgeAccess.MAX_DIST; EdgeIteratorState edge1 = graph.edge(0, 1, maxDist, true); assertEquals(maxDist, edge1.getDistance(), 1); // max out should NOT lead to infinity as this leads fast to NaN! try { graph.edge(0, 2, maxDist + 1, true); } catch (Exception ex) { assertTrue(ex.getMessage(), ex.getMessage().startsWith("Distance too large")); } }
private static EdgeLabel getEdgeLabel(EdgeIteratorState edgeIteratorState, PtFlagEncoder flagEncoder) { return new EdgeLabel(edgeIteratorState, flagEncoder.getEdgeType(edgeIteratorState.getFlags()), flagEncoder.getValidityId(edgeIteratorState.getFlags()), flagEncoder.getTransfers(edgeIteratorState.getFlags()), edgeIteratorState.getDistance()); }
private void updatePointsAndInstruction(EdgeIteratorState edge, PointList pl) { // skip adjNode int len = pl.size() - 1; for (int i = 0; i < len; i++) { prevInstruction.getPoints().add(pl, i); } double newDist = edge.getDistance(); prevInstruction.setDistance(newDist + prevInstruction.getDistance()); prevInstruction.setTime(weighting.calcMillis(edge, false, EdgeIterator.NO_EDGE) + prevInstruction.getTime()); }
@Override public void applyWayTags(ReaderWay way, EdgeIteratorState edge) { double speed = this.getSpeed(edge.getFlags()); double roadDistance = edge.getDistance(); double beelineDistance = getBeelineDistance(way); double bendiness = beelineDistance / roadDistance; bendiness = discriminateSlowStreets(bendiness, speed); bendiness = increaseBendinessImpact(bendiness); bendiness = correctErrors(bendiness); edge.setFlags(this.curvatureEncoder.setValue(edge.getFlags(), convertToInt(bendiness))); }
@Test public void testPropertiesWithNoInit() { graph = createGHStorage(); assertEquals(0, graph.edge(0, 1).getFlags()); assertEquals(0, graph.edge(0, 2).getDistance(), 1e-6); }
@Test public void testCopyProperties() { graph = createGHStorage(); EdgeIteratorState edge = graph.edge(1, 3, 10, false).setName("testing").setWayGeometry(Helper.createPointList(1, 2)); EdgeIteratorState newEdge = graph.edge(1, 3, 10, false); edge.copyPropertiesTo(newEdge); assertEquals(edge.getName(), newEdge.getName()); assertEquals(edge.getDistance(), newEdge.getDistance(), 1e-7); assertEquals(edge.getFlags(), newEdge.getFlags()); assertEquals(edge.fetchWayGeometry(0), newEdge.fetchWayGeometry(0)); }
protected GraphHopperStorage createTestStorage() { GraphHopperStorage graph = createGHStorage(false); graph.edge(0, 1, 7, true); graph.edge(0, 4, 6, true); graph.edge(1, 4, 2, true); graph.edge(1, 5, 8, true); graph.edge(1, 2, 2, true); graph.edge(2, 5, 5, true); graph.edge(2, 3, 2, true); graph.edge(3, 5, 2, true); graph.edge(3, 7, 10, true); graph.edge(4, 6, 4, true); graph.edge(4, 5, 7, true); graph.edge(5, 6, 2, true); graph.edge(5, 7, 1, true); EdgeIteratorState edge6_7 = graph.edge(6, 7, 5, true); updateDistancesFor(graph, 0, 0.0010, 0.00001); updateDistancesFor(graph, 1, 0.0008, 0.0000); updateDistancesFor(graph, 2, 0.0005, 0.0001); updateDistancesFor(graph, 3, 0.0006, 0.0002); updateDistancesFor(graph, 4, 0.0009, 0.0001); updateDistancesFor(graph, 5, 0.0007, 0.0001); updateDistancesFor(graph, 6, 0.0009, 0.0002); updateDistancesFor(graph, 7, 0.0008, 0.0003); edge6_7.setDistance(5 * edge6_7.getDistance()); return graph; }
protected void initDirectedAndDiffSpeed(Graph graph, FlagEncoder enc) { graph.edge(0, 1).setFlags(enc.setProperties(10, true, false)); graph.edge(0, 4).setFlags(enc.setProperties(100, true, false)); graph.edge(1, 4).setFlags(enc.setProperties(10, true, true)); graph.edge(1, 5).setFlags(enc.setProperties(10, true, true)); EdgeIteratorState edge12 = graph.edge(1, 2).setFlags(enc.setProperties(10, true, true)); graph.edge(5, 2).setFlags(enc.setProperties(10, true, false)); graph.edge(2, 3).setFlags(enc.setProperties(10, true, false)); EdgeIteratorState edge53 = graph.edge(5, 3).setFlags(enc.setProperties(20, true, false)); graph.edge(3, 7).setFlags(enc.setProperties(10, true, false)); graph.edge(4, 6).setFlags(enc.setProperties(100, true, false)); graph.edge(5, 4).setFlags(enc.setProperties(10, true, false)); graph.edge(5, 6).setFlags(enc.setProperties(10, true, false)); graph.edge(7, 5).setFlags(enc.setProperties(100, true, false)); graph.edge(6, 7).setFlags(enc.setProperties(100, true, true)); updateDistancesFor(graph, 0, 0.002, 0); updateDistancesFor(graph, 1, 0.002, 0.001); updateDistancesFor(graph, 2, 0.002, 0.002); updateDistancesFor(graph, 3, 0.002, 0.003); updateDistancesFor(graph, 4, 0.0015, 0); updateDistancesFor(graph, 5, 0.0015, 0.001); updateDistancesFor(graph, 6, 0, 0); updateDistancesFor(graph, 7, 0.001, 0.003); edge12.setDistance(edge12.getDistance() * 2); edge53.setDistance(edge53.getDistance() * 2); }