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:]) ])