class RasterWindowMemoryFile():
"""Context manager around rasterio.io.MemoryFile."""
def __init__(self,
in_tile=None,
in_data=None,
out_profile=None,
out_tile=None,
tags=None):
"""Prepare data & profile."""
out_tile = out_tile or in_tile
validate_write_window_params(in_tile, out_tile, in_data, out_profile)
self.data = extract_from_array(in_raster=in_data,
in_affine=in_tile.affine,
out_tile=out_tile)
# use transform instead of affine
if "affine" in out_profile:
out_profile["transform"] = out_profile.pop("affine")
self.profile = out_profile
self.tags = tags
def __enter__(self):
"""Open MemoryFile, write data and return."""
self.rio_memfile = MemoryFile()
with self.rio_memfile.open(**self.profile) as dst:
dst.write(self.data.astype(self.profile["dtype"], copy=False))
_write_tags(dst, self.tags)
return self.rio_memfile
def __exit__(self, *args):
"""Make sure MemoryFile is closed."""
self.rio_memfile.close()
def __update_dataset(self, crs, transform, nodata=None):
"""Update dataset without writing to file after it theoretically changed.
:param crs: crs of the dataset
:param transform: transform of the dataset
:param nodata: nodata value, optional
:return: file in memory, open as dataset
"""
meta = {
"driver": "GTiff",
"dtype": self.__arr.dtype,
"nodata": nodata,
"height": self.__arr.shape[-2],
"width": self.__arr.shape[-1],
"count": self.__arr.shape[0],
"crs": crs,
"transform": transform,
}
memfile = MemoryFile()
with memfile.open(**meta) as ds:
ds.write(self.__arr)
self.dataset = memfile.open()
memfile.close()
def fp_reader(fp):
memfile = MemoryFile(fp.read())
dataset = memfile.open()
try:
yield dataset
finally:
dataset.close()
memfile.close()
def fp_reader(fp):
memfile = MemoryFile(fp.read())
dataset = memfile.open(driver=driver, sharing=sharing)
try:
yield dataset
finally:
dataset.close()
memfile.close()
def fp_reader(fp):
memfile = MemoryFile(fp.read())
dataset = memfile.open()
try:
yield dataset
finally:
dataset.close()
memfile.close()
def fp_writer(fp):
memfile = MemoryFile()
dataset = memfile.open(driver=driver, width=width, height=height,
count=count, crs=crs, transform=transform,
dtype=dtype, nodata=nodata, **kwargs)
try:
yield dataset
finally:
dataset.close()
memfile.seek(0)
fp.write(memfile.read())
memfile.close()
def fp_writer(fp):
memfile = MemoryFile()
dataset = memfile.open(driver=driver, width=width, height=height,
count=count, crs=crs, transform=transform,
dtype=dtype, nodata=nodata, sharing=sharing, **kwargs)
try:
yield dataset
finally:
dataset.close()
memfile.seek(0)
fp.write(memfile.read())
memfile.close()
class FakeCog(ImageBase):
"""fake cloud optimized geotiff"""
src_img: FakeImage
dst_kwargs: Dict
indexes: Optional[Sequence[int]] = None
nodata: Optional[Union[int, float]] = None
dtype: Optional[str] = None
add_mask: bool = False
overview_level: Optional[int] = None
overview_resampling: str = "nearest"
web_optimized: bool = False
latitude_adjustment: bool = True
resampling: str = "nearest"
config: Optional[Dict] = None
allow_intermediate_compression: bool = False
forward_band_tags: bool = False
quiet: bool = False
temporary_compression: str = "DEFLATE"
def __post_init__(self):
"""post init hook"""
self.memfile = MemoryFile()
cog_translate(
source=self.src_img.handle,
dst_path=self.memfile.name,
dst_kwargs=self.dst_kwargs,
indexes=self.indexes,
nodata=self.nodata,
dtype=self.dtype,
add_mask=self.add_mask,
overview_level=self.overview_level,
overview_resampling=self.overview_resampling,
web_optimized=self.web_optimized,
latitude_adjustment=self.latitude_adjustment,
resampling=self.resampling,
in_memory=True,
config=self.config,
allow_intermediate_compression=self.allow_intermediate_compression,
forward_band_tags=self.forward_band_tags,
quiet=self.quiet,
temporary_compression=self.temporary_compression,
)
self.handle = self.memfile.open()
def close(self):
"""close resources"""
self.handle.close()
self.memfile.close()