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 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_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 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 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))
def test_point_without_file(self):
geo_elevation_data = mod_srtm.get_data()
print(geo_elevation_data.get_elevation(0, 0))
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))
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))
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))
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))
# 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),
