@Override public NodeAccess getNodeAccess() { return baseGraph.getNodeAccess(); }
/** * @return the calculated landmarks as GeoJSON string. */ String getLandmarksAsGeoJSON() { NodeAccess na = graph.getNodeAccess(); String str = ""; for (int subnetwork = 1; subnetwork < landmarkIDs.size(); subnetwork++) { int[] lmArray = landmarkIDs.get(subnetwork); for (int lmIdx = 0; lmIdx < lmArray.length; lmIdx++) { int index = lmArray[lmIdx]; if (!str.isEmpty()) str += ","; str += "{ \"type\": \"Feature\", \"geometry\": {\"type\": \"Point\", \"coordinates\": [" + na.getLon(index) + ", " + na.getLat(index) + "]},"; str += " \"properties\":{\"node_index\":" + index + "," + "\"subnetwork\":" + subnetwork + "," + "\"lm_index\":" + lmIdx + "}" + "}"; } } return "{ \"type\": \"FeatureCollection\", \"features\": [" + str + "]}"; }
private static void warmUpCHSubNetwork(GraphHopper graphHopper, int iterations) { GraphHopperStorage ghStorage = graphHopper.getGraphHopperStorage(); Random rand = new Random(0); for (int i = 0; i < iterations; i++) { int startNode = rand.nextInt(graphHopper.getMaxVisitedNodes() + 1); int endNode = rand.nextInt(graphHopper.getMaxVisitedNodes() + 1); double fromLatitude = ghStorage.getNodeAccess().getLatitude(startNode); double fromLongitude = ghStorage.getNodeAccess().getLongitude(startNode); double toLatitude = ghStorage.getNodeAccess().getLatitude(endNode); double toLongitude = ghStorage.getNodeAccess().getLongitude(endNode); GHRequest request = new GHRequest(fromLatitude, fromLongitude, toLatitude, toLongitude); graphHopper.route(request); } }
private void interpolateElevationsOfInnerNodesForOneOuterNode(int outerNodeId, int[] innerNodeIds) { NodeAccess nodeAccess = storage.getNodeAccess(); double ele = nodeAccess.getEle(outerNodeId); for (int innerNodeId : innerNodeIds) { double lat = nodeAccess.getLat(innerNodeId); double lon = nodeAccess.getLon(innerNodeId); nodeAccess.setNode(innerNodeId, lat, lon, ele); } }
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; }
/** * Create a new storage from the specified one without copying the data. */ public static GraphHopperStorage newStorage(GraphHopperStorage store) { Directory outdir = guessDirectory(store); boolean is3D = store.getNodeAccess().is3D(); return new GraphHopperStorage(store.getCHWeightings(), outdir, store.getEncodingManager(), is3D, store.getExtension()). create(store.getNodes()); }
private void interpolateElevationsOfInnerNodesForNOuterNodes(int[] outerNodeIds, int[] innerNodeIds) { NodeAccess nodeAccess = storage.getNodeAccess(); PointList pointList = new PointList(outerNodeIds.length, true); for (int outerNodeId : outerNodeIds) { pointList.add(nodeAccess.getLat(outerNodeId), nodeAccess.getLon(outerNodeId), nodeAccess.getEle(outerNodeId)); } for (int innerNodeId : innerNodeIds) { double lat = nodeAccess.getLat(innerNodeId); double lon = nodeAccess.getLon(innerNodeId); double ele = elevationInterpolator.calculateElevationBasedOnPointList(lat, lon, pointList); nodeAccess.setNode(innerNodeId, lat, lon, ele); } } }
private void interpolateElevationsOfInnerNodesForTwoOuterNodes(int firstOuterNodeId, int secondOuterNodeId, int[] innerNodeIds) { final NodeAccess nodeAccess = storage.getNodeAccess(); double lat0 = nodeAccess.getLat(firstOuterNodeId); double lon0 = nodeAccess.getLon(firstOuterNodeId); double ele0 = nodeAccess.getEle(firstOuterNodeId); double lat1 = nodeAccess.getLat(secondOuterNodeId); double lon1 = nodeAccess.getLon(secondOuterNodeId); double ele1 = nodeAccess.getEle(secondOuterNodeId); for (int innerNodeId : innerNodeIds) { double lat = nodeAccess.getLat(innerNodeId); double lon = nodeAccess.getLon(innerNodeId); double ele = elevationInterpolator.calculateElevationBasedOnTwoPoints(lat, lon, lat0, lon0, ele0, lat1, lon1, ele1); nodeAccess.setNode(innerNodeId, lat, lon, ele); } }
void initGraph(GraphHopperStorage graph) { NodeAccess na = graph.getNodeAccess(); na.setNode(0, 42, 10); na.setNode(1, 42.1, 10.1); na.setNode(2, 42.1, 10.2); na.setNode(3, 42, 10.4); graph.edge(0, 1, 10, true); graph.edge(2, 3, 10, true); }
/** * This method makes edges crossing the specified border inaccessible to split a bigger area into smaller subnetworks. * This is important for the world wide use case to limit the maximum distance and also to detect unreasonable routes faster. */ protected IntHashSet findBorderEdgeIds(SpatialRuleLookup ruleLookup) { AllEdgesIterator allEdgesIterator = graph.getAllEdges(); NodeAccess nodeAccess = graph.getNodeAccess(); IntHashSet inaccessible = new IntHashSet(); while (allEdgesIterator.next()) { int adjNode = allEdgesIterator.getAdjNode(); SpatialRule ruleAdj = ruleLookup.lookupRule(nodeAccess.getLatitude(adjNode), nodeAccess.getLongitude(adjNode)); int baseNode = allEdgesIterator.getBaseNode(); SpatialRule ruleBase = ruleLookup.lookupRule(nodeAccess.getLatitude(baseNode), nodeAccess.getLongitude(baseNode)); if (ruleAdj != ruleBase) { inaccessible.add(allEdgesIterator.getEdge()); } } return inaccessible; }
private void interpolateElevationsOfInnerNodesForThreeOuterNodes(int firstOuterNodeId, int secondOuterNodeId, int thirdOuterNodeId, int[] innerNodeIds) { NodeAccess nodeAccess = storage.getNodeAccess(); double lat0 = nodeAccess.getLat(firstOuterNodeId); double lon0 = nodeAccess.getLon(firstOuterNodeId); double ele0 = nodeAccess.getEle(firstOuterNodeId); double lat1 = nodeAccess.getLat(secondOuterNodeId); double lon1 = nodeAccess.getLon(secondOuterNodeId); double ele1 = nodeAccess.getEle(secondOuterNodeId); double lat2 = nodeAccess.getLat(thirdOuterNodeId); double lon2 = nodeAccess.getLon(thirdOuterNodeId); double ele2 = nodeAccess.getEle(thirdOuterNodeId); for (int innerNodeId : innerNodeIds) { double lat = nodeAccess.getLat(innerNodeId); double lon = nodeAccess.getLon(innerNodeId); double ele = elevationInterpolator.calculateElevationBasedOnThreePoints(lat, lon, lat0, lon0, ele0, lat1, lon1, ele1, lat2, lon2, ele2); nodeAccess.setNode(innerNodeId, lat, lon, ele); } }
@Test public void testSetNodes() { graph = createGHStorage(); NodeAccess na = graph.getNodeAccess(); for (int i = 0; i < defaultSize * 2; i++) { na.setNode(i, 2 * i, 3 * i); } graph.edge(defaultSize + 1, defaultSize + 2, 10, true); graph.edge(defaultSize + 1, defaultSize + 3, 10, true); assertEquals(2, GHUtility.count(carAllExplorer.setBaseNode(defaultSize + 1))); }
@Test public void testDeleteAndOptimize() { graph = createGHStorage(); NodeAccess na = graph.getNodeAccess(); na.setNode(20, 10, 10); na.setNode(21, 10, 11); graph.markNodeRemoved(20); graph.optimize(); assertEquals(11, na.getLongitude(20), 1e-5); }
@Test public void testBounds() { graph = createGHStorage(); BBox b = graph.getBounds(); assertEquals(BBox.createInverse(false).maxLat, b.maxLat, 1e-6); NodeAccess na = graph.getNodeAccess(); na.setNode(0, 10, 20); assertEquals(10, b.maxLat, 1e-6); assertEquals(20, b.maxLon, 1e-6); na.setNode(0, 15, -15); assertEquals(15, b.maxLat, 1e-6); assertEquals(20, b.maxLon, 1e-6); assertEquals(10, b.minLat, 1e-6); assertEquals(-15, b.minLon, 1e-6); }
private Graph initExampleGraph() { GraphHopperStorage gs = new GraphHopperStorage(new RAMDirectory(), em, true, new GraphExtension.NoOpExtension()).create(1000); NodeAccess na = gs.getNodeAccess(); // 50--(0.0001)-->49--(0.0004)-->55--(0.0005)-->60 na.setNode(0, 51.1, 12.001, 50); na.setNode(1, 51.1, 12.002, 60); EdgeIteratorState edge = gs.edge(0, 1). setWayGeometry(Helper.createPointList3D(51.1, 12.0011, 49, 51.1, 12.0015, 55)); edge.setDistance(100); edge.setFlags(encoder.setReverseSpeed(encoder.setProperties(10, true, true), 15)); return gs; }
private Graph initExampleGraph() { GraphHopperStorage gs = new GraphHopperStorage(new RAMDirectory(), em, true, new GraphExtension.NoOpExtension()).create(1000); NodeAccess na = gs.getNodeAccess(); // 50--(0.0001)-->49--(0.0004)-->55--(0.0005)-->60 na.setNode(0, 51.1, 12.001, 50); na.setNode(1, 51.1, 12.002, 60); EdgeIteratorState edge = gs.edge(0, 1). setWayGeometry(Helper.createPointList3D(51.1, 12.0011, 49, 51.1, 12.0015, 55)); edge.setDistance(100); edge.setFlags(encoder.setReverseSpeed(encoder.setProperties(10, true, true), 15)); return gs; }
@Test public void testGetLocations() { graph = createGHStorage(); NodeAccess na = graph.getNodeAccess(); na.setNode(0, 12, 23); na.setNode(1, 22, 23); assertEquals(2, graph.getNodes()); graph.edge(0, 1, 10, true); assertEquals(2, graph.getNodes()); graph.edge(0, 2, 10, true); assertEquals(3, graph.getNodes()); Helper.close((Closeable) graph); graph = createGHStorage(); assertEquals(0, graph.getNodes()); }
@Test public void testEnabledElevation() { graph = createGHStorage(defaultGraphLoc, true); NodeAccess na = graph.getNodeAccess(); assertTrue(na.is3D()); na.setNode(0, 10, 20, -10); na.setNode(1, 11, 2, 100); assertEquals(-10, na.getEle(0), 1e-1); assertEquals(100, na.getEle(1), 1e-1); graph.edge(0, 1).setWayGeometry(Helper.createPointList3D(10, 27, 72, 11, 20, 1)); assertEquals(Helper.createPointList3D(10, 27, 72, 11, 20, 1), GHUtility.getEdge(graph, 0, 1).fetchWayGeometry(0)); assertEquals(Helper.createPointList3D(10, 20, -10, 10, 27, 72, 11, 20, 1, 11, 2, 100), GHUtility.getEdge(graph, 0, 1).fetchWayGeometry(3)); assertEquals(Helper.createPointList3D(11, 2, 100, 11, 20, 1, 10, 27, 72, 10, 20, -10), GHUtility.getEdge(graph, 1, 0).fetchWayGeometry(3)); }
@Test public void testOneWay() { NodeAccess na = g.getNodeAccess(); na.setNode(0, 0, 0); na.setNode(1, 0, 1); g.edge(0, 1, 10, false); EdgeIteratorState edge = GHUtility.getEdge(g, 0, 1); QueryResult res1 = createLocationResult(0.1, 0.1, edge, 0, EDGE); QueryResult res2 = createLocationResult(0.1, 0.9, edge, 0, EDGE); QueryGraph queryGraph = new QueryGraph(g); queryGraph.lookup(Arrays.asList(res2, res1)); assertEquals(2, res1.getClosestNode()); assertEquals(new GHPoint(0, 0.1), res1.getSnappedPoint()); assertEquals(3, res2.getClosestNode()); assertEquals(new GHPoint(0, 0.9), res2.getSnappedPoint()); assertEquals(2, getPoints(queryGraph, 0, 2).getSize()); assertEquals(2, getPoints(queryGraph, 2, 3).getSize()); assertEquals(2, getPoints(queryGraph, 3, 1).getSize()); assertNull(GHUtility.getEdge(queryGraph, 3, 0)); assertNull(GHUtility.getEdge(queryGraph, 2, 1)); }
@Test public void testClone() { graph = createGHStorage(); graph.edge(1, 2, 10, true); NodeAccess na = graph.getNodeAccess(); na.setNode(0, 12, 23); na.setNode(1, 8, 13); na.setNode(2, 2, 10); na.setNode(3, 5, 9); graph.edge(1, 3, 10, true); Graph cloneGraph = graph.copyTo(AbstractGraphStorageTester.this.createGHStorage(locationParent + "/clone", false)); assertEquals(graph.getNodes(), cloneGraph.getNodes()); assertEquals(count(carOutExplorer.setBaseNode(1)), count(cloneGraph.createEdgeExplorer(carOutFilter).setBaseNode(1))); cloneGraph.edge(1, 4, 10, true); assertEquals(3, count(cloneGraph.createEdgeExplorer(carOutFilter).setBaseNode(1))); assertEquals(graph.getBounds(), cloneGraph.getBounds()); Helper.close((Closeable) cloneGraph); }