@Override public boolean is3D() { return mainNodeAccess.is3D(); }
@Override public OSMReader setElevationProvider(ElevationProvider eleProvider) { if (eleProvider == null) throw new IllegalStateException("Use the NOOP elevation provider instead of null or don't call setElevationProvider"); if (!nodeAccess.is3D() && ElevationProvider.NOOP != eleProvider) throw new IllegalStateException("Make sure you graph accepts 3D data"); this.eleProvider = eleProvider; return this; }
int addTowerNode(long osmId, double lat, double lon, double ele) { if (nodeAccess.is3D()) nodeAccess.setNode(nextTowerId, lat, lon, ele); else nodeAccess.setNode(nextTowerId, lat, lon); int id = -(nextTowerId + 3); getNodeMap().put(osmId, id); nextTowerId++; return id; }
public OSMReader(GraphHopperStorage ghStorage) { this.ghStorage = ghStorage; this.graph = ghStorage; this.nodeAccess = graph.getNodeAccess(); this.encodingManager = ghStorage.getEncodingManager(); osmNodeIdToInternalNodeMap = new GHLongIntBTree(200); osmNodeIdToNodeFlagsMap = new GHLongLongHashMap(200, .5f); osmWayIdToRouteWeightMap = new GHLongLongHashMap(200, .5f); pillarInfo = new PillarInfo(nodeAccess.is3D(), ghStorage.getDirectory()); }
/** * 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 createEdges(int origTraversalKey, int origRevTraversalKey, GHPoint3D prevSnapped, int prevWayIndex, GHPoint3D currSnapped, int wayIndex, PointList fullPL, EdgeIteratorState closestEdge, int prevNodeId, int nodeId, long reverseFlags) { int max = wayIndex + 1; // basePoints must have at least the size of 2 to make sure fetchWayGeometry(3) returns at least 2 PointList basePoints = new PointList(max - prevWayIndex + 1, mainNodeAccess.is3D()); basePoints.add(prevSnapped.lat, prevSnapped.lon, prevSnapped.ele); for (int i = prevWayIndex; i < max; i++) { basePoints.add(fullPL, i); } basePoints.add(currSnapped.lat, currSnapped.lon, currSnapped.ele); PointList baseReversePoints = basePoints.clone(true); double baseDistance = basePoints.calcDistance(Helper.DIST_PLANE); int virtEdgeId = mainEdges + virtualEdges.size(); // edges between base and snapped point VirtualEdgeIteratorState baseEdge = new VirtualEdgeIteratorState(origTraversalKey, virtEdgeId, prevNodeId, nodeId, baseDistance, closestEdge.getFlags(), closestEdge.getName(), basePoints); VirtualEdgeIteratorState baseReverseEdge = new VirtualEdgeIteratorState(origRevTraversalKey, virtEdgeId, nodeId, prevNodeId, baseDistance, reverseFlags, closestEdge.getName(), baseReversePoints); baseEdge.setReverseEdge(baseReverseEdge); baseReverseEdge.setReverseEdge(baseEdge); virtualEdges.add(baseEdge); virtualEdges.add(baseReverseEdge); }
PointList pointList = new PointList(osmNodeIds.size(), nodeAccess.is3D()); List<EdgeIteratorState> newEdges = new ArrayList<>(5); int firstNode = -1;
virtualNodes = new PointList(resList.size(), mainNodeAccess.is3D()); queryResults = new ArrayList<>(resList.size()); baseGraph.virtualEdges = virtualEdges;
/** * This method calculated a list of points for this path * <p> * * @return this path its geometry */ public PointList calcPoints() { final PointList points = new PointList(edgeIds.size() + 1, nodeAccess.is3D()); if (edgeIds.isEmpty()) { if (isFound()) { points.add(graph.getNodeAccess(), endNode); } return points; } int tmpNode = getFromNode(); points.add(nodeAccess, tmpNode); forEveryEdge(new EdgeVisitor() { @Override public void next(EdgeIteratorState eb, int index, int prevEdgeId) { PointList pl = eb.fetchWayGeometry(2); for (int j = 0; j < pl.getSize(); j++) { points.add(pl, j); } } @Override public void finish() { } }); return points; }
double prevEle = pointList.is3D() ? pointList.getElevation(0) : Double.NaN; double lat, lon, ele = Double.NaN; PointList pillarNodes = new PointList(pointList.getSize() - 2, nodeAccess.is3D()); int nodes = pointList.getSize(); for (int i = 1; i < nodes; i++) {
return PointList.EMPTY; PointList pillarNodes = new PointList(count + mode, nodeAccess.is3D()); if (reverse) { if ((mode & 2) != 0) double lon = Helper.intToDegree(bitUtil.toInt(bytes, index)); index += 4; if (nodeAccess.is3D()) { pillarNodes.add(lat, lon, Helper.intToEle(bitUtil.toInt(bytes, index))); index += 4;
private byte[] createWayGeometryBytes(PointList pillarNodes, boolean reverse) { int len = pillarNodes.getSize(); int dim = nodeAccess.getDimension(); int totalLen = len * dim * 4 + 4; byte[] bytes = new byte[totalLen]; bitUtil.fromInt(bytes, len, 0); if (reverse) pillarNodes.reverse(); int tmpOffset = 4; boolean is3D = nodeAccess.is3D(); for (int i = 0; i < len; i++) { double lat = pillarNodes.getLatitude(i); bitUtil.fromInt(bytes, Helper.degreeToInt(lat), tmpOffset); tmpOffset += 4; bitUtil.fromInt(bytes, Helper.degreeToInt(pillarNodes.getLongitude(i)), tmpOffset); tmpOffset += 4; if (is3D) { bitUtil.fromInt(bytes, Helper.eleToInt(pillarNodes.getElevation(i)), tmpOffset); tmpOffset += 4; } } return bytes; }
/** * @return the specified toGraph which is now filled with data from fromGraph */ // TODO very similar to createSortedGraph -> use a 'int map(int)' interface public static Graph copyTo(Graph fromGraph, Graph toGraph) { AllEdgesIterator eIter = fromGraph.getAllEdges(); while (eIter.next()) { int base = eIter.getBaseNode(); int adj = eIter.getAdjNode(); eIter.copyPropertiesTo(toGraph.edge(base, adj)); } NodeAccess fna = fromGraph.getNodeAccess(); NodeAccess tna = toGraph.getNodeAccess(); int nodes = fromGraph.getNodes(); for (int node = 0; node < nodes; node++) { if (tna.is3D()) tna.setNode(node, fna.getLatitude(node), fna.getLongitude(node), fna.getElevation(node)); else tna.setNode(node, fna.getLatitude(node), fna.getLongitude(node)); } return toGraph; }
static Graph createSortedGraph(Graph fromGraph, Graph toSortedGraph, final IntIndexedContainer oldToNewNodeList) { AllEdgesIterator eIter = fromGraph.getAllEdges(); while (eIter.next()) { int base = eIter.getBaseNode(); int newBaseIndex = oldToNewNodeList.get(base); int adj = eIter.getAdjNode(); int newAdjIndex = oldToNewNodeList.get(adj); // ignore empty entries if (newBaseIndex < 0 || newAdjIndex < 0) continue; eIter.copyPropertiesTo(toSortedGraph.edge(newBaseIndex, newAdjIndex)); } int nodes = fromGraph.getNodes(); NodeAccess na = fromGraph.getNodeAccess(); NodeAccess sna = toSortedGraph.getNodeAccess(); for (int old = 0; old < nodes; old++) { int newIndex = oldToNewNodeList.get(old); if (sna.is3D()) sna.setNode(newIndex, na.getLatitude(old), na.getLongitude(old), na.getElevation(old)); else sna.setNode(newIndex, na.getLatitude(old), na.getLongitude(old)); } return toSortedGraph; }
N_LAT = nextNodeEntryIndex(4); N_LON = nextNodeEntryIndex(4); if (nodeAccess.is3D()) N_ELE = nextNodeEntryIndex(4); else
@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 testDontGrowOnUpdate() throws IOException { graph = createGHStorage(defaultGraphLoc, true); NodeAccess na = graph.getNodeAccess(); assertTrue(na.is3D()); na.setNode(0, 10, 10, 0); na.setNode(1, 11, 20, 1); na.setNode(2, 12, 12, 0.4); EdgeIteratorState iter2 = graph.edge(0, 1, 100, true); final BaseGraph baseGraph = (BaseGraph) graph.getBaseGraph(); assertEquals(4, baseGraph.getMaxGeoRef()); iter2.setWayGeometry(Helper.createPointList3D(1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 8, 9)); assertEquals(4 + (1 + 12), baseGraph.getMaxGeoRef()); iter2.setWayGeometry(Helper.createPointList3D(1, 2, 3, 3, 4, 5, 5, 6, 7)); assertEquals(4 + (1 + 12), baseGraph.getMaxGeoRef()); iter2.setWayGeometry(Helper.createPointList3D(1, 2, 3, 3, 4, 5)); assertEquals(4 + (1 + 12), baseGraph.getMaxGeoRef()); iter2.setWayGeometry(Helper.createPointList3D(1, 2, 3)); assertEquals(4 + (1 + 12), baseGraph.getMaxGeoRef()); iter2.setWayGeometry(Helper.createPointList3D(1.5, 1, 0, 2, 3, 0)); assertEquals(4 + (1 + 12) + (1 + 6), baseGraph.getMaxGeoRef()); EdgeIteratorState iter1 = graph.edge(0, 2, 200, true); iter1.setWayGeometry(Helper.createPointList3D(3.5, 4.5, 0, 5, 6, 0)); assertEquals(4 + (1 + 12) + (1 + 6) + (1 + 6), baseGraph.getMaxGeoRef()); }
@Test public void testSave_and_fileFormat() throws IOException { graph = newGHStorage(new RAMDirectory(defaultGraphLoc, true), true).create(defaultSize); NodeAccess na = graph.getNodeAccess(); assertTrue(na.is3D()); na.setNode(0, 10, 10, 0); na.setNode(1, 11, 20, 1); na.setNode(2, 12, 12, 0.4); EdgeIteratorState iter2 = graph.edge(0, 1, 100, true); iter2.setWayGeometry(Helper.createPointList3D(1.5, 1, 0, 2, 3, 0)); EdgeIteratorState iter1 = graph.edge(0, 2, 200, true); iter1.setWayGeometry(Helper.createPointList3D(3.5, 4.5, 0, 5, 6, 0)); graph.edge(9, 10, 200, true); graph.edge(9, 11, 200, true); graph.edge(1, 2, 120, false); iter1.setName("named street1"); iter2.setName("named street2"); checkGraph(graph); graph.flush(); graph.close(); graph = newGHStorage(new MMapDirectory(defaultGraphLoc), true); assertTrue(graph.loadExisting()); assertEquals(12, graph.getNodes()); checkGraph(graph); assertEquals("named street1", graph.getEdgeIteratorState(iter1.getEdge(), iter1.getAdjNode()).getName()); assertEquals("named street2", graph.getEdgeIteratorState(iter2.getEdge(), iter2.getAdjNode()).getName()); graph.edge(3, 4, 123, true).setWayGeometry(Helper.createPointList3D(4.4, 5.5, 0, 6.6, 7.7, 0)); checkGraph(graph); }
protected void checkGraph(Graph g) { NodeAccess na = g.getNodeAccess(); assertTrue(na.is3D()); assertTrue(g.getBounds().isValid());
graph = newGHStorage(new RAMDirectory(defaultGraphLoc, true), true).create(defaultSize); NodeAccess na = graph.getNodeAccess(); assertTrue(na.is3D()); na.setNode(0, 10, 10, 0); na.setNode(1, 11, 20, 1);