public static List<Integer> getEdgeIds(EdgeIterator iter) { List<Integer> list = new ArrayList<>(); while (iter.next()) { list.add(iter.getEdge()); } return list; }
if (osmReader.getOsmIdOfInternalEdge(iter.getEdge()) == this.fromOsmWayId) { edgeIdFrom = iter.getEdge(); break; int edgeId = iter.getEdge(); long wayId = osmReader.getOsmIdOfInternalEdge(edgeId); if (edgeId != edgeIdFrom && this.restriction == Type.ONLY && wayId != this.toOsmWayId entry.nodeVia = nodeVia; entry.edgeFrom = edgeIdFrom; entry.edgeTo = iter.getEdge(); entry.flags = encoder.getTurnFlags(true, 0); entries.add(entry);
if (currEdge.edge == iter.getEdge()) { continue; IsoLabel nEdge = fromMap.get(tmpNode); if (nEdge == null) { nEdge = new IsoLabel(iter.getEdge(), tmpNode, tmpWeight, tmpTime, tmpDistance); nEdge.parent = currEdge; fromMap.put(tmpNode, nEdge); } else if (nEdge.weight > tmpWeight) { fromHeap.remove(nEdge); nEdge.edge = iter.getEdge(); nEdge.weight = tmpWeight; nEdge.distance = tmpDistance;
private int findPlatformNode(int stationNode, GtfsStorageI.PlatformDescriptor platformDescriptor, GtfsStorage.EdgeType edgeType) { DefaultEdgeFilter filter; if (edgeType == GtfsStorage.EdgeType.ENTER_PT) { filter = DefaultEdgeFilter.outEdges(encoder); } else if (edgeType == GtfsStorage.EdgeType.EXIT_PT) { filter = DefaultEdgeFilter.inEdges(encoder); } else { throw new RuntimeException(); } EdgeIterator i = graph.getBaseGraph().createEdgeExplorer(filter).setBaseNode(stationNode); while (i.next()) { if (encoder.getEdgeType(i.getFlags()) == edgeType) { if (platformDescriptor.equals(gtfsStorage.getRoutes().get(i.getEdge()))) { return i.getAdjNode(); } } } return -1; }
estimationFullWeight = alreadyVisitedWeight + currWeightToGoal; if (ase == null) { ase = new AStarEntry(iter.getEdge(), neighborNode, estimationFullWeight, alreadyVisitedWeight); fromMap.put(traversalId, ase); } else { ase.edge = iter.getEdge(); ase.weight = estimationFullWeight; ase.weightOfVisitedPath = alreadyVisitedWeight;
public static boolean check(GraphHopperStorage storage, EdgeExplorer edgeExplorer, int node) { List<Integer> toNodes = new ArrayList<>(); List<Integer> edges = new ArrayList<>(); EdgeIterator edgeIterator = edgeExplorer.setBaseNode(node); while(edgeIterator.next()) { if (edgeIterator.getBaseNode() < 0 || edgeIterator.getAdjNode() < 0) { return false; } toNodes.add(edgeIterator.getAdjNode()); edges.add(edgeIterator.getEdge()); } for(int i=0;i<toNodes.size();i++) { EdgeIteratorState edgeIteratorState = storage.getEdgeIteratorState(edges.get(i), toNodes.get(i)); if(edgeIteratorState == null) { return false; } EdgeIteratorState edgeIteratorState2 = storage.getEdgeIteratorState(edges.get(i), node); if(edgeIteratorState2 == null) { return false; } } return true; }
private void insertInboundTransfers(String fromStopId, String from_route_id, int minimumTransferTime, NavigableMap<Integer, Integer> toStopTimelineNode) { int stationNode = gtfsStorage.getStationNodes().get(fromStopId); EdgeIterator i = graph.createEdgeExplorer().setBaseNode(stationNode); while (i.next()) { if (encoder.getEdgeType(i.getFlags()) == GtfsStorage.EdgeType.EXIT_PT) { GtfsStorageI.PlatformDescriptor routeId = gtfsStorage.getRoutes().get(i.getEdge()); if (from_route_id == null || GtfsStorageI.PlatformDescriptor.route(from_route_id).equals(routeId)) { EdgeIterator j = graph.createEdgeExplorer().setBaseNode(i.getAdjNode()); while (j.next()) { if (encoder.getEdgeType(j.getFlags()) == GtfsStorage.EdgeType.LEAVE_TIME_EXPANDED_NETWORK) { int arrivalTime = (int) encoder.getTime(j.getFlags()); SortedMap<Integer, Integer> tailSet = toStopTimelineNode.tailMap(arrivalTime + minimumTransferTime); if (!tailSet.isEmpty()) { EdgeIteratorState edge = graph.edge(j.getAdjNode(), tailSet.get(tailSet.firstKey())); edge.setFlags(encoder.setAccess(edge.getFlags(), true, false)); setEdgeTypeAndClearDistance(edge, GtfsStorage.EdgeType.TRANSFER); edge.setFlags(encoder.setTime(edge.getFlags(), tailSet.firstKey() - arrivalTime)); } } } } } } }
void fillVirtualEdges(IntObjectMap<VirtualEdgeIterator> node2Edge, int towerNode, EdgeExplorer mainExpl) { if (isVirtualNode(towerNode)) throw new IllegalStateException("Node should not be virtual:" + towerNode + ", " + node2Edge); VirtualEdgeIterator vIter = node2Edge.get(towerNode); IntArrayList ignoreEdges = new IntArrayList(vIter.count() * 2); while (vIter.next()) { EdgeIteratorState edge = queryResults.get(vIter.getAdjNode() - mainNodes).getClosestEdge(); ignoreEdges.add(edge.getEdge()); } vIter.reset(); EdgeIterator iter = mainExpl.setBaseNode(towerNode); while (iter.next()) { if (!ignoreEdges.contains(iter.getEdge())) vIter.add(iter.detach(false)); } }
int incomingEdge = incomingEdges.getEdge(); int inOrigEdgeCount = getOrigEdgeCount(incomingEdge); double existingDirectWeight = incomingEdgeWeight + prepareWeighting.calcWeight(outgoingEdges, false, incomingEdges.getEdge()); if (Double.isNaN(existingDirectWeight)) throw new IllegalStateException("Weighting should never return NaN values" outgoingEdges.getEdge(), getOrigEdgeCount(outgoingEdges.getEdge()), incomingEdge, inOrigEdgeCount);
public static String getNodeInfo(Graph g, int nodeId, EdgeFilter filter) { EdgeIterator iter = g.createEdgeExplorer(filter).setBaseNode(nodeId); NodeAccess na = g.getNodeAccess(); String str = nodeId + ":" + na.getLatitude(nodeId) + "," + na.getLongitude(nodeId) + "\n"; while (iter.next()) { str += " ->" + iter.getAdjNode() + " (" + iter.getDistance() + ") pillars:" + iter.fetchWayGeometry(0).getSize() + ", edgeId:" + iter.getEdge() + "\t" + BitUtil.BIG.toBitString(iter.getFlags(), 8) + "\n"; } return str; }
void prepare() { final EdgeIterator allIter = graph.getAllEdges(); try { while (allIter.next()) { int nodeA = allIter.getBaseNode(); int nodeB = allIter.getAdjNode(); double lat1 = nodeAccess.getLatitude(nodeA); double lon1 = nodeAccess.getLongitude(nodeA); double lat2; double lon2; PointList points = allIter.fetchWayGeometry(0); int len = points.getSize(); for (int i = 0; i < len; i++) { lat2 = points.getLatitude(i); lon2 = points.getLongitude(i); addNode(nodeA, nodeB, lat1, lon1, lat2, lon2); lat1 = lat2; lon1 = lon2; } lat2 = nodeAccess.getLatitude(nodeB); lon2 = nodeAccess.getLongitude(nodeB); addNode(nodeA, nodeB, lat1, lon1, lat2, lon2); } } catch (Exception ex) { logger.error("Problem! base:" + allIter.getBaseNode() + ", adj:" + allIter.getAdjNode() + ", edge:" + allIter.getEdge(), ex); } }
private void insertOutboundTransfers(String toStopId, String toRouteId, int minimumTransferTime, NavigableMap<Integer, Integer> fromStopTimelineNodes) { int stationNode = gtfsStorage.getStationNodes().get(toStopId); EdgeIterator i = graph.getBaseGraph().createEdgeExplorer().setBaseNode(stationNode); while (i.next()) { GtfsStorage.EdgeType edgeType = encoder.getEdgeType(i.getFlags()); if (edgeType == GtfsStorage.EdgeType.ENTER_PT) { GtfsStorageI.PlatformDescriptor routeId = gtfsStorage.getRoutes().get(i.getEdge()); if (toRouteId == null || routeId instanceof GtfsStorageI.RouteTypePlatform || GtfsStorageI.PlatformDescriptor.route(toRouteId).equals(routeId)) { fromStopTimelineNodes.forEach((time, e) -> { EdgeIterator j = graph.getBaseGraph().createEdgeExplorer().setBaseNode(i.getAdjNode()); while (j.next()) { GtfsStorage.EdgeType edgeType2 = encoder.getEdgeType(j.getFlags()); if (edgeType2 == GtfsStorage.EdgeType.ENTER_TIME_EXPANDED_NETWORK) { int departureTime = (int) encoder.getTime(j.getFlags()); if (departureTime < time + minimumTransferTime) { continue; } EdgeIteratorState edge = graph.edge(e, j.getAdjNode()); edge.setFlags(encoder.setAccess(edge.getFlags(), true, false)); setEdgeTypeAndClearDistance(edge, GtfsStorage.EdgeType.TRANSFER); edge.setFlags(encoder.setTime(edge.getFlags(), departureTime - time)); break; } } }); } } } }
private void assertEdgeIdsStayingEqual(EdgeExplorer inExplorer, EdgeExplorer outExplorer, int startNode, int endNode) { EdgeIterator it = outExplorer.setBaseNode(startNode); it.next(); assertEquals(startNode, it.getBaseNode()); assertEquals(endNode, it.getAdjNode()); // we expect the edge id to be the same when exploring in backward direction int expectedEdgeId = it.getEdge(); assertFalse(it.next()); // backward iteration, edge id should remain the same!! it = inExplorer.setBaseNode(endNode); it.next(); assertEquals(endNode, it.getBaseNode()); assertEquals(startNode, it.getAdjNode()); assertEquals("The edge id is not the same,", expectedEdgeId, it.getEdge()); assertFalse(it.next()); }
@Test public void testInternalAPIOriginalTraversalKey() { initGraph(g); EdgeExplorer explorer = g.createEdgeExplorer(); QueryGraph queryGraph = new QueryGraph(g); EdgeIterator iter = explorer.setBaseNode(1); assertTrue(iter.next()); int origEdgeId = iter.getEdge(); QueryResult res = createLocationResult(2, 1.5, iter, 1, PILLAR); queryGraph.lookup(Arrays.asList(res)); assertEquals(new GHPoint(1.5, 1.5), res.getSnappedPoint()); assertEquals(3, res.getClosestNode()); EdgeExplorer qGraphExplorer = queryGraph.createEdgeExplorer(); iter = qGraphExplorer.setBaseNode(3); assertTrue(iter.next()); assertEquals(0, iter.getAdjNode()); assertEquals(GHUtility.createEdgeKey(1, 0, origEdgeId, false), ((VirtualEdgeIteratorState) queryGraph.getEdgeIteratorState(iter.getEdge(), 0)).getOriginalTraversalKey()); assertTrue(iter.next()); assertEquals(1, iter.getAdjNode()); assertEquals(GHUtility.createEdgeKey(0, 1, origEdgeId, false), ((VirtualEdgeIteratorState) queryGraph.getEdgeIteratorState(iter.getEdge(), 1)).getOriginalTraversalKey()); }
@Test public void testExtract2() { Graph g = createGraph(); g.edge(1, 2, 10, false); g.edge(2, 3, 20, false); EdgeExplorer explorer = g.createEdgeExplorer(carOutEdges); EdgeIterator iter = explorer.setBaseNode(1); iter.next(); PathBidirRef pw = new PathBidirRef(g, new FastestWeighting(carEncoder)); pw.sptEntry = new SPTEntry(iter.getEdge(), 2, 10); pw.sptEntry.parent = new SPTEntry(EdgeIterator.NO_EDGE, 1, 0); explorer = g.createEdgeExplorer(DefaultEdgeFilter.inEdges(carEncoder)); iter = explorer.setBaseNode(3); iter.next(); pw.edgeTo = new SPTEntry(iter.getEdge(), 2, 20); pw.edgeTo.parent = new SPTEntry(EdgeIterator.NO_EDGE, 3, 0); Path p = pw.extract(); assertEquals(IntArrayList.from(new int[]{1, 2, 3}), p.calcNodes()); assertEquals(30, p.getDistance(), 1e-4); } }
@Test public void testExtract() { Graph g = createGraph(); g.edge(1, 2, 10, true); PathBidirRef pw = new PathBidirRef(g, new FastestWeighting(carEncoder)); EdgeExplorer explorer = g.createEdgeExplorer(carOutEdges); EdgeIterator iter = explorer.setBaseNode(1); iter.next(); pw.sptEntry = new SPTEntry(iter.getEdge(), 2, 0); pw.sptEntry.parent = new SPTEntry(EdgeIterator.NO_EDGE, 1, 10); pw.edgeTo = new SPTEntry(EdgeIterator.NO_EDGE, 2, 0); Path p = pw.extract(); assertEquals(IntArrayList.from(new int[]{1, 2}), p.calcNodes()); assertEquals(10, p.getDistance(), 1e-4); }
@Test public void testGetAllEdges() { graph = createGHStorage(); graph.edge(0, 1, 2, true); graph.edge(3, 1, 1, false); graph.edge(3, 2, 1, false); EdgeIterator iter = graph.getAllEdges(); assertTrue(iter.next()); int edgeId = iter.getEdge(); assertEquals(0, iter.getBaseNode()); assertEquals(1, iter.getAdjNode()); assertEquals(2, iter.getDistance(), 1e-6); assertTrue(iter.next()); int edgeId2 = iter.getEdge(); assertEquals(1, edgeId2 - edgeId); assertEquals(1, iter.getBaseNode()); assertEquals(3, iter.getAdjNode()); assertTrue(iter.next()); assertEquals(2, iter.getBaseNode()); assertEquals(3, iter.getAdjNode()); assertFalse(iter.next()); }
EdgeIteratorState oneIter = graph.getEdgeIteratorState(iter.getEdge(), 3); assertEquals(13, oneIter.getDistance(), 1e-6); assertEquals(2, oneIter.getBaseNode()); assertFalse(carEncoder.isBackward(oneIter.getFlags())); oneIter = graph.getEdgeIteratorState(iter.getEdge(), 2); assertEquals(13, oneIter.getDistance(), 1e-6); assertEquals(3, oneIter.getBaseNode());