def test_example_process(cleantopo_tl):
with mapchete.open(cleantopo_tl.path) as mp:
zoom = max(mp.config.zoom_levels)
# tile containing data
tile = next(mp.get_process_tiles(zoom))
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
output = example_process.execute(user_process)
assert isinstance(output, ma.masked_array)
# empty tile
tile = mp.config.process_pyramid.tile(
zoom,
mp.config.process_pyramid.matrix_height(zoom) - 1,
mp.config.process_pyramid.matrix_width(zoom) - 1,
)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
output = example_process.execute(user_process)
assert output == "empty"
def test_convert_raster(cleantopo_tl, cleantopo_tl_tif, landpoly):
with mapchete.open(
dict(cleantopo_tl.dict, input=dict(inp=cleantopo_tl_tif))) as mp:
zoom = max(mp.config.zoom_levels)
# execute without clip
tile = next(mp.get_process_tiles(zoom))
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
assert isinstance(convert.execute(user_process), np.ndarray)
# execute on empty tile
tile = mp.config.process_pyramid.tile(
zoom,
mp.config.process_pyramid.matrix_height(zoom) - 1,
mp.config.process_pyramid.matrix_width(zoom) - 1)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
assert convert.execute(user_process) == "empty"
with mapchete.open(
dict(cleantopo_tl.dict,
input=dict(inp=cleantopo_tl_tif, clip=landpoly))) as mp:
zoom = max(mp.config.zoom_levels)
tile = next(mp.get_process_tiles(zoom))
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
# tile with data
default = convert.execute(user_process)
assert isinstance(default, np.ndarray)
# scale_offset
offset = convert.execute(user_process, scale_offset=2)
assert isinstance(offset, np.ndarray)
# scale_ratio
ratio = convert.execute(user_process, scale_ratio=0.5)
assert isinstance(ratio, np.ndarray)
# clip_to_output_dtype
clip_dtype = convert.execute(user_process,
scale_ratio=2,
clip_to_output_dtype="uint8")
assert isinstance(clip_dtype, np.ndarray)
# execute on empty tile
tile = mp.config.process_pyramid.tile(
zoom,
mp.config.process_pyramid.matrix_height(zoom) - 1,
mp.config.process_pyramid.matrix_width(zoom) - 1)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
assert convert.execute(user_process) == "empty"
def test_tilify(cleantopo_tl, cleantopo_tl_tif):
with mapchete.open(
dict(cleantopo_tl.dict, input=dict(raster=cleantopo_tl_tif))
) as mp:
zoom = max(mp.config.zoom_levels)
# tile containing data
process_tile = next(mp.get_process_tiles(zoom))
tile_process = mapchete.MapcheteProcess(
process_tile, mp.config, mp.config.params_at_zoom(zoom)
)
# no scaling
not_scaled = tilify.execute(tile_process)
assert isinstance(not_scaled, ma.masked_array)
# dtype_scale
dtype_scaled = tilify.execute(
tile_process, scale_method="dtype_scale", scales_minmax=((0, 10000), )
)
assert isinstance(dtype_scaled, ma.masked_array)
assert not np.array_equal(not_scaled, dtype_scaled)
assert dtype_scaled.min() == 167
assert dtype_scaled.max() == 247
# minmax_scale
with rasterio.open(cleantopo_tl_tif) as src:
data_minmax = tuple((band.min(), band.max()) for band in src.read())
minmax_scaled = tilify.execute(
tile_process, scale_method="minmax_scale", scales_minmax=data_minmax
)
assert isinstance(minmax_scaled, ma.masked_array)
assert minmax_scaled.min() == 0
assert minmax_scaled.max() == 255
# crop
cropped = tilify.execute(
tile_process, scale_method="crop", scales_minmax=((7000, 8000), )
)
assert isinstance(cropped, ma.masked_array)
assert cropped.min() == 7000
assert cropped.max() == 8000
# empty tile
process_tile = mp.config.process_pyramid.tile(
zoom,
mp.config.process_pyramid.matrix_height(zoom) - 1,
mp.config.process_pyramid.matrix_width(zoom) - 1,
)
tile_process = mapchete.MapcheteProcess(
process_tile, mp.config, mp.config.params_at_zoom(zoom)
)
output = tilify.execute(tile_process)
assert output == "empty"
def test_contours(cleantopo_tl, cleantopo_tl_tif, landpoly):
with mapchete.open(
dict(cleantopo_tl.dict, input=dict(dem=cleantopo_tl_tif))) as mp:
zoom = max(mp.config.zoom_levels)
# execute without clip
tile = next(mp.get_process_tiles(zoom))
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
output = contours.execute(user_process)
assert isinstance(output, list)
assert output
# execute on empty tile
tile = mp.config.process_pyramid.tile(
zoom,
mp.config.process_pyramid.matrix_height(zoom) - 1,
mp.config.process_pyramid.matrix_width(zoom) - 1)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
assert contours.execute(user_process) == "empty"
with mapchete.open(
dict(cleantopo_tl.dict,
input=dict(dem=cleantopo_tl_tif, clip=landpoly))) as mp:
zoom = max(mp.config.zoom_levels)
tile = next(mp.get_process_tiles(zoom))
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
output = contours.execute(user_process)
assert isinstance(output, list)
assert output
# execute on empty tile
tile = mp.config.process_pyramid.tile(
zoom,
mp.config.process_pyramid.matrix_height(zoom) - 1,
mp.config.process_pyramid.matrix_width(zoom) - 1)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
assert contours.execute(user_process) == "empty"
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 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 test_process_tile_read(example_mapchete):
"""Raise ValueError on MapcheteProcess.open()."""
config = MapcheteConfig(example_mapchete.path)
tile = BufferedTilePyramid("mercator").tile(7, 1, 1)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=config.params_at_zoom(tile.zoom),
input=config.get_inputs_for_tile(tile),
)
with pytest.raises(DeprecationWarning):
user_process.read()
def test_read_from_raster_file(cleantopo_br):
"""Read different bands from source raster."""
with mapchete.open(cleantopo_br.path) as mp:
tile = mp.config.process_pyramid.tile(5, 0, 0)
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
with user_process.open("file1") as f:
assert f.read().shape == f.read([1]).shape == f.read(1).shape
def test_open_data_error(cleantopo_tl):
"""Try to open data not specified as input."""
with mapchete.open(cleantopo_tl.path) as mp:
tile = mp.config.process_pyramid.tile(5, 0, 0)
# read written data from within MapcheteProcess object
user_process = mapchete.MapcheteProcess(
tile=tile,
config=mp.config,
)
with pytest.raises(ValueError):
user_process.open("invaild_input_id")
def test_open_data_error(cleantopo_tl):
"""Try to open data not specified as input."""
tile = (5, 0, 0)
with mapchete.open(cleantopo_tl.path) as mp:
# read written data from within MapcheteProcess object
mp_tile = mapchete.MapcheteProcess(
mp.config.process_pyramid.tile(*tile),
config=mp.config,
params=mp.config.params_at_zoom(5))
with pytest.raises(ValueError):
mp_tile.open("invaild_input_id")
def test_read_input_order(file_groups):
"""Assert input objects are represented in the same order as configured."""
with mapchete.open(file_groups.path) as mp:
inputs = yaml.load(open(file_groups.path).read())["input"]
tile = mp.config.process_pyramid.tile(0, 0, 0)
# read written data from within MapcheteProcess object
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
assert inputs.keys() == user_process.input.keys()
def test_custom_grid(mp_tmpdir, custom_grid):
"""Cutom grid processing."""
# process and save
with mapchete.open(custom_grid.dict) as mp:
mp.batch_process()
# read written output
with mapchete.open(custom_grid.dict, mode="readonly") as mp:
for tile in mp.get_process_tiles(5):
mp_tile = mapchete.MapcheteProcess(
tile, config=mp.config, params=mp.config.params_at_zoom(5))
data = mp_tile.read()
assert data.any()
assert isinstance(data, ma.masked_array)
assert not data.mask.all()
def test_read_existing_output_vector(mp_tmpdir, geojson):
"""Read existing process output with process buffer."""
with mapchete.open(geojson.path) as mp:
tile = next(mp.get_process_tiles(4))
# process and save
mp.write(tile, mp.get_raw_output(tile))
# read written data from within MapcheteProcess object
mp_tile = mapchete.MapcheteProcess(tile,
config=mp.config,
params=mp.config.params_at_zoom(4))
data = mp_tile.read()
assert data
for feature in data:
assert shape(feature["geometry"]).is_valid
def test_http_rasters(files_bounds, http_raster):
"""Raster file on remote server with http:// or https:// URLs."""
zoom = 13
config = files_bounds.dict
config.update(input=dict(file1=http_raster), zoom_levels=zoom)
# TODO make tests more performant
with mapchete.open(config) as mp:
assert mp.config.area_at_zoom(zoom).area > 0
tile = next(mp.get_process_tiles(13))
user_process = mapchete.MapcheteProcess(
tile=tile,
params=mp.config.params_at_zoom(tile.zoom),
input=mp.config.get_inputs_for_tile(tile),
)
with user_process.open("file1") as f:
assert f.read().any()
def test_read_existing_output_buffer(mp_tmpdir, cleantopo_tl):
"""Read existing process output with process buffer."""
# raster data process buffer > output buffer
config = cleantopo_tl.dict
config["output"].update(pixelbuffer=0)
with mapchete.open(config) as mp:
tile = next(mp.get_process_tiles(5))
# process and save
mp.get_raw_output(tile)
# read written data from within MapcheteProcess object
mp_tile = mapchete.MapcheteProcess(
mp.config.process_pyramid.tile(*tile.id),
config=mp.config,
params=mp.config.params_at_zoom(5))
data = mp_tile.read()
assert data.any()
assert isinstance(data, ma.masked_array)
assert not data.mask.all()
def test_read_existing_output(mp_tmpdir, cleantopo_tl):
"""Read existing process output."""
# raster data
tile = (5, 0, 0)
with mapchete.open(cleantopo_tl.path) as mp:
# process and save
mp.get_raw_output(tile)
# read written data from within MapcheteProcess object
mp_tile = mapchete.MapcheteProcess(
mp.config.process_pyramid.tile(*tile),
config=mp.config,
params=mp.config.params_at_zoom(5))
data = mp_tile.read()
assert data.any()
assert isinstance(data, ma.masked_array)
assert not data.mask.all()
# read data from Mapchete class
data = mp.read(tile)
assert data.any()
assert isinstance(data, ma.masked_array)
assert not data.mask.all()
