@Override public int doCalc(boolean warmup, int run) { int nodeId = rand.nextInt(maxNode); return GHUtility.count(outExplorer.setBaseNode(nodeId)); } }.setIterations(count).start();
@Override public int doCalc(boolean warmup, int run) { int nodeId = rand.nextInt(maxNode); return GHUtility.count(allExplorer.setBaseNode(nodeId)); } }.setIterations(count).start();
@Override public EdgeIterator setBaseNode(int baseNode) { VirtualEdgeIterator iter = node2EdgeMap.get(baseNode); if (iter != null) return iter.reset(); return mainExplorer.setBaseNode(baseNode); } };
/** * @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; }
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; }
/** * 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; }
@Test public void testEdges() { graph = createGHStorage(); graph.edge(2, 1, 12, true); assertEquals(1, count(carOutExplorer.setBaseNode(2))); graph.edge(2, 3, 12, true); assertEquals(1, count(carOutExplorer.setBaseNode(1))); assertEquals(2, count(carOutExplorer.setBaseNode(2))); assertEquals(1, count(carOutExplorer.setBaseNode(3))); }
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)); } } } } } } }
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; }
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; }
@Test public void testCheckFirstNode() { graph = createGHStorage(); assertEquals(0, count(carAllExplorer.setBaseNode(1))); graph.edge(0, 1, 12, true); assertEquals(1, count(carAllExplorer.setBaseNode(1))); }
@Test public void testCreateLocation() { graph = createGHStorage(); graph.edge(3, 1, 50, true); assertEquals(1, count(carOutExplorer.setBaseNode(1))); graph.edge(1, 2, 100, true); assertEquals(2, count(carOutExplorer.setBaseNode(1))); }
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)); } }
@Test public void testDozendEdges() { graph = createGHStorage(); graph.edge(1, 2, 12, true); assertEquals(1, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 3, 13, false); assertEquals(2, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 4, 14, false); assertEquals(3, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 5, 15, false); assertEquals(4, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 6, 16, false); assertEquals(5, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 7, 16, false); assertEquals(6, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 8, 16, false); assertEquals(7, count(carAllExplorer.setBaseNode(1))); graph.edge(1, 9, 16, false); assertEquals(8, count(carAllExplorer.setBaseNode(1))); assertEquals(8, count(carOutExplorer.setBaseNode(1))); assertEquals(1, count(carInExplorer.setBaseNode(1))); assertEquals(1, count(carInExplorer.setBaseNode(2))); }
@Test public void testMediumRead() throws IOException { Graph graph = new GraphBuilder(encodingManager).create(); new PrincetonReader(graph).setStream(new GZIPInputStream(PrincetonReader.class.getResourceAsStream("mediumEWD.txt.gz"))).read(); assertEquals(250, graph.getNodes()); EdgeExplorer explorer = graph.createEdgeExplorer(carOutEdges); assertEquals(13, count(explorer.setBaseNode(244))); assertEquals(11, count(explorer.setBaseNode(16))); } }
@Test public void testIdenticalNodes() { graph = createGHStorage(); graph.edge(0, 0, 100, true); assertEquals(1, GHUtility.count(carAllExplorer.setBaseNode(0))); }
@Test public void testRead() { Graph graph = new GraphBuilder(encodingManager).create(); new PrincetonReader(graph).setStream(PrincetonReader.class.getResourceAsStream("tinyEWD.txt")).read(); assertEquals(8, graph.getNodes()); EdgeExplorer explorer = graph.createEdgeExplorer(carOutEdges); assertEquals(2, count(explorer.setBaseNode(0))); assertEquals(3, count(explorer.setBaseNode(6))); }
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; }