def get_best_zoom_level(input_file, tile_pyramid_type):
"""
Determine the best base zoom level for a raster.
"Best" means the maximum zoom level where no oversampling has to be done.
Parameters
----------
input_file : path to raster file
tile_pyramid_type : ``TilePyramid`` projection (``geodetic`` or``mercator``)
Returns
-------
zoom : integer
"""
tile_pyramid = BufferedTilePyramid(tile_pyramid_type)
with rasterio.open(input_file, "r") as src:
xmin, ymin, xmax, ymax = reproject_geometry(
segmentize_geometry(
box(src.bounds.left, src.bounds.bottom, src.bounds.right,
src.bounds.top),
get_segmentize_value(input_file, tile_pyramid)),
src_crs=src.crs,
dst_crs=tile_pyramid.crs).bounds
x_dif = xmax - xmin
y_dif = ymax - ymin
size = float(src.width + src.height)
avg_resolution = ((x_dif / float(src.width)) *
(float(src.width) / size) +
(y_dif / float(src.height)) *
(float(src.height) / size))
for zoom in range(0, 40):
if tile_pyramid.pixel_x_size(zoom) <= avg_resolution:
return zoom - 1
def test_resample_from_array():
"""Resample array using rasterio reproject()."""
in_tile = BufferedTilePyramid("geodetic").tile(5, 5, 5)
in_data = np.ones(in_tile.shape)
# tile from next toom level
out_tile = BufferedTilePyramid("geodetic").tile(6, 10, 10)
out_array = resample_from_array(in_data, in_tile.affine, out_tile)
assert isinstance(out_array, ma.masked_array)
assert np.all(np.where(out_array == 1, True, False))
# not intersecting tile
out_tile = BufferedTilePyramid("geodetic").tile(7, 0, 0)
out_array = resample_from_array(in_data, in_tile.affine, out_tile)
assert isinstance(out_array, ma.masked_array)
assert out_array.mask.all()
# data as tuple
in_data = (np.ones(in_tile.shape[1:]), )
out_tile = BufferedTilePyramid("geodetic").tile(6, 10, 10)
out_array = resample_from_array(in_data, in_tile.affine, out_tile)
# errors
with pytest.raises(TypeError):
in_data = "invalid_type"
resample_from_array(in_data, in_tile.affine, out_tile)
with pytest.raises(TypeError):
in_data = np.ones(in_tile.shape[0])
resample_from_array(in_data, in_tile.affine, out_tile)
def test_raster_window_memoryfile():
"""Use context manager for rasterio MemoryFile."""
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
data = ma.masked_array(np.ones((2, ) + tile.shape))
for out_profile in [
dict(
driver="GTiff", count=2, dtype="uint8", compress="lzw", nodata=0,
height=tile.height, width=tile.width, affine=tile.affine),
dict(
driver="GTiff", count=2, dtype="uint8", compress="deflate",
nodata=0, height=tile.height, width=tile.width,
affine=tile.affine),
dict(
driver="PNG", count=2, dtype="uint8", nodata=0, height=tile.height,
width=tile.width, compress=None, affine=tile.affine),
]:
with RasterWindowMemoryFile(
in_tile=tile, in_data=data, out_profile=out_profile
) as memfile:
with memfile.open() as src:
assert src.read().any()
assert src.meta["driver"] == out_profile["driver"]
assert src.transform == tile.affine
if out_profile["compress"]:
assert src.compression == Compression(
out_profile["compress"].upper())
def test_s3_write_output_data(mp_s3_tmpdir):
"""Write and read output."""
output_params = dict(grid="geodetic",
format="PNG",
path=mp_s3_tmpdir,
pixelbuffer=0,
metatiling=1)
output = png.OutputDataWriter(output_params)
assert output.path == mp_s3_tmpdir
assert output.file_extension == ".png"
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
# get_path
assert output.get_path(tile) == os.path.join(
*[mp_s3_tmpdir, "5", "5", "5" + ".png"])
# profile
assert isinstance(output.profile(tile), dict)
# write
data = np.ones((1, ) + tile.shape) * 128
output.write(tile, data)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile)
assert isinstance(data, np.ndarray)
assert data.shape[0] == 4
assert not data[0].mask.any()
# empty
empty = output.empty(tile)
assert isinstance(empty, ma.MaskedArray)
assert not empty.any()
def test_read_raster_window(dummy1_tif, minmax_zoom):
"""Read array with read_raster_window."""
zoom = 8
# without reproject
config = MapcheteConfig(minmax_zoom.path)
rasterfile = config.params_at_zoom(zoom)["input"]["file1"]
dummy1_bbox = rasterfile.bbox()
pixelbuffer = 5
tile_pyramid = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
tiles = list(tile_pyramid.tiles_from_geom(dummy1_bbox, zoom))
# add edge tile
tiles.append(tile_pyramid.tile(8, 0, 0))
for tile in tiles:
width, height = tile.shape
for band in read_raster_window(dummy1_tif, tile):
assert isinstance(band, ma.MaskedArray)
assert band.shape == (width, height)
for index in range(1, 4):
band = read_raster_window(dummy1_tif, tile, index)
assert isinstance(band, ma.MaskedArray)
assert band.shape == (width, height)
for index in [None, [1, 2, 3]]:
band = read_raster_window(dummy1_tif, tile, index)
assert isinstance(band, ma.MaskedArray)
assert band.ndim == 3
assert band.shape == (3, width, height)
def test_input_data(mp_tmpdir, cleantopo_br):
"""Check GeoTIFF proces output as input data."""
with mapchete.open(cleantopo_br.path) as mp:
tp = BufferedTilePyramid("geodetic")
# TODO tile with existing but empty data
tile = tp.tile(5, 5, 5)
output_params = dict(
grid="geodetic",
format="GeoTIFF",
path=mp_tmpdir,
pixelbuffer=0,
metatiling=1,
bands=2,
dtype="int16",
delimiters=dict(bounds=Bounds(-180.0, -90.0, 180.0, 90.0),
effective_bounds=Bounds(-180.439453125, -90.0,
180.439453125, 90.0),
zoom=[5],
process_bounds=Bounds(-180.0, -90.0, 180.0, 90.0)))
output = gtiff.OutputDataWriter(output_params)
with output.open(tile, mp) as input_tile:
for data in [
input_tile.read(),
input_tile.read(1),
input_tile.read([1]),
# TODO assert valid indexes are passed input_tile.read([1, 2])
]:
assert isinstance(data, ma.masked_array)
assert input_tile.is_empty()
# open without resampling
with output.open(tile, mp) as input_tile:
pass
def test_s3_write_output_data(mp_s3_tmpdir):
"""Write and read output."""
output_params = dict(type="geodetic",
format="PNG_hillshade",
path=mp_s3_tmpdir,
pixelbuffer=0,
metatiling=1)
output = png_hillshade.OutputData(output_params)
assert output.path == mp_s3_tmpdir
assert output.file_extension == ".png"
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
# get_path
assert output.get_path(tile) == os.path.join(
*[mp_s3_tmpdir, "5", "5", "5" + ".png"])
# profile
assert isinstance(output.profile(tile), dict)
# write full array
data = np.ones(tile.shape) * 128
output.write(tile, data)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile)
assert isinstance(data, np.ndarray)
assert not data.mask.any()
def test_count_tiles_mercator():
for metatiling in [1, 2, 4, 8, 16]:
tp = BufferedTilePyramid("mercator", metatiling=metatiling)
for zoom in range(13):
count_by_geom = count_tiles(box(*tp.bounds), tp, zoom, zoom)
count_by_tp = tp.matrix_width(zoom) * tp.matrix_height(zoom)
assert count_by_geom == count_by_tp
def test_input_data(mp_tmpdir, cleantopo_br):
"""Check GeoTIFF proces output as input data."""
with mapchete.open(cleantopo_br.path) as mp:
tp = BufferedTilePyramid("geodetic")
# TODO tile with existing but empty data
tile = tp.tile(5, 5, 5)
output_params = dict(type="geodetic",
format="GeoTIFF",
path=mp_tmpdir,
pixelbuffer=0,
metatiling=1,
bands=2,
dtype="int16")
output = gtiff.OutputData(output_params)
with output.open(tile, mp, resampling="nearest") as input_tile:
assert input_tile.resampling == "nearest"
for data in [
input_tile.read(),
input_tile.read(1),
input_tile.read([1]),
# TODO assert valid indexes are passed input_tile.read([1, 2])
]:
assert isinstance(data, ma.masked_array)
assert input_tile.is_empty()
# open without resampling
with output.open(tile, mp) as input_tile:
pass
def test_read_raster_window():
"""Read array with read_raster_window."""
dummy1 = os.path.join(TESTDATA_DIR, "dummy1.tif")
zoom = 8
config = MapcheteConfig(
os.path.join(SCRIPTDIR, "testdata/minmax_zoom.mapchete"))
rasterfile = config.at_zoom(7)["input"]["file1"]
dummy1_bbox = rasterfile.bbox()
pixelbuffer = 5
tile_pyramid = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
tiles = tile_pyramid.tiles_from_geom(dummy1_bbox, zoom)
width = height = tile_pyramid.tile_size + 2 * pixelbuffer
for tile in tiles:
for band in raster.read_raster_window(dummy1, tile):
assert isinstance(band, ma.MaskedArray)
assert band.shape == (width, height)
for index in range(4):
band = raster.read_raster_window(dummy1, tile, index).next()
assert isinstance(band, ma.MaskedArray)
assert band.shape == (width, height)
for resampling in [
"nearest", "bilinear", "cubic", "cubic_spline", "lanczos",
"average", "mode"
]:
raster.read_raster_window(dummy1, tile, resampling=resampling)
def test_extract_from_array():
"""Extract subdata from array."""
in_tile = BufferedTilePyramid("geodetic", metatiling=4).tile(5, 5, 5)
shape = (in_tile.shape[0] // 2, in_tile.shape[1])
data = ma.masked_array(np.concatenate([np.ones(shape),
np.ones(shape) * 2]))
# intersecting at top
out_tile = BufferedTilePyramid("geodetic").tile(5, 20, 20)
out_array = extract_from_array(in_raster=data,
in_affine=in_tile.affine,
out_tile=out_tile)
assert isinstance(out_array, np.ndarray)
assert np.all(np.where(out_array == 1, True, False))
# intersecting at bottom
out_tile = BufferedTilePyramid("geodetic").tile(5, 22, 20)
out_array = extract_from_array(in_raster=data,
in_affine=in_tile.affine,
out_tile=out_tile)
assert isinstance(out_array, np.ndarray)
assert np.all(np.where(out_array == 2, True, False))
# not intersecting
out_tile = BufferedTilePyramid("geodetic").tile(5, 15, 20)
with pytest.raises(ValueError):
out_array = extract_from_array(in_raster=data,
in_affine=in_tile.affine,
out_tile=out_tile)
def test_read_vector_window_errors(invalid_geojson):
with pytest.raises(FileNotFoundError):
read_vector_window("invalid_path",
BufferedTilePyramid("geodetic").tile(0, 0, 0))
with pytest.raises(MapcheteIOError):
read_vector_window(invalid_geojson,
BufferedTilePyramid("geodetic").tile(0, 0, 0))
def test_write_raster_window_memory():
"""Basic output format writing."""
path = "memoryfile"
# standard tile
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
data = ma.masked_array(np.ones((2, ) + tile.shape))
for out_profile in [
dict(
driver="GTiff", count=2, dtype="uint8", compress="lzw", nodata=0,
height=tile.height, width=tile.width, affine=tile.affine),
dict(
driver="GTiff", count=2, dtype="uint8", compress="deflate",
nodata=0, height=tile.height, width=tile.width,
affine=tile.affine),
dict(
driver="PNG", count=2, dtype="uint8", nodata=0, height=tile.height,
width=tile.width, compress=None, affine=tile.affine),
]:
memfile = write_raster_window(
in_tile=tile, in_data=data, out_profile=out_profile, out_path=path)
# with rasterio.open(memfile, 'r') as src:
with memfile.open() as src:
assert src.read().any()
assert src.meta["driver"] == out_profile["driver"]
assert src.transform == tile.affine
if out_profile["compress"]:
assert src.compression == Compression(
out_profile["compress"].upper())
memfile.close()
def test_output_data(mp_tmpdir):
"""Check PNG as output data."""
output_params = dict(grid="geodetic",
format="PNG",
path=mp_tmpdir,
pixelbuffer=0,
metatiling=1)
try:
output = png.OutputDataWriter(output_params)
assert output.path == mp_tmpdir
assert output.file_extension == ".png"
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
finally:
shutil.rmtree(mp_tmpdir, ignore_errors=True)
# get_path
try:
assert output.get_path(tile) == os.path.join(
*[mp_tmpdir, "5", "5", "5" + ".png"])
finally:
shutil.rmtree(mp_tmpdir, ignore_errors=True)
# prepare_path
try:
temp_dir = os.path.join(*[mp_tmpdir, "5", "5"])
output.prepare_path(tile)
assert os.path.isdir(temp_dir)
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# profile
assert isinstance(output.profile(tile), dict)
# write
try:
data = np.ones((1, ) + tile.shape) * 128
output.write(tile, data)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile)
assert isinstance(data, np.ndarray)
assert data.shape[0] == 4
assert not data[0].mask.any()
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# read empty
empty = output.read(tp.tile(5, 0, 0))
assert isinstance(empty, ma.MaskedArray)
assert not empty.any()
# write empty
output.write(tile, np.zeros((3, ) + tile.shape))
output.write(tile, np.zeros((4, ) + tile.shape))
with pytest.raises(TypeError):
output.write(tile, np.zeros((5, ) + tile.shape))
def test_output_data(mp_tmpdir):
"""Check GeoTIFF as output data."""
output_params = dict(type="geodetic",
format="GeoTIFF",
path=mp_tmpdir,
pixelbuffer=0,
metatiling=1,
bands=1,
dtype="int16")
output = gtiff.OutputData(output_params)
assert output.path == mp_tmpdir
assert output.file_extension == ".tif"
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
# get_path
assert output.get_path(tile) == os.path.join(
*[mp_tmpdir, "5", "5", "5" + ".tif"])
# prepare_path
try:
temp_dir = os.path.join(*[mp_tmpdir, "5", "5"])
output.prepare_path(tile)
assert os.path.isdir(temp_dir)
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# profile
assert isinstance(output.profile(tile), dict)
# write
try:
data = np.ones((1, ) + tile.shape) * 128
output.write(tile, data)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile)
assert isinstance(data, np.ndarray)
assert not data[0].mask.any()
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# read empty
data = output.read(tile)
assert isinstance(data, np.ndarray)
assert data[0].mask.all()
# empty
empty = output.empty(tile)
assert isinstance(empty, ma.MaskedArray)
assert not empty.any()
# deflate with predictor
output_params.update(compress="deflate", predictor=2)
output = gtiff.OutputData(output_params)
assert output.profile(tile)["compress"] == "deflate"
assert output.profile(tile)["predictor"] == 2
# using deprecated "compression" property
output_params.update(compression="deflate", predictor=2)
output = gtiff.OutputData(output_params)
assert output.profile(tile)["compress"] == "deflate"
assert output.profile(tile)["predictor"] == 2
def test_write_raster_window():
"""Basic output format writing."""
path = tempfile.NamedTemporaryFile(delete=False).name
# standard tile
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
data = ma.masked_array(np.ones((2, ) + tile.shape))
for out_profile in [
dict(
driver="GTiff", count=2, dtype="uint8", compress="lzw", nodata=0,
height=tile.height, width=tile.width, affine=tile.affine),
dict(
driver="GTiff", count=2, dtype="uint8", compress="deflate",
nodata=0, height=tile.height, width=tile.width,
affine=tile.affine),
dict(
driver="PNG", count=2, dtype="uint8", nodata=0, height=tile.height,
width=tile.width, compress=None, affine=tile.affine),
]:
try:
write_raster_window(
in_tile=tile, in_data=data, out_profile=out_profile,
out_path=path
)
with rasterio.open(path, 'r') as src:
assert src.read().any()
assert src.meta["driver"] == out_profile["driver"]
assert src.transform == tile.affine
if out_profile["compress"]:
assert src.compression == Compression(
out_profile["compress"].upper())
finally:
shutil.rmtree(path, ignore_errors=True)
# with metatiling
tile = BufferedTilePyramid("geodetic", metatiling=4).tile(5, 1, 1)
data = ma.masked_array(np.ones((2, ) + tile.shape))
out_tile = BufferedTilePyramid("geodetic").tile(5, 5, 5)
out_profile = dict(
driver="GTiff", count=2, dtype="uint8", compress="lzw", nodata=0,
height=out_tile.height, width=out_tile.width,
affine=out_tile.affine)
try:
write_raster_window(
in_tile=tile, in_data=data, out_profile=out_profile,
out_tile=out_tile, out_path=path
)
with rasterio.open(path, 'r') as src:
assert src.shape == out_tile.shape
assert src.read().any()
assert src.meta["driver"] == out_profile["driver"]
assert src.transform == out_profile["transform"]
finally:
shutil.rmtree(path, ignore_errors=True)
def test_create_mosaic_errors():
"""Check error handling of create_mosaic()."""
tp_geo = BufferedTilePyramid("geodetic")
tp_mer = BufferedTilePyramid("mercator")
geo_tile = tp_geo.tile(1, 0, 0)
geo_tile_data = np.ndarray(geo_tile.shape)
mer_tile = tp_mer.tile(1, 1, 0)
mer_tile_data = np.ndarray(mer_tile.shape)
# tiles error
with pytest.raises(TypeError):
create_mosaic("invalid tiles")
with pytest.raises(TypeError):
create_mosaic(["invalid tiles"])
# CRS error
with pytest.raises(ValueError):
create_mosaic([(geo_tile, geo_tile_data), (mer_tile, mer_tile_data)])
# zoom error
with pytest.raises(ValueError):
diff_zoom = tp_geo.tile(2, 1, 0)
diff_zoom_data = np.ndarray(diff_zoom.shape)
create_mosaic([(geo_tile, geo_tile_data), (diff_zoom, diff_zoom_data)])
# tile data error
with pytest.raises(TypeError):
# for one tile
create_mosaic([(geo_tile, None)])
with pytest.raises(TypeError):
# for multiple tiles
create_mosaic([(geo_tile, None), (geo_tile, None)])
# tile data type error
with pytest.raises(TypeError):
diff_type = tp_geo.tile(1, 1, 0)
diff_type_data = np.ndarray(diff_zoom.shape).astype("int")
create_mosaic([(geo_tile, geo_tile_data), (diff_type, diff_type_data)])
def test_create_mosaic_errors():
"""Check error handling of create_mosaic()."""
tp_geo = BufferedTilePyramid("geodetic")
tp_mer = BufferedTilePyramid("mercator")
geo_tile = tp_geo.tile(1, 0, 0)
geo_tile.data = np.ndarray(geo_tile.shape)
mer_tile = tp_mer.tile(1, 1, 0)
mer_tile.data = np.ndarray(mer_tile.shape)
# CRS error
with pytest.raises(ValueError):
raster.create_mosaic([geo_tile, mer_tile])
# zoom error
with pytest.raises(ValueError):
diff_zoom = tp_geo.tile(2, 1, 0)
diff_zoom.data = np.ndarray(diff_zoom.shape)
raster.create_mosaic([geo_tile, diff_zoom])
# tile data error
with pytest.raises(TypeError):
geo_tile.data = None
# for one tile
raster.create_mosaic([geo_tile])
with pytest.raises(TypeError):
geo_tile.data = None
# for multiple tiles
raster.create_mosaic([geo_tile, geo_tile])
# tile data type error
with pytest.raises(TypeError):
geo_tile.data = np.ndarray(geo_tile.shape)
diff_type = tp_geo.tile(1, 1, 0)
diff_type.data = np.ndarray(diff_zoom.shape).astype("int")
raster.create_mosaic([geo_tile, diff_type])
def test_resample_from_array():
"""Resample array using rasterio reproject()."""
in_tile = BufferedTilePyramid("geodetic").tile(5, 5, 5)
in_data = np.ones(in_tile.shape)
# tile from next toom level
out_tile = BufferedTilePyramid("geodetic").tile(6, 10, 10)
out_array = raster.resample_from_array(in_data, in_tile.affine, out_tile)
assert isinstance(out_array, ma.masked_array)
assert np.all(np.where(out_array == 1, True, False))
# not intersecting tile
out_tile = BufferedTilePyramid("geodetic").tile(7, 0, 0)
out_array = raster.resample_from_array(in_data, in_tile.affine, out_tile)
assert isinstance(out_array, ma.masked_array)
assert out_array.mask.all()
def test_snap_bounds_to_zoom():
bounds = (-180, -90, -60, -30)
for pixelbuffer in [0, 5, 10]:
for metatiling in [1, 2, 4]:
pyramid = BufferedTilePyramid("geodetic",
pixelbuffer=pixelbuffer,
metatiling=metatiling)
for zoom in range(3, 5):
snapped_bounds = mapchete.config.snap_bounds(bounds=bounds,
pyramid=pyramid,
zoom=zoom)
control_bounds = unary_union([
t.bbox for t in pyramid.tiles_from_bounds(bounds, zoom)
]).bounds
assert snapped_bounds == control_bounds
def test_read_vector_window():
"""Read vector data from read_vector_window."""
zoom = 4
config = MapcheteConfig(
os.path.join(SCRIPTDIR, "testdata/geojson.mapchete"))
vectorfile = config.at_zoom(zoom)["input"]["file1"]
pixelbuffer = 5
tile_pyramid = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
tiles = tile_pyramid.tiles_from_geom(vectorfile.bbox(), zoom)
feature_count = 0
for tile in tiles:
for feature in vector.read_vector_window(vectorfile.path, tile):
assert "properties" in feature
assert shape(feature["geometry"]).is_valid
feature_count += 1
assert feature_count
def test_read_raster_window_mask(s2_band):
"""No resampling artefacts on mask edges."""
tile = BufferedTilePyramid("geodetic").tile(zoom=13, row=1918, col=8905)
data = read_raster_window(
s2_band, tile, resampling="cubic", src_nodata=0, dst_nodata=0)
assert data.any()
assert not np.where(data == 1, True, False).any()
def write_output_metadata(output_params):
"""Dump output JSON and verify parameters if output metadata exist."""
if "path" in output_params:
metadata_path = os.path.join(output_params["path"], "metadata.json")
logger.debug("check for output %s", metadata_path)
try:
existing_params = read_output_metadata(metadata_path)
logger.debug("%s exists", metadata_path)
logger.debug("existing output parameters: %s",
pformat(existing_params))
existing_tp = existing_params["pyramid"]
current_params = params_to_dump(output_params)
logger.debug("current output parameters: %s",
pformat(current_params))
current_tp = BufferedTilePyramid(**current_params["pyramid"])
if existing_tp != current_tp: # pragma: no cover
raise MapcheteConfigError(
"pyramid definitions between existing and new output do not match: "
"%s != %s" % (existing_tp, current_tp))
existing_format = existing_params["driver"]["format"]
current_format = current_params["driver"]["format"]
if existing_format != current_format: # pragma: no cover
raise MapcheteConfigError(
"existing output format does not match new output format: "
"%s != %s" % ((existing_format, current_format)))
except FileNotFoundError:
logger.debug("%s does not exist", metadata_path)
dump_params = params_to_dump(output_params)
# dump output metadata
write_json(metadata_path, dump_params)
def test_process_tile_open(example_mapchete):
"""Raise ValueError on MapcheteProcess.open()."""
config = MapcheteConfig(example_mapchete.path)
tile = BufferedTilePyramid("mercator").tile(7, 1, 1)
process_tile = mapchete.MapcheteProcess(tile, config)
with pytest.raises(ValueError):
process_tile.open("nonexisting_id")
def read_output_metadata(metadata_json, **kwargs):
params = read_json(metadata_json, **kwargs)
grid = params["pyramid"]["grid"]
if grid["type"] == "geodetic" and grid["shape"] == [2, 1
]: # pragma: no cover
warnings.warn(
DeprecationWarning(
"Deprecated grid shape ordering found. "
"Please change grid shape from [2, 1] to [1, 2] in %s." %
metadata_json))
params["pyramid"]["grid"]["shape"] = [1, 2]
if "crs" in grid and isinstance(grid["crs"], str):
crs = CRS.from_string(grid["crs"])
warnings.warn(
DeprecationWarning(
"Deprecated 'srs' found in %s: '%s'. "
"Use WKT representation instead: %s" %
(metadata_json, grid["crs"], pformat(dict(wkt=crs.to_wkt())))))
params["pyramid"]["grid"].update(srs=dict(wkt=crs.to_wkt()))
params.update(pyramid=BufferedTilePyramid(
params["pyramid"]["grid"],
metatiling=params["pyramid"].get("metatiling", 1),
tile_size=params["pyramid"].get("tile_size", 256),
pixelbuffer=params["pyramid"].get("pixelbuffer", 0)))
return params
def test_process_tile_write(example_mapchete):
"""Raise DeprecationWarning on MapcheteProcess.write()."""
config = MapcheteConfig(example_mapchete.path)
tile = BufferedTilePyramid("mercator").tile(7, 1, 1)
process_tile = mapchete.MapcheteProcess(tile, config)
with pytest.raises(DeprecationWarning):
process_tile.write("data")
def baselevels(self):
"""
Optional baselevels configuration.
baselevels:
min: <zoom>
max: <zoom>
lower: <resampling method>
higher: <resampling method>
"""
if "baselevels" not in self._raw:
return {}
baselevels = self._raw["baselevels"]
minmax = {
k: v for k, v in six.iteritems(baselevels) if k in ["min", "max"]}
if not minmax:
raise MapcheteConfigError(
"no min and max values given for baselevels")
for v in minmax.values():
if not isinstance(v, int) or v < 0:
raise MapcheteConfigError(
"invalid baselevel zoom parameter given: %s" % (
minmax.values()))
return dict(
zooms=range(
minmax.get("min", min(self.zoom_levels)),
minmax.get("max", max(self.zoom_levels)) + 1),
lower=baselevels.get("lower", "nearest"),
higher=baselevels.get("higher", "nearest"),
tile_pyramid=BufferedTilePyramid(
self.output_pyramid.grid,
pixelbuffer=self.output_pyramid.pixelbuffer,
metatiling=self.process_pyramid.metatiling))
def __init__(self,
input_config,
zoom=None,
bounds=None,
single_input_file=None,
mode="continue",
debug=False):
"""Initialize configuration."""
LOGGER.info("preparing configuration ...")
if debug:
LOGGER.setLevel(logging.DEBUG)
if mode not in ["memory", "readonly", "continue", "overwrite"]:
raise MapcheteConfigError("invalid process mode")
LOGGER.debug("zooms provided to config: %s" % zoom)
self.mode = mode
# parse configuration
LOGGER.debug("parse configuration ...")
self._input_cache = {}
self._process_area_cache = {}
self.raw, self.mapchete_file, self.config_dir = self._parse_config(
input_config, single_input_file=single_input_file)
if not self.process_file:
raise MapcheteConfigError("no process_file given")
# set process delimiters
self._delimiters = dict(zoom=zoom, bounds=bounds)
# helper caches
self._at_zoom_cache = {}
self._global_process_area = None
# other properties
try:
self.output_type = self.raw["output"]["type"]
except KeyError:
raise MapcheteConfigError("no output type given")
if self.raw["output"]["type"] not in TILING_TYPES:
raise MapcheteConfigError("output type is missing: %s" %
PYRAMID_PARAMS.keys())
self.process_pyramid = BufferedTilePyramid(
self.output_type,
metatiling=self.metatiling,
pixelbuffer=self.pixelbuffer)
self.output_pyramid = BufferedTilePyramid(
self.output_type,
metatiling=self.raw["output"]["metatiling"],
pixelbuffer=self.raw["output"]["pixelbuffer"])
self.crs = self.process_pyramid.crs
LOGGER.debug("validate ...")
self._validate()
def test_create_mosaic_antimeridian():
"""Create mosaic using tiles on opposing antimeridian sides."""
zoom = 5
row = 0
pixelbuffer = 5
tp = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
west = tp.tile(zoom, row, 0)
east = tp.tile(zoom, row, tp.matrix_width(zoom) - 1)
for tile in [west, east]:
tile.data = np.ones(tile.shape)
mosaic = raster.create_mosaic([west, east])
assert isinstance(mosaic, raster.ReferencedRaster)
# Huge array gets initialized because the two tiles are on opposing sides
# of the projection area. The below test should pass if the tiles are
# stitched together next to each other.
assert mosaic.data.shape == (1, west.height,
west.width * 2 - 2 * pixelbuffer)
def test_read_raster_window_resampling(cleantopo_br_tif):
"""Assert various resampling options work."""
tp = BufferedTilePyramid("geodetic")
with rasterio.open(cleantopo_br_tif, "r") as src:
tiles = tp.tiles_from_bounds(src.bounds, 4)
for tile in tiles:
outputs = [
read_raster_window(cleantopo_br_tif, tile, resampling=resampling)
for resampling in [
"nearest", "bilinear", "cubic", "cubic_spline", "lanczos",
"average", "mode"
]
]
# resampling test:
assert any([
not np.array_equal(w, v) for v, w in zip(outputs[:-1], outputs[1:])
])
