/** * Counts reachable edges. */ public static int count(EdgeIterator iter) { int counter = 0; while (iter.next()) { counter++; } return counter; }
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 static List<Integer> getEdgeIds(EdgeIterator iter) { List<Integer> list = new ArrayList<>(); while (iter.next()) { list.add(iter.getEdge()); } return list; }
/** * @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 boolean entryIsStallable(SPTEntry entry, IntObjectMap<SPTEntry> bestWeightMap, EdgeExplorer edgeExplorer, boolean reverse) { // We check for all 'incoming' edges if we can prove that the current node (that is about to be settled) is // reached via a suboptimal path. We do this regardless of the CH level of the adjacent nodes. EdgeIterator iter = edgeExplorer.setBaseNode(entry.adjNode); while (iter.next()) { int traversalId = traversalMode.createTraversalId(iter, reverse); SPTEntry adjNode = bestWeightMap.get(traversalId); if (adjNode != null && adjNode.weight + weighting.calcWeight(iter, !reverse, entry.edge) < entry.weight) { return true; } } return false; } }
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; }
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; }
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)); } }
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 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()); }
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; } }
public static void updateDistancesFor(Graph g, int node, double lat, double lon) { NodeAccess na = g.getNodeAccess(); na.setNode(node, lat, lon); EdgeIterator iter = g.createEdgeExplorer().setBaseNode(node); while (iter.next()) { iter.setDistance(iter.fetchWayGeometry(3).calcDistance(distCalc)); // System.out.println(node + "->" + adj + ": " + iter.getDistance()); } }
@Test public void useEECache() { initGraph(g); EdgeExplorer explorer = g.createEdgeExplorer(); EdgeIterator iter = explorer.setBaseNode(1); assertTrue(iter.next()); QueryResult res = createLocationResult(2, 1.5, iter, 1, PILLAR); QueryGraph queryGraph = new QueryGraph(g).setUseEdgeExplorerCache(true); queryGraph.lookup(Arrays.asList(res)); EdgeExplorer edgeExplorer = queryGraph.createEdgeExplorer(); // using cache means same reference assertTrue(edgeExplorer == queryGraph.createEdgeExplorer()); } }
@Test public void testVirtEdges() { initGraph(g); EdgeIterator iter = g.createEdgeExplorer().setBaseNode(0); iter.next(); VirtualEdgeIterator vi = new VirtualEdgeIterator(2); vi.add(iter.detach(false)); assertTrue(vi.next()); }
@Test public void testFlags() { graph = createGHStorage(); graph.edge(0, 1).setDistance(10).setFlags(carEncoder.setProperties(100, true, true)); graph.edge(2, 3).setDistance(10).setFlags(carEncoder.setProperties(10, true, false)); EdgeIterator iter = carAllExplorer.setBaseNode(0); assertTrue(iter.next()); assertEquals(carEncoder.setProperties(100, true, true), iter.getFlags()); iter = carAllExplorer.setBaseNode(2); assertTrue(iter.next()); assertEquals(carEncoder.setProperties(10, true, false), iter.getFlags()); try { graph.edge(0, 1).setDistance(-1); assertTrue(false); } catch (IllegalArgumentException ex) { } }
@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); }