def test_read_raster_window_reproject(dummy1_3857_tif, minmax_zoom):
"""Read array with read_raster_window."""
zoom = 8
# with reproject
config_raw = minmax_zoom.dict
config_raw["input"].update(file1=dummy1_3857_tif)
config = MapcheteConfig(config_raw)
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))
# target window out of CRS bounds
band = read_raster_window(dummy1_3857_tif, tile_pyramid.tile(12, 0, 0))
assert isinstance(band, ma.MaskedArray)
assert band.mask.all()
# not intersecting tile
tiles.append(tile_pyramid.tile(zoom, 1, 1)) # out of CRS bounds
tiles.append(tile_pyramid.tile(zoom, 16, 1)) # out of file bbox
for tile in tiles:
for band in read_raster_window(dummy1_3857_tif, tile):
assert isinstance(band, ma.MaskedArray)
assert band.shape == tile.shape
bands = read_raster_window(dummy1_3857_tif, tile, [1])
assert isinstance(bands, ma.MaskedArray)
assert bands.shape == tile.shape
# errors
with pytest.raises(IOError):
read_raster_window("nonexisting_path", tile)
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():
"""Create mosaic from tiles."""
tp = BufferedTilePyramid("geodetic")
# quick return mosaic if there is just one tile
tile = tp.tile(3, 3, 3)
data = np.ones(tile.shape)
mosaic = create_mosaic([(tile, data)])
assert isinstance(mosaic, ReferencedRaster)
assert np.array_equal(data, mosaic.data)
assert tile.affine == mosaic.affine
# multiple tiles
for pixelbuffer in [0, 10]:
tp = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
tiles = [(tp.tile(5, row, col), np.ones(tp.tile(5, row, col).shape))
for row, col in product(range(4), range(4))]
# 4x4 top left tiles from zoom 5 equal top left tile from zoom 3
# also use tile generator
mosaic = create_mosaic((t for t in tiles))
assert isinstance(mosaic, ReferencedRaster)
assert np.all(np.where(mosaic.data == 1, True, False))
mosaic_bbox = box(
mosaic.affine[2],
mosaic.affine[5] + mosaic.data.shape[1] * mosaic.affine[4],
mosaic.affine[2] + mosaic.data.shape[2] * mosaic.affine[0],
mosaic.affine[5])
control_bbox = box(*unary_union([t.bbox for t, _ in tiles]).bounds)
assert mosaic_bbox.equals(control_bbox)
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_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_bufferedtiles():
tp = BufferedTilePyramid("geodetic")
a = tp.tile(5, 5, 5)
b = tp.tile(5, 5, 5)
c = tp.tile(5, 5, 6)
assert a == b
assert a != c
assert b != c
assert a != "invalid type"
assert len(set([a, b, c])) == 2
tp_buffered = BufferedTilePyramid("geodetic", pixelbuffer=10)
assert a != tp_buffered.tile(5, 5, 5)
assert a.get_neighbors() != a.get_neighbors(connectedness=4)
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_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_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_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_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_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_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_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_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_shift_required():
zoom = 11
row = 711
tp = BufferedTilePyramid("mercator")
tiles = [(tp.tile(zoom, row, i), None) for i in range(1, 5)]
# all tiles are connected without passing the Antimeridian, so no shift is required
assert not _shift_required(tiles)
# add one tile connected on the other side of the Antimeridian and a shift is required
tiles.append((tp.tile(zoom, row, tp.matrix_width(zoom) - 1), None))
assert _shift_required(tiles)
# leave one column and add one tile
tiles = [(tp.tile(zoom, row, i), None) for i in range(2, 5)]
tiles.append((tp.tile(zoom, row, 6), None))
tiles.append((tp.tile(zoom, row, 8), None))
tiles.append((tp.tile(zoom, row, 9), None))
assert not _shift_required(tiles)
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_output_data():
"""Check PNG as output data."""
output_params = dict(type="geodetic",
format="PNG",
path=OUT_DIR,
pixelbuffer=0,
metatiling=1)
output = png.OutputData(output_params)
assert output.path == OUT_DIR
assert output.file_extension == ".png"
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
# get_path
assert output.get_path(tile) == os.path.join(
*[OUT_DIR, "5", "5", "5" + ".png"])
# prepare_path
try:
temp_dir = os.path.join(*[OUT_DIR, "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:
tile.data = np.ones((1, ) + tile.shape) * 128
output.write(tile)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile).data
assert isinstance(data, np.ndarray)
assert data.shape[0] == 4
assert not data[0].mask.any()
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# empty
empty = output.empty(tile)
assert isinstance(empty, ma.MaskedArray)
assert not empty.any()
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),
]:
with pytest.raises(DeprecationWarning):
write_raster_window(
in_tile=tile, in_data=data, out_profile=out_profile, out_path=path)
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)
mosaic = create_mosaic([(west, np.ones(west.shape).astype("uint8")),
(east, np.ones(east.shape).astype("uint8") * 2)])
assert isinstance(mosaic, 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)
assert mosaic.data[0][0][0] == 2
assert mosaic.data[0][0][-1] == 1
# If tiles from opposing sides from Antimeridian are mosaicked it will happen that the
# output mosaic exceeds the CRS bounds (obviously). In such a case the mosaicking
# function shall make sure that the larger part of the output mosaic shall be inside
# the CRS bounds.
# (1) mosaic crosses Antimeridian in the West, larger part is on Western hemisphere:
tiles_ids = [
# Western hemisphere tiles
(zoom, row, 0),
(zoom, row, 1),
# Eastern hemisphere tile
(zoom, row, tp.matrix_width(zoom) - 1),
]
tiles = [(tp.tile(*tile_id), np.ones(tp.tile(*tile_id).shape))
for tile_id in tiles_ids]
mosaic = create_mosaic(tiles)
control_bounds = Bounds(
# Eastern tile has to be shifted
-(360 - tp.tile(*tiles_ids[2]).left),
tp.tile(*tiles_ids[2]).bottom,
tp.tile(*tiles_ids[1]).right,
tp.tile(*tiles_ids[1]).top,
)
assert mosaic.bounds == control_bounds
# (2) mosaic crosses Antimeridian in the West, larger part is on Eastern hemisphere:
tiles_ids = [
# Western hemisphere tile
(zoom, row, 0),
# Eastern hemisphere tiles
(zoom, row, tp.matrix_width(zoom) - 1),
(zoom, row, tp.matrix_width(zoom) - 2),
]
tiles = [(tp.tile(*tile_id), np.ones(tp.tile(*tile_id).shape))
for tile_id in tiles_ids]
mosaic = create_mosaic(tiles)
control_bounds = Bounds(
tp.tile(*tiles_ids[2]).left,
tp.tile(*tiles_ids[2]).bottom,
# Western tile has to be shifted
360 + tp.tile(*tiles_ids[0]).right,
tp.tile(*tiles_ids[0]).top,
)
assert mosaic.bounds == control_bounds
def test_output_data():
"""Check PNG_hillshade as output data."""
output_params = dict(
type="geodetic",
format="PNG_hillshade",
path=OUT_DIR,
pixelbuffer=0,
metatiling=1
)
output = png_hillshade.OutputData(output_params)
assert output.path == OUT_DIR
assert output.file_extension == ".png"
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
# get_path
assert output.get_path(tile) == os.path.join(*[
OUT_DIR, "5", "5", "5"+".png"])
# prepare_path
try:
temp_dir = os.path.join(*[OUT_DIR, "5", "5"])
output.prepare_path(tile)
assert os.path.isdir(temp_dir)
# create again to ensure, no OSError is being thrown
output.prepare_path(tile)
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# profile
assert isinstance(output.profile(tile), dict)
# write full array
try:
tile.data = np.ones(tile.shape)*128
output.write(tile)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile).data
assert isinstance(data, np.ndarray)
assert not data.mask.any()
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# write half masked array
try:
half_shape = (tile.shape[0], tile.shape[1]/2)
tile.data = ma.masked_array(
data=np.ones(tile.shape)*128,
mask=np.concatenate(
[np.zeros(half_shape), np.ones(half_shape)], axis=1))
output.write(tile)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile).data
assert isinstance(data, np.ndarray)
assert not data.mask.all()
assert data.mask.any()
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# old_band_num
output_params.update(old_band_num=True)
output = png_hillshade.OutputData(output_params)
tp = BufferedTilePyramid("geodetic")
tile = tp.tile(5, 5, 5)
try:
tile.data = np.ones(tile.shape)*128
output.write(tile)
# tiles_exist
assert output.tiles_exist(tile)
# read
data = output.read(tile).data
assert isinstance(data, np.ndarray)
assert not data.mask.any()
finally:
shutil.rmtree(temp_dir, ignore_errors=True)
# empty
empty = output.empty(tile)
assert isinstance(empty, ma.MaskedArray)
assert not empty.any()
# read non-existing file
data = output.read(tile).data
assert data.mask.all()
def test_tile_to_zoom_level():
tp_merc = BufferedTilePyramid("mercator")
tp_geod = BufferedTilePyramid("geodetic")
zoom = 9
col = 0
# mercator from geodetic
# at Northern boundary
assert tile_to_zoom_level(tp_merc.tile(zoom, 0, col), tp_geod) == 9
assert tile_to_zoom_level(tp_merc.tile(zoom, 0, col),
tp_geod,
matching_method="min") == 12
# at Equator
assert tile_to_zoom_level(
tp_merc.tile(zoom,
tp_merc.matrix_height(zoom) // 2, col), tp_geod) == 9
assert tile_to_zoom_level(tp_merc.tile(zoom,
tp_merc.matrix_height(zoom) // 2,
col),
tp_geod,
matching_method="min") == 9
# at Southern boundary
assert tile_to_zoom_level(
tp_merc.tile(zoom,
tp_merc.matrix_height(zoom) - 1, col), tp_geod) == 9
assert tile_to_zoom_level(tp_merc.tile(zoom,
tp_merc.matrix_height(zoom) - 1,
col),
tp_geod,
matching_method="min") == 12
assert tile_to_zoom_level(BufferedTilePyramid("mercator",
metatiling=2,
pixelbuffer=20).tile(
4, 0, 7),
BufferedTilePyramid("geodetic",
metatiling=8,
pixelbuffer=20),
matching_method="gdal") == 4
# geodetic from mercator
# at Northern boundary
assert tile_to_zoom_level(tp_geod.tile(zoom, 0, col), tp_merc) == 2
with pytest.raises(TopologicalError):
tile_to_zoom_level(tp_geod.tile(zoom, 0, col),
tp_merc,
matching_method="min")
# at Equator
assert tile_to_zoom_level(
tp_geod.tile(zoom,
tp_geod.matrix_height(zoom) // 2, col), tp_merc) == 10
assert tile_to_zoom_level(tp_geod.tile(zoom,
tp_geod.matrix_height(zoom) // 2,
col),
tp_merc,
matching_method="min") == 10
# at Southern boundary
assert tile_to_zoom_level(
tp_geod.tile(zoom,
tp_geod.matrix_height(zoom) - 1, col), tp_merc) == 2
with pytest.raises(TopologicalError):
tile_to_zoom_level(tp_geod.tile(zoom,
tp_geod.matrix_height(zoom) - 1, col),
tp_merc,
matching_method="min")
# check wrong method
with pytest.raises(ValueError):
tile_to_zoom_level(tp_geod.tile(zoom,
tp_geod.matrix_height(zoom) - 1, col),
tp_merc,
matching_method="invalid_method")
