@Override public void setTo(int toNode) { toLat = nodeAccess.getLatitude(toNode); toLon = nodeAccess.getLongitude(toNode); }
/** * @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; }
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); } }
@Override public void updateBestPath(EdgeIteratorState es, SPTEntry entry, int traversalId, boolean reverse) { if (g2 != null) { mg.plotEdge(g2, na.getLat(entry.parent.adjNode), na.getLon(entry.parent.adjNode), na.getLat(entry.adjNode), na.getLon(entry.adjNode), .8f); } // System.out.println("new node:" + currLoc); super.updateBestPath(es, entry, traversalId, reverse); } }
@Override public void setTo(int toNode) { toLat = nodeAccess.getLatitude(toNode); toLon = nodeAccess.getLongitude(toNode); if (this.weighting.needsElevation()) { toElevation = nodeAccess.getElevation(toNode); } }
na.setNode(0, 0, 0, 0); na.setNode(1, 10, 0, 0); na.setNode(2, 20, 0, 10); na.setNode(3, 30, 0, 20); na.setNode(4, 40, 0, 0); assertEquals(0, na.getElevation(0), PRECISION); assertEquals(0, na.getElevation(1), PRECISION); assertEquals(10, na.getElevation(2), PRECISION); assertEquals(20, na.getElevation(3), PRECISION); assertEquals(0, na.getElevation(4), PRECISION);
gtfsStorage.getOperatingDayPatterns().put(blockTransferValidOn, blockTransferValidityId); nodeAccess.setNode(i++, stop.stop_lat, stop.stop_lon); nodeAccess.setAdditionalNodeField(i-1, NodeType.INTERNAL_PT.ordinal()); EdgeIteratorState transferEdge = graph.edge(lastTrip.arrivalNode,i-1); transferEdge.setFlags(encoder.setAccess(transferEdge.getFlags(), true, false));
protected void checkGraph(Graph g) { NodeAccess na = g.getNodeAccess(); assertTrue(na.is3D()); assertTrue(g.getBounds().isValid()); assertEquals(10, na.getLatitude(0), 1e-2); assertEquals(10, na.getLongitude(0), 1e-2); EdgeExplorer explorer = g.createEdgeExplorer(carOutFilter); assertEquals(2, GHUtility.count(explorer.setBaseNode(0))); assertEquals(Helper.createPointList3D(1.5, 1, 0, 2, 3, 0, 11, 20, 1), iter.fetchWayGeometry(2)); assertEquals(11, na.getLatitude(1), 1e-2); assertEquals(20, na.getLongitude(1), 1e-2); assertEquals(2, GHUtility.count(explorer.setBaseNode(1))); assertEquals(GHUtility.asSet(2, 0), GHUtility.getNeighbors(explorer.setBaseNode(1))); assertEquals(12, na.getLatitude(2), 1e-2); assertEquals(12, na.getLongitude(2), 1e-2); assertEquals(1, GHUtility.count(explorer.setBaseNode(2)));
@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); }
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); } } } }
@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)); }
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; }
@Override public double getLatitude(int nodeId) { if (isVirtualNode(nodeId)) return virtualNodes.getLatitude(nodeId - mainNodes); return mainNodeAccess.getLatitude(nodeId); }
@Override public int getDimension() { return mainNodeAccess.getDimension(); }
@Override public boolean is3D() { return mainNodeAccess.is3D(); }
int previousEntryIndex = nodeAccess.getAdditionalNodeField(viaNode); if (previousEntryIndex == NO_TURN_ENTRY) { nodeAccess.setAdditionalNodeField(viaNode, newEntryIndex); } else { int i = 0;
@Override public double getLongitude(int nodeId) { if (isVirtualNode(nodeId)) return virtualNodes.getLongitude(nodeId - mainNodes); return mainNodeAccess.getLongitude(nodeId); }
@Override public void ensureNode(int nodeId) { mainNodeAccess.ensureNode(nodeId); }