public static Set<Integer> getNeighbors(EdgeIterator iter) { // make iteration order over set static => linked Set<Integer> list = new LinkedHashSet<>(); while (iter.next()) { list.add(iter.getAdjNode()); } return list; }
public InstructionsOutgoingEdges(EdgeIteratorState prevEdge, EdgeIteratorState currentEdge, FlagEncoder encoder, EdgeExplorer crossingExplorer, NodeAccess nodeAccess, int prevNode, int baseNode, int adjNode) { this.prevEdge = prevEdge; this.currentEdge = currentEdge; this.encoder = encoder; this.nodeAccess = nodeAccess; EdgeIteratorState tmpEdge; allOutgoingEdges = new ArrayList<>(); allowedOutgoingEdges = new ArrayList<>(); EdgeIterator edgeIter = crossingExplorer.setBaseNode(baseNode); while (edgeIter.next()) { if (edgeIter.getAdjNode() != prevNode && edgeIter.getAdjNode() != adjNode) { tmpEdge = edgeIter.detach(false); allOutgoingEdges.add(tmpEdge); if (encoder.isForward(tmpEdge.getFlags())) { allowedOutgoingEdges.add(tmpEdge); } } } }
/** * @return the <b>first</b> edge containing the specified nodes base and adj. Returns null if * not found. */ public static EdgeIteratorState getEdge(Graph graph, int base, int adj) { EdgeIterator iter = graph.createEdgeExplorer().setBaseNode(base); while (iter.next()) { if (iter.getAdjNode() == adj) return iter; } return null; }
private NavigableMap<Integer, Integer> findDepartureTimelineForPlatform(int platformEnterNode) { TreeMap<Integer, Integer> result = new TreeMap<>(); if (platformEnterNode == -1) { return result; } EdgeIterator edge = graph.getBaseGraph().createEdgeExplorer(DefaultEdgeFilter.outEdges(encoder)).setBaseNode(platformEnterNode); while (edge.next()) { if (encoder.getEdgeType(edge.getFlags()) == GtfsStorage.EdgeType.ENTER_TIME_EXPANDED_NETWORK) { result.put((int) encoder.getTime(edge.getFlags()), edge.getAdjNode()); } } return result; }
public boolean containsLatitude(Graph g, EdgeIterator iter, double latitude) { NodeAccess na = g.getNodeAccess(); while (iter.next()) { if (Math.abs(na.getLatitude(iter.getAdjNode()) - latitude) < 1e-4) return true; } return false; }
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; }
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 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); } }
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; }
String toString(FlagEncoder encoder, EdgeIterator iter) { String str = ""; while (iter.next()) { int adjNode = iter.getAdjNode(); str += adjNode + " (" + ghStorage.getNodeAccess().getLat(adjNode) + "," + ghStorage.getNodeAccess().getLon(adjNode) + "), "; str += "speed (fwd:" + encoder.getSpeed(iter.getFlags()) + ", rev:" + encoder.getReverseSpeed(iter.getFlags()) + "), "; str += "access (fwd:" + encoder.isForward(iter.getFlags()) + ", rev:" + encoder.isBackward(iter.getFlags()) + "), "; str += "distance:" + iter.getDistance(); str += ";\n "; } return str; }
private boolean isGraphValid(Graph graph, FlagEncoder encoder) { EdgeExplorer explorer = graph.createEdgeExplorer(); // iterator at node 0 considers the edge 0-1 to be undirected EdgeIterator iter0 = explorer.setBaseNode(0); iter0.next(); boolean iter0flag = iter0.getBaseNode() == 0 && iter0.getAdjNode() == 1 && iter0.isForward(encoder) && iter0.isBackward(encoder); // iterator at node 1 considers the edge 1-0 to be directed EdgeIterator iter1 = explorer.setBaseNode(1); iter1.next(); boolean iter1flag = iter1.getBaseNode() == 1 && iter1.getAdjNode() == 0 && iter1.isForward(encoder) && iter1.isBackward(encoder); return iter0flag && iter1flag; } }
/** * beginning with startNode add all following nodes to LIFO queue. If node has been already * explored before, skip reexploration. */ @Override public void start(EdgeExplorer explorer, int startNode) { IntArrayDeque stack = new IntArrayDeque(); GHBitSet explored = createBitSet(); stack.addLast(startNode); int current; while (stack.size() > 0) { current = stack.removeLast(); if (!explored.contains(current) && goFurther(current)) { EdgeIterator iter = explorer.setBaseNode(current); while (iter.next()) { int connectedId = iter.getAdjNode(); if (checkAdjacent(iter)) { stack.addLast(connectedId); } } explored.add(current); } } }
@Override public void start(EdgeExplorer explorer, int startNode) { SimpleIntDeque fifo = new SimpleIntDeque(); GHBitSet visited = createBitSet(); visited.add(startNode); fifo.push(startNode); int current; while (!fifo.isEmpty()) { current = fifo.pop(); if (!goFurther(current)) continue; EdgeIterator iter = explorer.setBaseNode(current); while (iter.next()) { int connectedId = iter.getAdjNode(); if (checkAdjacent(iter) && !visited.contains(connectedId)) { visited.add(connectedId); fifo.push(connectedId); } } } } }
@Test public void testUpdateUnidirectional() { graph = createGHStorage(); graph.edge(1, 2, 12, false); graph.edge(3, 2, 112, false); EdgeIterator i = carOutExplorer.setBaseNode(2); assertFalse(i.next()); i = carOutExplorer.setBaseNode(3); assertTrue(i.next()); assertEquals(2, i.getAdjNode()); assertFalse(i.next()); graph.edge(2, 3, 112, false); i = carOutExplorer.setBaseNode(2); assertTrue(i.next()); assertEquals(3, i.getAdjNode()); i = carOutExplorer.setBaseNode(3); i.next(); assertEquals(2, i.getAdjNode()); assertFalse(i.next()); }
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()); }
private void interpolateElevationsOfPillarNodes() { final EdgeIterator edge = storage.getAllEdges(); final NodeAccess nodeAccess = storage.getNodeAccess(); while (edge.next()) { if (isInterpolatableEdge(edge)) { int firstNodeId = edge.getBaseNode(); int secondNodeId = edge.getAdjNode(); double lat0 = nodeAccess.getLat(firstNodeId); double lon0 = nodeAccess.getLon(firstNodeId); double ele0 = nodeAccess.getEle(firstNodeId); double lat1 = nodeAccess.getLat(secondNodeId); double lon1 = nodeAccess.getLon(secondNodeId); double ele1 = nodeAccess.getEle(secondNodeId); final PointList pointList = edge.fetchWayGeometry(0); final int count = pointList.size(); for (int index = 0; index < count; index++) { double lat = pointList.getLat(index); double lon = pointList.getLon(index); double ele = elevationInterpolator.calculateElevationBasedOnTwoPoints(lat, lon, lat0, lon0, ele0, lat1, lon1, ele1); pointList.set(index, lat, lon, ele); } edge.setWayGeometry(pointList); } } } }
@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()); }
@Test public void testUnidirectionalEdgeFilter() { graph = createGHStorage(); graph.edge(1, 2, 12, false); graph.edge(1, 11, 12, false); graph.edge(11, 1, 12, false); graph.edge(1, 12, 12, false); graph.edge(3, 2, 112, false); EdgeIterator i = carOutExplorer.setBaseNode(2); assertFalse(i.next()); assertEquals(4, GHUtility.count(carAllExplorer.setBaseNode(1))); assertEquals(1, GHUtility.count(carInExplorer.setBaseNode(1))); assertEquals(2, GHUtility.count(carInExplorer.setBaseNode(2))); assertEquals(0, GHUtility.count(carInExplorer.setBaseNode(3))); assertEquals(3, GHUtility.count(carOutExplorer.setBaseNode(1))); assertEquals(0, GHUtility.count(carOutExplorer.setBaseNode(2))); assertEquals(1, GHUtility.count(carOutExplorer.setBaseNode(3))); i = carOutExplorer.setBaseNode(3); i.next(); assertEquals(2, i.getAdjNode()); i = carOutExplorer.setBaseNode(1); assertTrue(i.next()); assertEquals(12, i.getAdjNode()); assertTrue(i.next()); assertEquals(11, i.getAdjNode()); assertTrue(i.next()); assertEquals(2, i.getAdjNode()); assertFalse(i.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()); }