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")