@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); }
if (enableLogging) logger.info(encoder.toString() + " - access change via feature " + jsonFeature.getId()); edge.setFlags(encoder.setAccess(edge.getFlags(), value, value)); double oldSpeed = encoder.getSpeed(edge.getFlags()); if (oldSpeed != value) { updates++; if (enableLogging) logger.info(encoder.toString() + " - speed change via feature " + jsonFeature.getId() + ". Old: " + oldSpeed + ", new:" + value); edge.setFlags(encoder.setSpeed(edge.getFlags(), value));
public boolean needsTurnCostsSupport() { for (FlagEncoder encoder : edgeEncoders) { if (encoder.supports(TurnWeighting.class)) return true; } return false; } }
@Override protected final boolean checkAdjacent(EdgeIteratorState edge) { if (encoder.isForward(edge.getFlags()) || encoder.isBackward(edge.getFlags())) { tmpCounter++; return true; } return false; }
protected double getRoadSpeed(EdgeIteratorState edge, boolean reverse) { return reverse ? flagEncoder.getReverseSpeed(edge.getFlags()) : flagEncoder.getSpeed(edge.getFlags()); }
@Test public void testCombined() { FlagEncoder carEncoder = encodingManager.getEncoder("car"); long fl = footEncoder.setProperties(10, true, true) | carEncoder.setProperties(100, true, false); assertEquals(10, footEncoder.getSpeed(fl), 1e-1); assertTrue(footEncoder.isForward(fl)); assertTrue(footEncoder.isBackward(fl)); assertEquals(100, carEncoder.getSpeed(fl), 1e-1); assertTrue(carEncoder.isForward(fl)); assertFalse(carEncoder.isBackward(fl)); assertEquals(0, carEncoder.getSpeed(footEncoder.setProperties(10, true, true)), 1e-1); }
double speed = encoder.getSpeed(edge.getFlags()); Color color; if (speed >= 120) { boolean fwd = encoder.isForward(edge.getFlags()); boolean bwd = encoder.isBackward(edge.getFlags()); float width = speed > 90 ? 1f : 0.8f; if (fwd && !bwd) {
/** * Reports whether the edge is available in backward direction for the specified encoder. */ @Override public boolean isBackward(FlagEncoder encoder) { return encoder.isBackward(getDirectFlags()); }
/** * Reports whether the edge is available in forward direction for the specified encoder. */ @Override public boolean isForward(FlagEncoder encoder) { return encoder.isForward(getDirectFlags()); }
int removeEdges(EdgeExplorer explorer, FlagEncoder encoder, IntIndexedContainer component, int min) { int removedEdges = 0; if (component.size() < min) { for (int i = 0; i < component.size(); i++) { EdgeIterator edge = explorer.setBaseNode(component.get(i)); while (edge.next()) { edge.setFlags(encoder.setAccess(edge.getFlags(), false, false)); removedEdges++; } } } return removedEdges; }
@Test public void testTime() { FlagEncoder tmpEnc = new Bike2WeightFlagEncoder(); GraphHopperStorage g = new GraphBuilder(new EncodingManager(tmpEnc)).create(); Weighting w = new FastestWeighting(tmpEnc); long flags = tmpEnc.setSpeed(tmpEnc.setReverseSpeed(tmpEnc.setAccess(0, true, true), 10), 15); EdgeIteratorState edge = GHUtility.createMockedEdgeIteratorState(100000, flags); assertEquals(375 * 60 * 1000, w.calcMillis(edge, false, EdgeIterator.NO_EDGE)); assertEquals(600 * 60 * 1000, w.calcMillis(edge, true, EdgeIterator.NO_EDGE)); g.close(); } }
double defaultSpeed = encoder.getSpeed(GHUtility.getEdge(graph, 0, 1).getFlags()); AllEdgesIterator iter = graph.getAllEdges(); while (iter.next()) { long flags = GHUtility.getEdge(graph, 0, 1).getFlags(); assertEquals(defaultSpeed, encoder.getSpeed(flags), .1); assertTrue(encoder.isForward(flags)); double newSpeed = encoder.getSpeed(GHUtility.getEdge(graph, 0, 1).getFlags()); assertEquals(10, newSpeed, .1); assertTrue(newSpeed < defaultSpeed); assertFalse(encoder.isForward(GHUtility.getEdge(graph, 3, 4).getFlags()));
void connectStopsToStreetNetwork() { FlagEncoder footEncoder = ((GraphHopperStorage) graph).getEncodingManager().getEncoder("foot"); final EdgeFilter filter = DefaultEdgeFilter.allEdges(footEncoder); for (Stop stop : feed.stops.values()) { if (stop.location_type == 0) { // Only stops. Not interested in parent stations for now. QueryResult locationQueryResult = walkNetworkIndex.findClosest(stop.stop_lat, stop.stop_lon, filter); int streetNode; if (!locationQueryResult.isValid()) { streetNode = i++; nodeAccess.setNode(streetNode, stop.stop_lat, stop.stop_lon); EdgeIteratorState edge = graph.edge(streetNode, streetNode); edge.setFlags(encoder.setAccess(edge.getFlags(), true, false)); edge.setFlags(footEncoder.setAccess(edge.getFlags(), true, false)); edge.setFlags(footEncoder.setSpeed(edge.getFlags(), 5.0)); } else { streetNode = locationQueryResult.getClosestNode(); } gtfsStorage.getStationNodes().put(stop.stop_id, streetNode); } } }
edge.setFlags(list.get(0).setProperties(99.123, true, true)); assertEquals(99.123, list.get(0).getSpeed(edge.getFlags()), 1e-3); EdgeIteratorState edgeIter = GHUtility.getEdge(graph, 1, 0); long flags = edgeIter.getFlags(); assertEquals(99.123, list.get(0).getSpeed(flags), 1e-3); assertTrue(edgeIter.isForward(list.get(0))); assertTrue(edgeIter.isBackward(list.get(0))); edge = graph.edge(2, 3); edge.setFlags(list.get(1).setProperties(44.123, true, false)); assertEquals(44.123, list.get(1).getSpeed(edge.getFlags()), 1e-3); assertEquals(44.123, list.get(1).getSpeed(flags), 1e-3); assertEquals(44.123, list.get(1).getReverseSpeed(flags), 1e-3); assertFalse(edgeIter.isForward(list.get(1))); assertTrue(edgeIter.isBackward(list.get(1)));
boolean isRoundabout = encoder.isBool(flags, FlagEncoder.K_ROUNDABOUT); InstructionAnnotation annotation = encoder.getAnnotation(flags, tr); while (edgeIter.next()) { if ((edgeIter.getAdjNode() != prevNode) && !encoder.isBool(edgeIter.getFlags(), FlagEncoder.K_ROUNDABOUT)) { roundaboutInstruction.increaseExitNumber(); break; if (!encoder.isBool(edgeIter.getFlags(), FlagEncoder.K_ROUNDABOUT)) { ((RoundaboutInstruction) prevInstruction).increaseExitNumber(); break;
public CurvatureWeighting(FlagEncoder flagEncoder, PMap pMap) { super(flagEncoder, pMap); double minBendiness = 1; // see correctErrors double maxPriority = 1; // BEST / BEST minFactor = minBendiness / Math.log(flagEncoder.getMaxSpeed()) / (0.5 + maxPriority); }
static List<FlagEncoder> parseEncoderString(FlagEncoderFactory factory, String encoderList) { if (encoderList.contains(":")) throw new IllegalArgumentException("EncodingManager does no longer use reflection instantiate encoders directly."); if (!encoderList.equals(toLowerCase(encoderList))) throw new IllegalArgumentException("Since 0.7 EncodingManager does no longer accept upper case profiles: " + encoderList); String[] entries = encoderList.split(","); List<FlagEncoder> resultEncoders = new ArrayList<>(); for (String entry : entries) { entry = toLowerCase(entry.trim()); if (entry.isEmpty()) continue; String entryVal = ""; if (entry.contains("|")) { entryVal = entry; entry = entry.split("\\|")[0]; } PMap configuration = new PMap(entryVal); FlagEncoder fe = factory.createFlagEncoder(entry, configuration); if (configuration.has("version") && fe.getVersion() != configuration.getInt("version", -1)) throw new IllegalArgumentException("Encoder " + entry + " was used in version " + configuration.getLong("version", -1) + ", but current version is " + fe.getVersion()); resultEncoders.add(fe); } return resultEncoders; }
public void setRoundabout(boolean clockwise) { for (FlagEncoder encoder : mixedEncoders.fetchEdgeEncoders()) { for (EdgeIteratorState edge : roundaboutEdges) { edge.setFlags(encoder.setAccess(edge.getFlags(), clockwise, !clockwise)); edge.setFlags(encoder.setBool(edge.getFlags(), FlagEncoder.K_ROUNDABOUT, true)); } } this.clockwise = clockwise; }
@Test public void testMinWeightHasSameUnitAs_getWeight() { Weighting instance = new FastestWeighting(encoder); long flags = encoder.setProperties(encoder.getMaxSpeed(), true, true); assertEquals(instance.getMinWeight(10), instance.calcWeight(createMockedEdgeIteratorState(10, flags), false, EdgeIterator.NO_EDGE), 1e-8); }