def test_utm(self, patch_config):
lats = [0.2, 0.8, 0.6]
lons = [10.2, 10.8, 11.5]
dataset = config.load_datasets()[SRTM_DATASET_NAME]
z = backend.get_elevation(lats, lons, dataset)
dataset_utm = config.load_datasets()[SRTM_UTM_DATASET_NAME]
z_utm = backend.get_elevation(lats, lons, dataset_utm)
assert np.allclose(z, z_utm)
def test_dataset_crs_format_equivalence(self, patch_config):
lats = [43.597009, 45.534601]
lons = [1.455697, 10.698698]
dataset_epsg = config.load_datasets()[EU_DEM_DATASET_NAME]
z_epsg = backend.get_elevation(lats, lons, dataset_epsg)
dataset_wkt = config.load_datasets()[EU_DEM_NO_EPSG_DATASET_NAME]
z_wkt = backend.get_elevation(lats, lons, dataset_wkt)
assert np.allclose(z_epsg, z_wkt)
def test_srtm_tiles(self, patch_config):
lats = [0.1, 0.9]
lons = [10.5, 11.5]
dataset = config.load_datasets()[SRTM_DATASET_NAME]
z = backend.get_elevation(lats, lons, dataset)
assert all(z)
assert all(np.isfinite(z))
def test_single_dataset(self, patch_config):
lats = [0.1, 0.9]
lons = [10.5, 11.5]
dataset = config.load_datasets()[SRTM_DATASET_NAME]
z, names = backend.get_elevation(lats, lons, [dataset])
assert all(z)
assert all(np.isfinite(z))
assert names == [SRTM_DATASET_NAME] * len(lats)
def test_single_file_dataset(self):
lats = [0.1, -9]
lons = [-50.5, 12.11]
interpolation = "cubic"
dataset = config.load_datasets()[ETOPO1_DATASET_NAME]
elevations_by_dataset = backend.get_elevation(lats, lons, dataset,
interpolation)
elevations_by_path = backend._get_elevation_from_path(
lats, lons, ETOPO1_GEOTIFF_PATH, interpolation)
assert elevations_by_dataset == elevations_by_path
def get_elevation_bunch(dataset_name):
"""Calculate the elevation for the given locations.
Args:
dataset_name: String matching a dataset in the config file.
Json Body:
inerpolation: Interpolation mode.
nodata_value: Value which should be returned if no data is found for a location.
locations: String with locations
Returns:
Response.
"""
try:
# Parse inputs.
interpolation = _parse_interpolation(request.json.get("interpolation"))
nodata_value = _parse_nodata_value(request.json.get("nodata_value"))
lats, lons = _parse_locations(
request.json["locations"], _load_config()["max_locations_per_request"]
)
# Get the z values.
datasets = _get_datasets(dataset_name)
elevations, dataset_names = backend.get_elevation(
lats, lons, datasets, interpolation, nodata_value
)
# Build response.
results = []
for z, dataset_name, lat, lon in zip(elevations, dataset_names, lats, lons):
results.append(
{
"elevation": z,
"dataset": dataset_name,
"location": {"lat": lat, "lng": lon},
}
)
data = {"status": "OK", "results": results}
return jsonify(data)
except (ClientError, backend.InputError) as e:
return jsonify({"status": "INVALID_REQUEST", "error": str(e)}), 400
except config.ConfigError as e:
return (
jsonify({"status": "SERVER_ERROR", "error": "Config Error: {}".format(e)}),
500,
)
except Exception as e:
if app.debug:
raise e
app.logger.error(e)
msg = "Unhandled server error, see server logs for details."
return jsonify({"status": "SERVER_ERROR", "error": msg}), 500
def test_multi_dataset_mask(self, patch_config):
lats = [47.625765, 0.1, 70]
lons = [9.418759, 10.5, 150]
datasets = [
config.load_datasets()[ETOPO1_RESAMPLED_DATASET_NAME],
config.load_datasets()[EU_DEM_DATASET_NAME],
config.load_datasets()[SRTM_DATASET_NAME],
]
z, dataset_names = backend.get_elevation(lats, lons, datasets)
assert all(np.isfinite(z))
assert dataset_names == [ETOPO1_RESAMPLED_DATASET_NAME] * len(lats)
def get_elevation(dataset_name):
"""Calculate the elevation for the given locations.
Args:
dataset_name: String matching a dataset in the config file.
Returns:
Response.
"""
try:
# Parse inputs.
interpolation = request.args.get("interpolation",
DEFAULT_INTERPOLATION_METHOD)
interpolation = _validate_interpolation(interpolation)
locations = request.args.get("locations")
lats, lons = _parse_locations(
locations,
_load_config()["max_locations_per_request"])
# Get the z values.
dataset = _get_dataset(dataset_name)
elevations = backend.get_elevation(lats, lons, dataset, interpolation)
# Build response.
results = []
for z, lat, lon in zip(elevations, lats, lons):
results.append({
"elevation": z,
"location": {
"lat": lat,
"lng": lon
}
})
data = {"status": "OK", "results": results}
return jsonify(data)
except (ClientError, backend.InputError) as e:
return jsonify({"status": "INVALID_REQUEST", "error": str(e)}), 400
except config.ConfigError as e:
return (
jsonify({
"status": "SERVER_ERROR",
"error": "Config Error: {}".format(e)
}),
500,
)
except Exception as e:
if app.debug:
raise e
app.logger.error(e)
msg = "Server error, please retry request."
return jsonify({"status": "SERVER_ERROR", "error": msg}), 500
def test_alternate_tiled_dataset(self, patch_config):
lats = [47.625765]
lons = [9.418759]
dataset = config.load_datasets()[EU_DEM_DATASET_NAME]
z = backend.get_elevation(lats, lons, dataset)
assert np.isfinite(z)
def test_out_of_srtm_bounds_utm(self, patch_config):
lats = [70]
lons = [10.5]
dataset = config.load_datasets()[SRTM_DATASET_NAME]
z = backend.get_elevation(lats, lons, dataset)[0]
assert z is None
def test_oob(self, patch_config):
lats = [1.5, -0.5, 0.5, 0.5]
lons = [10.5, 11.5, 9.5, 12.5]
dataset = config.load_datasets()[SRTM_DATASET_NAME]
z = backend.get_elevation(lats, lons, dataset)
assert all([x is None for x in z])
def get_elevation(dataset_name):
"""Calculate the elevation for the given locations.
Args:
dataset_name: String matching a dataset in the config file.
Returns:
Response.
"""
try:
# Parse inputs.
interpolation = _parse_interpolation(
_find_request_argument(request, "interpolation"))
nodata_value = _parse_nodata_value(
_find_request_argument(request, "nodata_value"))
lats, lons = _parse_locations(
_find_request_argument(request, "locations"),
_load_config()["max_locations_per_request"],
)
# Check if need to do sampling.
n_samples = _parse_n_samples(
_find_request_argument(request, "samples"),
_load_config()["max_locations_per_request"],
)
if n_samples:
lats, lons = utils.sample_points_on_path(lats, lons, n_samples)
# Get the z values.
datasets = _get_datasets(dataset_name)
elevations, dataset_names = backend.get_elevation(
lats, lons, datasets, interpolation, nodata_value)
# Build response.
results = []
for z, dataset_name, lat, lon in zip(elevations, dataset_names, lats,
lons):
results.append({
"elevation": z,
"dataset": dataset_name,
"location": {
"lat": lat,
"lng": lon
},
})
data = {"status": "OK", "results": results}
return jsonify(data)
except (ClientError, backend.InputError) as e:
return jsonify({"status": "INVALID_REQUEST", "error": str(e)}), 400
except config.ConfigError as e:
return (
jsonify({
"status": "SERVER_ERROR",
"error": "Config Error: {}".format(e)
}),
500,
)
except Exception as e:
if app.debug:
raise e
app.logger.error(e)
msg = "Unhandled server error, see server logs for details."
return jsonify({"status": "SERVER_ERROR", "error": msg}), 500
def get_elevation_auto(status='OK'):
"""Calculate the elevation for the given locations.
Args:
dataset_name: String matching a dataset in the config file.
Returns:
Response.
"""
try:
# Parse inputs.
interpolation = request.args.get("interpolation",
DEFAULT_INTERPOLATION_METHOD)
interpolation = _validate_interpolation(interpolation)
locations = request.args.get("locations")
if locations == None:
locations = request.args.get("region")
lats, lons = _parse_region(
locations,
_load_config()["max_locations_per_request"])
else:
lats, lons = _parse_locations(
locations,
_load_config()["max_locations_per_request"])
#data = {"status": "FAIL", "reason": "supports only region"}
#return jsonify(data)
# Get the z values.
#dataset = _get_dataset(dataset_name)
datasets = _load_datasets()
numdatasets = len(list(datasets))
if 'maxres' in request.args:
i = 0
elif 'dataset' in request.args:
reqdataset = request.args.get("dataset")
for i in range(0, numdatasets):
if (datasets[list(datasets)[i]].name == reqdataset):
break
i = i - 1
if i < 0: i = 0
else:
minres = min(abs(lats[1] - lats[0]),
abs(np.unique(lons)[1] - np.unique(lons)[0])) * 3600
for i in range(0, numdatasets):
if (datasets[list(datasets)[i]].resolution > minres):
break
i = i - 1
if i < 0: i = 0
keepgoing = True
while keepgoing:
try:
elevations = backend.get_elevation(lats, lons,
datasets[list(datasets)[i]],
interpolation)
except (ClientError, backend.InputError):
i = i + 1
continue
datasetused = list(datasets)[i]
if [
elevations[i] == elevations[i]
for i in range(len(elevations))
].count(False):
i = i + 1
else:
keepgoing = False
if i >= numdatasets:
status = 'MISSING DATA'
keepgoing = False
#if i<numdatasets-1 and [elevations[i]==elevations[i] for i in range(len(elevations))].count(False): # of nans
# return(get_elevation('srtm30m', status='FALLBACK')) ;
## Build response.
results = []
if 'verbose' in request.args:
for z, lat, lon in zip(elevations, lats, lons):
results.append({
"elevation": z,
"location": {
"lat": lat,
"lng": lon
}
})
else:
results.append({"elevation": elevations})
data = {"status": status, "dataset": datasetused, "results": results}
return jsonify(data)
except (ClientError, backend.InputError) as e:
return jsonify({"status": "INVALID_REQUEST", "error": str(e)}), 400
except config.ConfigError as e:
return (
jsonify({
"status": "SERVER_ERROR",
"error": "Config Error: {}".format(e)
}),
500,
)
except Exception as e:
if app.debug:
raise e
app.logger.error(e)
msg = "Server error, please retry request."
return jsonify({"status": "SERVER_ERROR", "error": msg}), 500
