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; }
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)); } }
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; }
while (iter.next()) { if (!accept(iter, currEdge.edge)) continue; nEdge = new SPTEntry(iter.getEdge(), iter.getAdjNode(), tmpWeight); nEdge.parent = currEdge; fromMap.put(traversalId, nEdge); } else if (nEdge.weight > tmpWeight) { fromHeap.remove(nEdge); nEdge.edge = iter.getEdge(); nEdge.weight = tmpWeight; nEdge.parent = currEdge;
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; }
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 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; }
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); } } } }
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; }
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; } }
/** * This method checks if the node is removed or inaccessible for ALL encoders. * <p> * * @return true if no edges are reachable from the specified nodeIndex for any flag encoder. */ boolean detectNodeRemovedForAllEncoders(EdgeExplorer edgeExplorerAllEdges, int nodeIndex) { // we could implement a 'fast check' for several previously marked removed nodes via GHBitSet // removedNodesPerVehicle. The problem is that we would need long-indices but BitSet only supports int (due to nodeIndex*numberOfEncoders) // if no edges are reachable return true EdgeIterator iter = edgeExplorerAllEdges.setBaseNode(nodeIndex); while (iter.next()) { // if at least on encoder allows one direction return false for (FlagEncoder encoder : encoders) { if (encoder.isBackward(iter.getFlags()) || encoder.isForward(iter.getFlags())) return false; } } return true; }
iter.detach(false); assertTrue(false); } catch (Exception ex) { iter.next(); 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())); EdgeIteratorState edgeState20 = iter.detach(true); assertEquals(0, edgeState20.getAdjNode()); assertEquals(2, edgeState20.getBaseNode()); iter.next(); assertEquals(1, iter.getAdjNode()); assertEquals(2, edgeState02.getAdjNode()); assertEquals(2, edgeState20.getBaseNode()); assertEquals(0, iter.fetchWayGeometry(0).size()); assertEquals(1, edgeState02.fetchWayGeometry(0).getLatitude(0), 1e-1); assertEquals(3, edgeState20.fetchWayGeometry(0).getLatitude(0), 1e-1); edgeState33.next(); assertEquals(3, edgeState33.getBaseNode()); assertEquals(3, edgeState33.getAdjNode()); assertEquals(edgeState02.getFlags(), edgeState33.detach(false).getFlags()); assertEquals(edgeState20.getFlags(), edgeState33.detach(true).getFlags());
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); } } } }
assertTrue(iter.next()); assertEquals(14, iter.getAdjNode()); assertPList(Helper.createPointList(1, 11, 1, 12, 1, 13.0), iter.fetchWayGeometry(0)); assertPList(Helper.createPointList(0.01, 0.01, 1, 11, 1, 12, 1, 13.0), iter.fetchWayGeometry(1)); assertPList(Helper.createPointList(1, 11, 1, 12, 1, 13.0, 0.14, 0.14), iter.fetchWayGeometry(2)); assertPList(Helper.createPointList(0.01, 0.01, 1, 11, 1, 12, 1, 13.0, 0.14, 0.14), iter.fetchWayGeometry(3)); assertTrue(iter.next()); assertEquals(4, iter.getAdjNode()); assertPList(Helper.createPointList(1, 1, 1, 2, 1, 3), iter.fetchWayGeometry(0)); assertPList(Helper.createPointList(0.01, 0.01, 1, 1, 1, 2, 1, 3), iter.fetchWayGeometry(1)); assertPList(Helper.createPointList(1, 1, 1, 2, 1, 3, 0.4, 0.4), iter.fetchWayGeometry(2)); assertPList(Helper.createPointList(0.01, 0.01, 1, 1, 1, 2, 1, 3, 0.4, 0.4), iter.fetchWayGeometry(3)); assertFalse(iter.next()); assertTrue(iter.next()); assertEquals(4, iter.getAdjNode()); assertPList(Helper.createPointList(1, 1, 1, 2, 1, 3), iter.fetchWayGeometry(0)); assertFalse(iter.next()); assertTrue(iter.next()); assertEquals(4, iter.getAdjNode()); assertPList(Helper.createPointList(1, 9, 1, 8, 1, 7, 1, 6, 1, 5), iter.fetchWayGeometry(0)); assertPList(Helper.createPointList(0.99, 0.99, 1, 9, 1, 8, 1, 7, 1, 6, 1, 5), iter.fetchWayGeometry(1)); assertPList(Helper.createPointList(1, 9, 1, 8, 1, 7, 1, 6, 1, 5, 0.4, 0.4), iter.fetchWayGeometry(2)); assertPList(Helper.createPointList(0.99, 0.99, 1, 9, 1, 8, 1, 7, 1, 6, 1, 5, 0.4, 0.4), iter.fetchWayGeometry(3)); assertFalse(iter.next());
/** * Counts reachable edges. */ public static int count(EdgeIterator iter) { int counter = 0; while (iter.next()) { counter++; } return counter; }
@Override public void foundShortcut( int u_fromNode, int w_toNode, double existingDirectWeight, double distance, EdgeIterator outgoingEdges, int skippedEdge1, int incomingEdgeOrigCount ) { shortcuts++; originalEdgesCount += incomingEdgeOrigCount + getOrigEdgeCount(outgoingEdges.getEdge()); } }
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()); } }
assertEquals(9, lg.getNodes()); EdgeIterator iter = lg.createEdgeExplorer().setBaseNode(8); iter.next(); assertEquals(2.05, iter.getDistance(), 1e-6); assertTrue(iter.isBackward(carEncoder)); assertTrue(iter.isForward(carEncoder)); iter.next(); assertEquals(0.5, iter.getDistance(), 1e-6); assertTrue(iter.isBackward(carEncoder)); assertTrue(iter.isForward(carEncoder)); iter.next(); assertEquals(.7, iter.getDistance(), 1e-6); iter.next(); assertEquals(2.1, iter.getDistance(), 1e-6); assertFalse(iter.isBackward(carEncoder)); assertTrue(iter.isForward(carEncoder)); assertFalse(iter.next());