def write(self, process_tile):
"""
Write data from process tiles into PNG file(s).
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
data = prepare_array(process_tile.data,
dtype="uint8",
masked=False,
nodata=0)
if self.old_band_num:
data = np.stack(
(np.zeros(process_tile.shape), np.zeros(process_tile.shape),
np.zeros(process_tile.shape), data[0]))
else:
data = np.stack((np.zeros(process_tile.shape), data[0]))
process_tile.data = prepare_array(data,
dtype="uint8",
masked=True,
nodata=255)
# Convert from process_tile to output_tiles
for tile in self.pyramid.intersecting(process_tile):
# skip if file exists and overwrite is not set
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(in_tile=process_tile,
out_profile=self.profile(out_tile),
out_tile=out_tile,
out_path=out_path)
def write(self, process_tile):
"""
Write data from process tiles into GeoTIFF file(s).
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
process_tile.data = prepare_array(
process_tile.data,
masked=True,
nodata=self.nodata,
dtype=self.profile(process_tile)["dtype"])
if process_tile.data.mask.all():
return
# Convert from process_tile to output_tiles
for tile in self.pyramid.intersecting(process_tile):
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(in_tile=process_tile,
out_profile=self.profile(out_tile),
out_tile=out_tile,
out_path=out_path)
def write(self, process_tile, data):
"""
Write data from process tiles into GeoTIFF file(s).
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
if (
isinstance(data, tuple) and
len(data) == 2 and
isinstance(data[1], dict)
):
data, tags = data
else:
tags = {}
data = prepare_array(
data, masked=True, nodata=self.nodata,
dtype=self.profile(process_tile)["dtype"])
if data.mask.all():
return
# Convert from process_tile to output_tiles
for tile in self.pyramid.intersecting(process_tile):
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(
in_tile=process_tile, in_data=data,
out_profile=self.profile(out_tile), out_tile=out_tile,
out_path=out_path, tags=tags)
def write(self, process_tile, data):
"""
Write data from process tiles into PNG file(s).
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
data = self._prepare_array(data)
if data.mask.all(): # pragma: no cover
logger.debug("data empty, nothing to write")
else:
# in case of S3 output, create an boto3 resource
bucket_resource = get_boto3_bucket(
self._bucket) if self._bucket else None
# Convert from process_tile to output_tiles and write
for tile in self.pyramid.intersecting(process_tile):
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(in_tile=process_tile,
in_data=data,
out_profile=self.profile(out_tile),
out_tile=out_tile,
out_path=out_path,
bucket_resource=bucket_resource)
def write(self, process_tile, data):
"""
Write data from one or more process tiles.
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
rgba = self._prepare_array_for_png(data)
data = ma.masked_where(rgba == self.nodata, rgba)
if data.mask.all():
logger.debug("data empty, nothing to write")
else:
# in case of S3 output, create an boto3 resource
bucket_resource = (
boto3.resource('s3').Bucket(self._bucket)
if self._bucket
else None
)
# Convert from process_tile to output_tiles and write
for tile in self.pyramid.intersecting(process_tile):
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(
in_tile=process_tile,
in_data=data,
out_profile=self.profile(out_tile),
out_tile=out_tile,
out_path=out_path,
bucket_resource=bucket_resource
)
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_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 write(self, process_tile, data):
"""
Write data from process tiles into GeoTIFF file(s).
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
data : ``np.ndarray``
"""
if (
isinstance(data, tuple) and
len(data) == 2 and
isinstance(data[1], dict)
):
data, tags = data
else:
tags = {}
data = prepare_array(
data,
masked=True,
nodata=self.output_params["nodata"],
dtype=self.profile(process_tile)["dtype"]
)
if data.mask.all():
logger.debug("data empty, nothing to write")
else:
# in case of S3 output, create an boto3 resource
bucket_resource = get_boto3_bucket(self._bucket) if self._bucket else None
# Convert from process_tile to output_tiles and write
for tile in self.pyramid.intersecting(process_tile):
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(
in_tile=process_tile,
in_data=data,
out_profile=self.profile(out_tile),
out_tile=out_tile,
out_path=out_path,
tags=tags,
bucket_resource=bucket_resource
)
def write(self, process_tile, data):
"""
Write data from process tiles into PNG file(s).
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
data = self._prepare_array(data)
# Convert from process_tile to output_tiles
for tile in self.pyramid.intersecting(process_tile):
# skip if file exists and overwrite is not set
out_path = self.get_path(tile)
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(
in_tile=process_tile, in_data=data,
out_profile=self.profile(out_tile), out_tile=out_tile,
out_path=out_path)
def test_write_raster_window_errors():
"""Basic output format writing."""
tile = BufferedTilePyramid("geodetic").tile(5, 5, 5)
data = ma.masked_array(np.ndarray((1, 1)))
profile = {}
path = ""
# in_tile
with pytest.raises(TypeError):
write_raster_window(in_tile="invalid tile",
in_data=data,
out_profile=profile,
out_tile=tile,
out_path=path)
# out_tile
with pytest.raises(TypeError):
write_raster_window(in_tile=tile,
in_data=data,
out_profile=profile,
out_tile="invalid tile",
out_path=path)
# in_data
with pytest.raises(TypeError):
write_raster_window(in_tile=tile,
in_data="invalid data",
out_profile=profile,
out_tile=tile,
out_path=path)
# out_profile
with pytest.raises(TypeError):
write_raster_window(in_tile=tile,
in_data=data,
out_profile="invalid profile",
out_tile=tile,
out_path=path)
# out_path
with pytest.raises(TypeError):
write_raster_window(in_tile=tile,
in_data=data,
out_profile=profile,
out_tile=tile,
out_path=999)
def write(self, process_tile, data):
"""
Write data from one or more process tiles.
Parameters
----------
process_tile : ``BufferedTile``
must be member of process ``TilePyramid``
"""
rgba = self._prepare_array_for_png(data)
data = ma.masked_where(rgba == self.nodata, rgba)
# Convert from process_tile to output_tiles
for tile in self.pyramid.intersecting(process_tile):
# skip if file exists and overwrite is not set
self.prepare_path(tile)
out_tile = BufferedTile(tile, self.pixelbuffer)
write_raster_window(in_tile=process_tile,
in_data=data,
out_tile=BufferedTile(tile, self.pixelbuffer),
out_profile=self.profile(out_tile),
out_path=self.get_path(tile))
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)
