def test_batch_mode(self): # Two pulls that are far enough apart to require multiple files # With batch_mode=False, both files should be kept geo_elevation_data = mod_srtm.get_data(batch_mode=False) elevation1 = geo_elevation_data.get_elevation(42.3467, 71.0972) self.assertTrue(elevation1 > 0) self.assertTrue(len(geo_elevation_data.files) == 1) elevation2 = geo_elevation_data.get_elevation(43.0382, 87.9298) self.assertTrue(elevation2 > 0) self.assertTrue(len(geo_elevation_data.files) == 2) # With batch_mode=True, only the most recent file should be kept geo_elevation_data = mod_srtm.get_data(batch_mode=True) elevation1 = geo_elevation_data.get_elevation(42.3467, 71.0972) self.assertTrue(elevation1 > 0) self.assertTrue(len(geo_elevation_data.files) == 1) keys1 = geo_elevation_data.files.keys() elevation2 = geo_elevation_data.get_elevation(43.0382, 87.9298) self.assertTrue(len(geo_elevation_data.files) == 1) self.assertFalse(geo_elevation_data.files.keys() == keys1)
def test_coordinates_in_file(self): geo_elevation_data = mod_srtm.get_data() geo_file = geo_elevation_data.get_file(47.0, 13.99) print("file:", geo_file) self.assertEqual(geo_file.get_elevation(47, 13), geo_file.get_elevation(47, 13))
def test_coordinates_in_file(self) -> None: geo_elevation_data = mod_srtm.get_data() geo_file = geo_elevation_data.get_file(47.0, 13.99) print('file:', geo_file) self.assertEqual(geo_file.get_elevation(47, 13), geo_file.get_elevation(47, 13)) # type: ignore
def downloadMapTiles(customerLocations, mapBoundaries): filenames = [] filenamesTemp = {} elevation_data = srtm.get_data(srtm1=True) print "Downloading map tiles" for i in range( 0, int( abs( math.floor(mapBoundaries.bRight.lng) - math.floor(mapBoundaries.bLeft.lng))) + 1): elevation_data.get_elevation(mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng + i) filenamesTemp[elevation_data.get_file_name( mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng + i)] = 1 # filenamesShapeTemp[elevation_data.get_swbd_file_name(mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng + i)] = 1 for j in range( 0, int( abs( math.floor(mapBoundaries.tLeft.lat) - math.floor(mapBoundaries.bLeft.lat))) + 1): elevation_data.get_elevation(mapBoundaries.bLeft.lat + j, mapBoundaries.bLeft.lng + i) filenamesTemp[elevation_data.get_file_name( mapBoundaries.bLeft.lat + j, mapBoundaries.bLeft.lng + i)] = 1 # filenamesShapeTemp[elevation_data.get_swbd_file_name(mapBoundaries.bLeft.lat + j, mapBoundaries.bLeft.lng + i)] = 1 for file in filenamesTemp: if file is not None: filenames.append(file.split(".")[0]) return filenames
def lat_lon_array_to_dem(self, lat_arr, lon_arr): """ Function to retrieve SRTM dem value from latitude and longitude arrays. This function calls the SRTM.py_ python library to automatically retrieve Digital Elevation Model values from the `SRTM mission`_ from a latitude vector and a longitude vector. Downloading and caching of SRTM data is handled by SRTM.py_ Args: lat_arr (1D numpy.ndarray): vector of latitudes lon_arr (1D numpy.ndarray): vector of longitudes Returns: 1D numpy.ndarray: vector of corresponding DEM values .. _SRTM.py: https://pypi.python.org/pypi/SRTM.py .. _`SRTM mission`: http://www2.jpl.nasa.gov/srtm/) """ dem_data = srtm.get_data() dem_array = np.empty(0, dtype=np.float) for elat, elon in zip(lat_arr, lon_arr): dem = dem_data.get_elevation(elat, elon) if not dem: dem_array = np.append(dem_array, [0]) else: dem_array = np.append(dem_array, dem) return dem_array
def _get_elevation(latitude_deg, longitude_deg, srtm_data_object=None, working_dir_name=None): """Gets elevation at a single point. WARNING: Input longitudes in western hemisphere must be negative. If `srtm_data_object is None`, it will be created on the fly. :param latitude_deg: Latitude (deg N). :param longitude_deg: Longitude (deg E). :param srtm_data_object: Instance of `srtm.data.GeoElevationData`. :param working_dir_name: See doc for `__init__` in class `ElevationFileHandler`. :return: elevation_m_asl: Elevation (metres above sea level). :return: srtm_data_object: Instance of `srtm.data.GeoElevationData`. """ if srtm_data_object is None: srtm_data_object = srtm.get_data( file_handler=ElevationFileHandler(working_dir_name)) elevation_m_asl = srtm_data_object.get_elevation(latitude=latitude_deg, longitude=longitude_deg) # TODO(thunderhoser): I am concerned about this hack. if elevation_m_asl is None: elevation_m_asl = 0. return elevation_m_asl, srtm_data_object
def test(): handler = util.SpecificFolderFileHandler( os.path.join(get_path_in_chunk(), '.srtm')) elevation_data = srtm.get_data(file_handler=handler) h = elevation_data.get_elevation(57.1, 95.1, approximate=True) print(h) return elevation_data
def elevationtoinflux(lat, lon, vin, displayname, ts, ifclient, dryrun, logger): if not os.path.isfile('srtm.lck.' + str(os.getpid())): Path('srtm.lck.' + str(os.getpid())).touch() elevation_data = srtm.get_data() elevation = elevation_data.get_elevation(lat, lon) os.remove('srtm.lck.' + str(os.getpid())) logger.debug("Elevation: " + str(elevation)) elev_json_body = [{ "measurement": "drive_state", "tags": { "vin": vin, "display_name": displayname, }, "time": int(ts * 1000000), "fields": { "elevation": elevation } }] if not dryrun and elevation is not None: ifclient.write_points(elev_json_body) else: print("Lockfile detected, skipping") sys.exit()
def showHeightmap(self, c, args): lat_min = float(args[0]) lat_max = float(args[1]) lon_min = float(args[2]) lon_max = float(args[3]) delta_lat = vincenty([lat_min, lon_min], [lat_max, lon_min]).kilometers delta_lon = vincenty([lat_min, lon_min], [lat_min, lon_max]).kilometers print(delta_lat, delta_lon) import srtm geo_elevation_data = srtm.get_data() width = 1000 height = (delta_lon * width) / delta_lat print(width, height) #image = geo_elevation_data.get_image((1000, 1000), (50, 51), (8, 9), 800) image = geo_elevation_data.get_image((round(width), round(height)), (lat_min, lat_max), (lon_min, lon_max), int(args[4])) result_object = Result() result_object.category = "image" result_object.payload = image return result_object
def basicTest(frmt:str="latlon", aPoints:list=None) -> None: #srtm library documentation - https://pypi.org/project/SRTM.py/ #srtm file config - D:\Users\BPascal\Anaconda3\Lib\site-packages\srtm\list.json #srtm source files - https://srtm.kurviger.de/index.html #srtm wiki - https://wiki.openstreetmap.org/wiki/SRTM #srtm maps - https://www.usgs.gov/centers/eros/science/usgs-eros-archive-products-overview?qt-science_center_objects=0#qt-science_center_objects #srtm (digital elevation) - https://www.usgs.gov/centers/eros/science/usgs-eros-archive-products-overview?qt-science_center_objects=0#qt-science_center_objects if aPoints: oGEH = GroundEstimatedHeight() if isinstance(aPoints[0], list): ret:list=[] for aPt in aPoints: if frmt!="latlon": aPt = aPt[::-1] #Invertion des coordonnées ret.append(oGEH.getElevation(aPt[0], aPt[1])) print("Points (m)", ret) else: if frmt!="latlon": aPoints = aPoints[::-1] #Invertion des coordonnées print("Point (m)", oGEH.getElevation(aPoints[0], aPoints[1]), "m") else: elevation_data = srtm.get_data() # srtm.get_data(local_cache_dir="tmp_cache") // Default cache - D:\Users\BPascal\.cache\srtm print("Home (m)", elevation_data.get_elevation(48.694548, 2.333953)) print("Place de l avenir (m)", elevation_data.get_elevation(48.700191, 2.325597)) print("Attérissage de Doussart (m)", elevation_data.get_elevation(45.781438, 6.222423))
def generate_auxiliar_columns(df,delta): df['Latitud-1']=df["Latitud"].shift(periods=+1) # Sentido 1 o -1 df['Longitud-1']=df["Longitud"].shift(periods=+1) df["Direction"] = df.apply(lambda r: etl.calc_train_direction(r["Latitud-1"], r["Longitud-1"], r["Latitud"], r["Longitud"]), axis=1) df['fr_wind'] = df.apply(lambda x: etl.front_aerodinamic_wind(x['wind_vmean_10m'], x['wind_direction_10m'], x['Direction']), axis=1) df['lat_wind'] = df.apply(lambda x: etl.lateral_aerodinamic_wind(x['wind_vmean_10m'], x['wind_direction_10m'], x['Direction']), axis=1) #Rellenamos los valores tras el merge df = etl.fill_dataframe_by_ut(df,delta) #Alturas elevation_data = srtm.get_data() df['altitude'] = df.apply(lambda x: elevation_data.get_elevation(x['Latitud'], x['Longitud']), axis=1) df['altitude-1'] = df.apply(lambda x: elevation_data.get_elevation(x['Latitud-1'], x['Longitud-1']), axis=1) df['slope'] = df.apply(lambda x: etl.calculate_slope_as_categorical(x['altitude'], x['altitude-1']), axis=1) df['distance'] = df.apply(lambda x: etl.calculate_distance(x['Latitud'], x['Longitud'], x['Latitud-1'], x['Longitud-1']), axis=1) df['percent_slope'] = df.apply(lambda x: etl.calculate_percent_slope(x['altitude'], x['altitude-1'], x['distance']), axis=1) columns_to_drop = ['Norte', 'Este', 'Nearest_Station', 'Direction', 'estacion', 'fecha', 'wind_vmax_3s', 'wind_vmean_10m', 'wind_direction_10m', 'wind_max_direction_60m', 'tia', 'tmin', 'tmax', 'Latitud-1', 'Longitud-1', 'altitude-1'] #'Latitud', 'Longitud' df.drop(columns_to_drop, axis=1, inplace=True) return df
def fill_elevation_attribute(graph: GeoGraph, attribute_name="elevation[m]", only_missing=True): """Fill the ``elevation[m]`` attribute on nodes of the given geograph. The elevation is found with the `srtm` package. Graph crs has to be WGS84 standard, otherwise elevation data won't be consistent. Parameters ---------- graph : GeoGraph GeoGraph to modify attribute_name : str Attribute to fill (Default value = "elevation[m]") only_missing : bool Get the elevation and set it only if the node attribute is missing. (Default value = True) Examples -------- >>> import geonetworkx as gnx >>> g = gnx.GeoGraph(crs=gnx.WGS84_CRS) >>> g.add_edge(1, 2, geometry=gnx.LineString([(5.15, 45.504), (5.167, 45.506)])) >>> gnx.fill_elevation_attribute(g) # doctest: +SKIP >>> print(g.nodes[1]["elevation[m]"]) # doctest: +SKIP 393 """ if srtm is None: raise ImportError( "Impossible to get elevation data, `srtm` package not found.") elevation_data = srtm.get_data() for n, data in graph.nodes(data=True): if (not only_missing) or attribute_name not in data: longitude, latitude = tuple(*data[graph.nodes_geometry_key].coords) elevation = elevation_data.get_elevation(latitude, longitude) if elevation is not None: data[attribute_name] = elevation
def getElevation(CSVObjList): elevation_data = srtm.get_data() for CSVObj in CSVObjList: #print(CSVObj.lat, CSVObj.long) CSVObj.elevation = elevation_data.get_elevation( CSVObj.lat, CSVObj.long)
def test_random_points(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(63, geo_elevation_data.get_elevation(46.0, 13.0)) self.assertEqual(2714, geo_elevation_data.get_elevation(46.999999, 13.0)) self.assertEqual(1643, geo_elevation_data.get_elevation(46.999999, 13.999999)) self.assertEqual(553, geo_elevation_data.get_elevation(46.0, 13.999999)) self.assertEqual(203, geo_elevation_data.get_elevation(45.2732, 13.7139)) self.assertEqual(460, geo_elevation_data.get_elevation(45.287, 13.905))
def init_reducer(self): self.cur_elev = None self.bounding_box = None self.elev_gain = 0 self.elev_loss = 0 self.min_elev = 20000 self.max_elev = None self.elev_data = srtm.get_data() self.updated = []
def test_without_approximation(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(geo_elevation_data.get_elevation(47.1, 13.1, approximate=False), geo_elevation_data.get_elevation(47.1, 13.1)) # SRTM elevations are always integers: elevation = geo_elevation_data.get_elevation(47.1, 13.1) self.assertTrue(int(elevation) == elevation)
def test_with_approximation(self) -> None: geo_elevation_data = mod_srtm.get_data() self.assertNotEquals(geo_elevation_data.get_elevation(47.1, 13.1, approximate=True), geo_elevation_data.get_elevation(47.1, 13.1)) # When approximating a random point, it probably won't be a integer: elevation = geo_elevation_data.get_elevation(47.1, 13.1, approximate=True) self.assertTrue(int(elevation) != elevation) # type: ignore
def test_random_points(self) -> None: geo_elevation_data = mod_srtm.get_data() self.assertEqual(597, geo_elevation_data.get_elevation(24.056313, 35.003152)) self.assertEqual(63, geo_elevation_data.get_elevation(46., 13.)) self.assertEqual(2714, geo_elevation_data.get_elevation(46.999999, 13.)) self.assertEqual(1643, geo_elevation_data.get_elevation(46.999999, 13.999999)) self.assertEqual(553, geo_elevation_data.get_elevation(46., 13.999999)) self.assertEqual(203, geo_elevation_data.get_elevation(45.2732, 13.7139)) self.assertEqual(460, geo_elevation_data.get_elevation(45.287, 13.905))
def test_with_approximation(self): geo_elevation_data = mod_srtm.get_data() self.assertNotEqual(geo_elevation_data.get_elevation(47.1, 13.1, approximate=True), geo_elevation_data.get_elevation(47.1, 13.1)) # When approximating a random point, it probably won't be a integer: elevation = geo_elevation_data.get_elevation(47.1, 13.1, approximate=True) self.assertTrue(int(elevation) != elevation)
def test_without_approximation(self) -> None: geo_elevation_data = mod_srtm.get_data() self.assertEqual(geo_elevation_data.get_elevation(47.1, 13.1, approximate=False), geo_elevation_data.get_elevation(47.1, 13.1)) # SRTM elevations are always integers: elevation = geo_elevation_data.get_elevation(47.1, 13.1) self.assertTrue(int(elevation) == elevation) # type: ignore
def test_approximation(self): # TODO(TK) Better tests for approximation here: geo_elevation_data = mod_srtm.get_data() elevation_without_approximation = geo_elevation_data.get_elevation(47, 13) elevation_with_approximation = geo_elevation_data.get_elevation(47, 13, approximate=True) print(elevation_without_approximation) print(elevation_with_approximation) self.assertNotEquals(elevation_with_approximation, elevation_without_approximation) self.assertTrue(abs(elevation_with_approximation - elevation_without_approximation) < 30)
def test_approximation(self) -> None: # TODO(TK) Better tests for approximation here: geo_elevation_data = mod_srtm.get_data() elevation_without_approximation = geo_elevation_data.get_elevation(47, 13) elevation_with_approximation = geo_elevation_data.get_elevation(47, 13, approximate=True) print(elevation_without_approximation) print(elevation_with_approximation) self.assertNotEqual(elevation_with_approximation, elevation_without_approximation) self.assertTrue(abs(elevation_with_approximation - elevation_without_approximation) < 30) # type: ignore
def downloadMapTiles(customerLocations, mapBoundaries): filenames = [] filenamesTemp = {} elevation_data = srtm.get_data(srtm3=True, srtm1=False) print "Downloading map tiles" for i in range( 0, int( abs( math.floor(mapBoundaries.bRight.lng) - math.floor(mapBoundaries.bLeft.lng))) + 1): elevation_data.get_elevation(mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng + i) filenamesTemp[elevation_data.get_file_name( mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng + i)] = 1 # filenamesShapeTemp[elevation_data.get_swbd_file_name(mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng + i)] = 1 for j in range( 0, int( abs( math.floor(mapBoundaries.tLeft.lat) - math.floor(mapBoundaries.bLeft.lat))) + 1): elevation_data.get_elevation(mapBoundaries.bLeft.lat + j, mapBoundaries.bLeft.lng + i) filenamesTemp[elevation_data.get_file_name( mapBoundaries.bLeft.lat + j, mapBoundaries.bLeft.lng + i)] = 1 # filenamesShapeTemp[elevation_data.get_swbd_file_name(mapBoundaries.bLeft.lat + j, mapBoundaries.bLeft.lng + i)] = 1 # fixme: check if BLeft < Tleft # for i in range(0, int(math.ceil(abs(mapBoundaries.tRight.lng - mapBoundaries.tLeft.lng)))+1): # for j in range(0, int(math.ceil(abs(mapBoundaries.tLeft.lat - mapBoundaries.bLeft.lat)))+1): # # print mapBoundaries.tLeft.lng + i, mapBoundaries.bLeft.lat + j # elevation_data.get_elevation(mapBoundaries.bLeft.lat + j, mapBoundaries.tLeft.lng + i) # filenamesTemp[elevation_data.get_file_name(mapBoundaries.bLeft.lat + j, mapBoundaries.tLeft.lng + i)] = 1 # elevation_data.get_elevation(mapBoundaries.tRight.lat, mapBoundaries.tRight.lng) # filenamesTemp[elevation_data.get_file_name(mapBoundaries.bRight.lat, mapBoundaries.bRight.lng)] = 1 # elevation_data.get_elevation(mapBoundaries.tLeft.lat, mapBoundaries.tLeft.lng) # filenamesTemp[(elevation_data.get_file_name(mapBoundaries.tLeft.lat, mapBoundaries.tLeft.lng))] = 1 # elevation_data.get_elevation(mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng) # filenamesTemp[(elevation_data.get_file_name(mapBoundaries.bLeft.lat, mapBoundaries.bLeft.lng))] = 1 # elevation_data.get_elevation(mapBoundaries.bRight.lat, mapBoundaries.bRight.lng) # filenamesTemp[(elevation_data.get_file_name(mapBoundaries.bRight.lat, mapBoundaries.bRight.lng))] = 1 # for coords in customerLocations: # elevation_data.get_elevation(coords.lat, coords.lng) # filenamesTemp[(elevation_data.get_file_name(coords.lat, coords.lng))] = 1 for file in filenamesTemp: if file is not None: filenames.append(file.split(".")[0]) return filenames
def parse_source(self): elevation_data = srtm.get_data() gpx = gpxpy.parse(self.source_file.open()) elevation_data.add_elevations(gpx, smooth=True, gpx_smooth_no=settings.GPX_SMOOTH_NO) file = ContentFile(gpx.to_xml("1.1")) filename = self.source_file.name self.source_file.delete() self.source_file.save(filename, file) self.datetime = gpx.get_time_bounds().start_time self.state = Track.StateChoices.READY self.save()
def test_files_equality(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(geo_elevation_data.get_file(47.0, 13.99), geo_elevation_data.get_file(47.0, 13.0)) self.assertEqual(geo_elevation_data.get_file(47.99, 13.99), geo_elevation_data.get_file(47.0, 13.0)) self.assertEqual(geo_elevation_data.get_file(-47.0, 13.99), geo_elevation_data.get_file(-47.0, 13.0)) self.assertEqual(geo_elevation_data.get_file(-47.99, 13.99), geo_elevation_data.get_file(-47.0, 13.0)) self.assertEqual(geo_elevation_data.get_file(-47.0, -13.99), geo_elevation_data.get_file(-47.0, -13.0)) self.assertEqual(geo_elevation_data.get_file(-47.99, -13.99), geo_elevation_data.get_file(-47.0, -13.0)) self.assertEqual(geo_elevation_data.get_file(47.0, -13.99), geo_elevation_data.get_file(47.0, -13.0)) self.assertEqual(geo_elevation_data.get_file(47.99, -13.99), geo_elevation_data.get_file(47.0, -13.0))
def test_invalit_coordinates_for_file(self) -> None: geo_elevation_data = mod_srtm.get_data() geo_file = geo_elevation_data.get_file(47.0, 13.99) try: self.assertFalse(geo_file.get_elevation(1, 1)) # type: ignore except Exception as e: message = str(e) self.assertEqual('Invalid latitude 1 for file N47E013.hgt', message) try: self.assertFalse(geo_file.get_elevation(47, 1)) # type: ignore except Exception as e: message = str(e) self.assertEqual('Invalid longitude 1 for file N47E013.hgt', message)
def export_runzi_points(file_obj, time=datetime.now()): runzi_list = [] elevation_data = srtm.get_data() current_time = time - timedelta(hours=10) for line in file_obj.readlines()[3:]: indv_point = line.split('|') current_time += timedelta(0, milliseconds=int(indv_point[0])) runzi_point = { 'latitude': indv_point[2], 'longitude': indv_point[3], 'time': current_time, 'elevation': elevation_data.get_elevation(indv_point[2], indv_point[3]) } runzi_list.append(runzi_point) return runzi_list
def test_coordinates_row_col_conversion(self): geo_elevation_data = mod_srtm.get_data() geo_file = geo_elevation_data.get_file(47.0, 13.99) print('file:', geo_file) r, c = geo_file.get_row_and_column(47, 13) lat, long = geo_file.get_lat_and_long(r, c) self.assertEqual(lat, 47) self.assertEqual(long, 13) r, c = geo_file.get_row_and_column(46.5371, 8.1264) lat, long = geo_file.get_lat_and_long(r, c) self.assertAlmostEqual(lat, 46.5371, delta=geo_file.resolution) self.assertAlmostEqual(long, 8.1264, delta=geo_file.resolution)
def test_invalit_coordinates_for_file(self): geo_elevation_data = mod_srtm.get_data() geo_file = geo_elevation_data.get_file(47.0, 13.99) try: self.assertFalse(geo_file.get_elevation(1, 1)) except Exception as e: message = str(e) self.assertEqual("Invalid latitude 1 for file N47E013.hgt", message) try: self.assertFalse(geo_file.get_elevation(47, 1)) except Exception as e: message = str(e) self.assertEqual("Invalid longitude 1 for file N47E013.hgt", message)
def __init__(self, min_lat, min_lon, max_lat, max_lon, hgts_folder, tasks): QtCore.QThread.__init__(self) self.hgts_folder = hgts_folder handler = util.SpecificFolderFileHandler(hgts_folder) self.min_lat = min_lat self.max_lat = max_lat self.min_lon = min_lon self.max_lon = max_lon self.elevation_data = srtm.get_data(file_handler=handler) self.hgt_names = self.get_hgt_names() self.percent_per_file = 100.0 / len(self.hgt_names) self.stopped = False self.paused = False self.mutex = QtCore.QMutex() self.merged_tif = os.path.join(self.hgts_folder, 'result.tif') self.full_hgt_names = '' self.tasks = tasks
def __init__(self, bbox=(-71.928864, 43.758201, -70.957947, 44.465151), font=None): """Initialize RidgeMap. Parameters ---------- bbox : list-like of length 4 In the form (long, lat, long, lat), describing the (bottom_left, top_right) corners of a box. http://bboxfinder.com is a useful way to find these tuples. font : matplotlib.font_manager.FontProperties Optional, a custom font to use. Defaults to Cinzel Regular. """ self.bbox = bbox self._srtm_data = srtm.get_data() if font is None: font = FontManager().prop self.font = font
def make_elevation_grid(): """ Uses SRTM.py to create an intermediate elevation tile representation and concatenates the tiles into a single array that can be indexed via latitude and longitude. Note, this takes a long time and downloads about 62 GB of data. Don't run this if the elevation grid is already available. """ def cleanup_elevation_grid(): """Concatenate tiles_latlon into a single array and replace NaNs with 0""" ta = [np.concatenate(tr, axis=1) for tr in tiles_latlon] ta = np.concatenate(ta) ta[np.isnan(ta)] = 0 print('Saving elevation array to {}'.format(elev_fname)) np.save(elev_fname, ta) try: import srtm except: print('Install SRTM.py via\n' 'pip3 install git+https://github.com/tkrajina/srtm.py.git') raise try: print('Resuming construction of tiles from {}'.format(tiles_fname)) tiles_latlon = np.load(tiles_fname) except: print('Creating list of empty tiles') tiles_latlon = [[None for _ in range(len(lon_ranges))] for _ in range(len(lat_ranges))] for k, lati in enumerate(lat_ranges): ed = srtm.get_data() for l, loti in enumerate(lon_ranges): print(lati, loti) if tiles_latlon[k][ l] is None: # only compute what we don't yet have try: tiles_latlon[k][l] = ed.get_image( (tile_size, tile_size), (lati, lati + tile_degrees), (loti, loti + tile_degrees), 10000, mode='array') except: print('Error producing tile {}, {}'.format(lati, loti)) pass np.save(tiles_fname, tiles_latlon) cleanup_elevation_grid()
def get_elevation(track_points): """ Get elevation of track points. Typically, requesting elevation of track points can take time. @param track_points: List of OSM node ids. @return: Dictionary of elevations for node ids. >>> elevation_nodes = [360693242, 360693253, 360693255, 360693257, 550026012] >>> elevation = get_elevation(elevation_nodes) """ elevation = {} for nd in track_points: node = get_node_by_id(nd) elevation_data = srtm.get_data() elevation[nd] = elevation_data.get_elevation(node['lat'], node['lon'], approximate=True) print 'Elevation (meters):', elevation[nd] return elevation
def __init__(self, oLog, srcPath, refPath, headFileName=""): bpaTools.initEvent(__file__, oLog) self.oLog = oLog self.refPath = refPath self.srcPath = srcPath self.headFileName = headFileName self.elevation_data = srtm.get_data() self.sHead = "headerFile" self.sProp = "properties" self.sGeom = "geometry" self.sCoor = "coordinates" self.sRefe = "referential" self.sFeat = "features" self.sUnknownGroundHeightFileName = self.headFileName + "refUnknownGroundHeight.json" self.sGroundHeightFileName = self.headFileName + "refGroundEstimatedHeight" self.sGroundHeightFileNameJson = self.sGroundHeightFileName + ".json" self.sGroundHeightFileNameGeoj = self.sGroundHeightFileName + ".geojson" return
def coords_callback(self, coords): # callback method for coords elevation_data = srtm.get_data() elev=0 for osm_id, lon, lat in coords: if self.min_lat_bound and lat < self.min_lat_bound: continue if self.max_lat_bound and lat > self.max_lat_bound: continue if self.min_lon_bound and lon < self.min_lon_bound: continue if self.max_lon_bound and lon > self.max_lon_bound: continue #elev=elevation_data.get_elevation(lat, lon) if osm_id in self.coords: elev=elevation_data.get_elevation(lat, lon) self.coords[osm_id] = (lat, lon, elev) #print self.coords[osm_id] # status output if self.verbose: self.num_coords = self.num_coords + 1 if not (self.num_coords % self.coords_marker): sys.stderr.write('.') sys.stderr.flush()
def test_around_zero_longitude(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(61, geo_elevation_data.get_elevation(51.2, 0.0)) self.assertEqual(100, geo_elevation_data.get_elevation(51.2, -0.1)) self.assertEqual(59, geo_elevation_data.get_elevation(51.2, 0.1))
def main(): geo_elevation_data = srtm.get_data() image = geo_elevation_data.get_image((500, 500), (45, 46), (13, 14), 300) # the image s a standard PIL object, you can save or show it: image.show()
previous_point = point yield mod_charts.data(length, point.elevation) return mod_charts.LineChart(data=f, color=color, transparency_mask=transparency_mask) def sample_gpx(): return mod_gpxpy.parse(open('sample_files/setnjica-kod-karojbe.gpx')) coordinate_system = mod_cartesius.CoordinateSystem(bounds=(-300, 6800, -40, 480)) coordinate_system.add(mod_elements.Grid(20, 100)) gpx = sample_gpx() coordinate_system.add(get_line(gpx, color=(0, 0, 0))) data = mod_srtm.get_data() gpx = sample_gpx() data.add_elevations(gpx) coordinate_system.add(get_line(gpx, color=(0, 0, 255), transparency_mask=150)) gpx = sample_gpx() data.add_elevations(gpx, smooth=True) coordinate_system.add(get_line(gpx, color=(255, 0, 0))) coordinate_system.add(mod_elements.Axis(horizontal=True, labels=500, points=100)) coordinate_system.add(mod_elements.Axis(vertical=True, labels=100, points=20)) image = coordinate_system.draw(600, 400, antialiasing=True) #image.show()
def getElevation(self, row): return get_data().get_elevation(Decimal(row['lat']), Decimal(Decimal(row['lon'])))
def test_dead_sea(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(-415, geo_elevation_data.get_elevation(31.5, 35.5))
def get_elevs(self, coords): #no longer used. elevations have been added to coords wayback thingymajig print "importing SRTM data" elevation_data = srtm.get_data() for osm_id in coords: self.coords[osm_id]=(self.coords[osm_id][0], self.coords[osm_id][1], elevation_data.get_elevation(self.coords[osm_id][0],self.coords[osm_id][0]))
def test_point_without_file(self): geo_elevation_data = mod_srtm.get_data() print(geo_elevation_data.get_elevation(0, 0))
def test_point_with_invalid_elevation(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(None, geo_elevation_data.get_elevation(47.0, 13.07))
mminx, mminy = ll2m(miny, minx) mmaxx, mmaxy = ll2m(maxy, maxx) # Download the OSM basemap log.info("Downloading basemap") wms(mminx, mminy, mmaxx, mmaxy, osm_WMS, osm_lyr, osm_epsg, osm_style, osm_img, w, h) # Download the SRTM image # srtm.py downloader log.info("Retrieving SRTM elevation data") # The SRTM module will try to use a local cache # first and if needed download it. srt = srtm.get_data() # Get the image and return a PIL Image object image = srt.get_image((w, h), (miny, maxy), (minx, maxx), 300, zero_color=zero_clr, min_color=min_clr, max_color=max_clr) # Save the image image.save(elv_img + ".jpg") # Hillshade the elevation image log.info("Hillshading elevation data") im = Image.open(elv_img + ".jpg").convert("L") dem = np.asarray(im) # Set up structure for a 3x3 windows to # process the slope throughout the grid
# L = np.cross(N1, N2) # # Find two intersection points # X1 = L / np.sqrt(L[0]**2 + L[1]**2 + L[2]**2) # X2 = -X1 # i_lat1 = math.asin(X1[2]) * 180./np.pi # i_long1 = math.atan2(X1[1], X1[0]) * 180./np.pi # i_lat2 = math.asin(X2[2]) * 180./np.pi # i_long2 = math.atan2(X2[1], X2[0]) * 180./np.pi # # Print results # print i_lat1, i_long1, i_lat2, i_long2 map_size = 500.0 elevation_data = srtm.get_data(True, True, False, None, True) # lat_from = 37.223 # lat_to = 37.223 # long_from = -122.092 # long_to = -122.407 # lat_from = 37.2478 # lat_to = 37.4432 # long_from = -122.27233 # long_to = -122.30941 # lat_from = 37.1478 # lat_to = 37.5432 # long_from = -122.27233 # long_to = -122.00941
def test_invalid_file(self): geo_elevation_data = mod_srtm.get_data() geo_file = geo_elevation_data.get_file(-47.0, -13.99) self.assertEqual(None, geo_file)
tracks = [] def getElevationData(gpx): data = [] previous_point = None length = 0 for point in gpx.walk(only_points=True): if previous_point: length += previous_point.distance_2d(point) previous_point = point data.append((length, point.elevation)) return data print "Getting SRTM data" elevation_data = srtm.get_data() for track_filename in glob.glob(TRACK_META_DIR + '/*.json'): print "Parsing file: %s" % (track_filename) with open(track_filename) as data_file: track_data = json.load(data_file) track_data['gpx'] = "%s/%s" % (TRACK_ROUTE_DIR, track_data['gpx']) track_data['meta'] = track_data.copy() gpx = gpxpy.parse(open(track_data['gpx'])) uphill_orig, downhill_orig = gpx.get_uphill_downhill() track_data['stats'] = {} track_data['stats']['uphill_orig_meters'] = math.floor(uphill_orig) track_data['stats']['downhill_orig_meters'] = math.floor(downhill_orig) track_data['stats']['length_2d_meters'] = math.floor(gpx.length_2d())
def test_around_zero_latitude(self): geo_elevation_data = mod_srtm.get_data() self.assertEqual(393, geo_elevation_data.get_elevation(0, 15)) self.assertEqual(423, geo_elevation_data.get_elevation(-0.1, 15)) self.assertEqual(381, geo_elevation_data.get_elevation(0.1, 15))
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import logging as mod_logging import PIL.Image as mod_image import PIL.ImageDraw as mod_imagedraw import srtm as mod_srtm mod_logging.basicConfig(level=mod_logging.DEBUG, format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s') geo_elevation_data = mod_srtm.get_data() image = geo_elevation_data.get_image((400, 400), (45, 46), (13, 14), 300) image.save('istra.png') miami = (25.787676, -80.224145) image = geo_elevation_data.get_image((400, 400), (miami[0] - 1, miami[0] + 1.5), (miami[1] - 2, miami[1] + 0.5), 40) image.save('miami.png') rio_de_janeiro = (-22.908333, -43.196389) image = geo_elevation_data.get_image((400, 400), (rio_de_janeiro[0] - 0.5, rio_de_janeiro[0] + 2), (rio_de_janeiro[1] - 0.5, rio_de_janeiro[1] + 2),