/** * Returns the identifier to access the map of the shortest path tree according to the traversal * mode. E.g. returning the adjacent node id in node-based behavior whilst returning the edge id * in edge-based behavior * <p> * * @param iterState the current {@link EdgeIteratorState} * @param reverse <code>true</code>, if traversal in backward direction. Will be true only for * backward searches in bidirectional algorithms. * @return the identifier to access the shortest path tree */ public final int createTraversalId(EdgeIteratorState iterState, boolean reverse) { if (edgeBased) { if (noOfStates == 1) return iterState.getEdge(); return GHUtility.createEdgeKey(iterState.getBaseNode(), iterState.getAdjNode(), iterState.getEdge(), reverse); } return iterState.getAdjNode(); }
@Override public EdgeIteratorState edge(int a, int b, double distance, boolean bothDirection) { return edge(a, b).setDistance(distance).setFlags(encodingManager.flagsDefault(true, bothDirection)); }
@Override public PointList fetchWayGeometry(int mode) { return edges.get(current).fetchWayGeometry(mode); }
@Override public String toString() { if (closestEdge != null) return closestEdge.getBaseNode() + "-" + closestEdge.getAdjNode() + " " + snappedPoint; return closestNode + ", " + queryPoint + ", " + wayIndex; }
@Override public boolean isEdgeDifferentToLastEdge(EdgeIteratorState edge) { if (edge.getEdge() != edgeId) { edgeId = edge.getEdge(); distance = edge.getDistance(); return true; } return false; }
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"); }
final PointList fullPL = closestEdge.fetchWayGeometry(3); int baseNode = closestEdge.getBaseNode(); int adjNode = closestEdge.getAdjNode(); int origTraversalKey = GHUtility.createEdgeKey(baseNode, adjNode, closestEdge.getEdge(), false); int origRevTraversalKey = GHUtility.createEdgeKey(baseNode, adjNode, closestEdge.getEdge(), true); long reverseFlags = closestEdge.detach(true).getFlags(); int prevWayIndex = 1; int prevNodeId = baseNode; if (res.getClosestEdge().getBaseNode() != baseNode) throw new IllegalStateException("Base nodes have to be identical but were not: " + closestEdge + " vs " + res.getClosestEdge());
@Test public void testNameIndex() { graph = createGHStorage(); EdgeIteratorState iter1 = graph.edge(0, 1, 10, true); iter1.setName("named street1"); EdgeIteratorState iter2 = graph.edge(0, 1, 10, true); iter2.setName("named street2"); assertEquals("named street1", graph.getEdgeIteratorState(iter1.getEdge(), iter1.getAdjNode()).getName()); assertEquals("named street2", graph.getEdgeIteratorState(iter2.getEdge(), iter2.getAdjNode()).getName()); }
@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)); }
graph.edge(0, 1, 2, true); long flags = carEncoder.setProperties(10, true, false); graph.edge(0, 2, 2, true).setWayGeometry(Helper.createPointList(1, 2, 3, 4)).setFlags(flags); graph.edge(1, 2, 2, true); EdgeIteratorState edgeState02 = iter.detach(false); assertEquals(2, iter.getAdjNode()); assertEquals(1, edgeState02.fetchWayGeometry(0).getLatitude(0), 1e-1); assertEquals(2, edgeState02.getAdjNode()); assertTrue(carEncoder.isForward(edgeState02.getFlags())); assertEquals(0, edgeState20.getAdjNode()); assertEquals(2, edgeState20.getBaseNode()); assertEquals(3, edgeState20.fetchWayGeometry(0).getLatitude(0), 1e-1); assertFalse(carEncoder.isForward(edgeState20.getFlags())); assertEquals(GHUtility.getEdge(graph, 0, 2).getFlags(), edgeState02.getFlags()); assertEquals(GHUtility.getEdge(graph, 2, 0).getFlags(), edgeState20.getFlags()); assertEquals(2, edgeState02.getAdjNode()); assertEquals(2, edgeState20.getBaseNode()); assertEquals(1, edgeState02.fetchWayGeometry(0).getLatitude(0), 1e-1); assertEquals(3, edgeState20.fetchWayGeometry(0).getLatitude(0), 1e-1); graph.edge(3, 3, 2, true).setFlags(flags); EdgeIterator edgeState33 = graph.createEdgeExplorer().setBaseNode(3); edgeState33.next(); assertEquals(3, edgeState33.getBaseNode()); assertEquals(3, edgeState33.getAdjNode());
@Override protected SPTEntry createEntry(EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse) { SPTEntry entry = new SPTEntry(edge.getEdge(), edge.getAdjNode(), weight); entry.parent = parent; return entry; }
/** * @return to */ EdgeIteratorState copyProperties(CommonEdgeIterator from, EdgeIteratorState to) { to.setDistance(from.getDistance()). setName(from.getName()). setFlags(from.getDirectFlags()). setWayGeometry(from.fetchWayGeometry(0)); if (E_ADDITIONAL >= 0) to.setAdditionalField(from.getAdditionalField()); return to; }
protected void updateEntry(SPTEntry entry, EdgeIteratorState edge, double weight, SPTEntry parent, boolean reverse) { entry.edge = edge.getEdge(); entry.weight = weight; entry.parent = parent; }
@Test public void testEdgeReturn() { graph = createGHStorage(); EdgeIteratorState iter = graph.edge(4, 10).setDistance(100).setFlags(carEncoder.setProperties(10, true, false)); assertEquals(4, iter.getBaseNode()); assertEquals(10, iter.getAdjNode()); iter = graph.edge(14, 10).setDistance(100).setFlags(carEncoder.setProperties(10, true, false)); assertEquals(14, iter.getBaseNode()); assertEquals(10, iter.getAdjNode()); }
@Override public long calcMillis(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { long millis = superWeighting.calcMillis(edgeState, reverse, prevOrNextEdgeId); if (prevOrNextEdgeId == EdgeIterator.NO_EDGE) return millis; // TODO for now assume turn costs are returned in milliseconds? // should we also separate weighting vs. time for turn? E.g. a fast but dangerous turn - is this common? long turnCostsInMillis; if (reverse) turnCostsInMillis = (long) calcTurnWeight(edgeState.getEdge(), edgeState.getBaseNode(), prevOrNextEdgeId); else turnCostsInMillis = (long) calcTurnWeight(prevOrNextEdgeId, edgeState.getBaseNode(), edgeState.getEdge()); return millis + turnCostsInMillis; }
private Graph initExampleGraph() { GraphHopperStorage gs = new GraphHopperStorage(new RAMDirectory(), em, true, new GraphExtension.NoOpExtension()).create(1000); NodeAccess na = gs.getNodeAccess(); // 50--(0.0001)-->49--(0.0004)-->55--(0.0005)-->60 na.setNode(0, 51.1, 12.001, 50); na.setNode(1, 51.1, 12.002, 60); EdgeIteratorState edge = gs.edge(0, 1). setWayGeometry(Helper.createPointList3D(51.1, 12.0011, 49, 51.1, 12.0015, 55)); edge.setDistance(100); edge.setFlags(encoder.setReverseSpeed(encoder.setProperties(10, true, true), 15)); return gs; }
private void setEdgeTypeAndClearDistance(EdgeIteratorState edge, GtfsStorage.EdgeType edgeType) { edge.setDistance(0.0); edge.setFlags(encoder.setEdgeType(edge.getFlags(), edgeType)); }
private void setFeedIdWithTimezone(EdgeIteratorState leaveTimeExpandedNetworkEdge, GtfsStorage.FeedIdWithTimezone validOn) { int validityId; if (gtfsStorage.getWritableTimeZones().containsKey(validOn)) { validityId = gtfsStorage.getWritableTimeZones().get(validOn); } else { validityId = gtfsStorage.getWritableTimeZones().size(); gtfsStorage.getWritableTimeZones().put(validOn, validityId); } leaveTimeExpandedNetworkEdge.setFlags(encoder.setValidityId(leaveTimeExpandedNetworkEdge.getFlags(), validityId)); }
@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; }
@Override public EdgeIteratorState detach(boolean reverse) { if (reverse) { reverseEdge.setFlags(getFlags()); reverseEdge.setName(getName()); reverseEdge.setDistance(getDistance()); return reverseEdge; } else { return this; } }