| |
| """Deterministic finite-nodata GeoTIFF conversions used by C10.""" |
|
|
| from __future__ import annotations |
|
|
| import os |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| import rasterio |
|
|
|
|
| S1_PORTABLE_NODATA = -9999.0 |
| BINARY_PORTABLE_NODATA = 255 |
|
|
|
|
| def valid_pixels(data: np.ndarray, nodata: float | int | None) -> np.ndarray: |
| """Return pixels valid in every band, including a finite nodata value.""" |
| bands = data if data.ndim == 3 else data[np.newaxis, ...] |
| valid = np.logical_and.reduce([np.isfinite(band) for band in bands]) |
| if nodata is not None and np.isfinite(float(nodata)): |
| valid &= np.logical_and.reduce([band != float(nodata) for band in bands]) |
| return valid |
|
|
|
|
| def _copy_tags(source: rasterio.io.DatasetReader, target: rasterio.io.DatasetWriter) -> None: |
| target.update_tags(**source.tags()) |
| for index in range(1, source.count + 1): |
| target.update_tags(index, **source.tags(index)) |
| if source.descriptions[index - 1]: |
| target.set_band_description(index, source.descriptions[index - 1]) |
|
|
|
|
| def _atomic_raster_write(destination: Path, writer: Any) -> None: |
| destination.parent.mkdir(parents=True, exist_ok=True) |
| temporary = destination.with_name(f".{destination.stem}.tmp.{os.getpid()}{destination.suffix}") |
| try: |
| writer(temporary) |
| os.replace(temporary, destination) |
| finally: |
| if temporary.exists(): |
| temporary.unlink() |
|
|
|
|
| def write_portable_s1(source: Path, destination: Path) -> dict[str, Any]: |
| """Preserve finite S1 values and encode invalid pixels as finite -9999.""" |
| source = source.resolve() |
| destination = destination.resolve() |
| with rasterio.open(source) as dataset: |
| data = dataset.read().astype("float32") |
| valid = valid_pixels(data, dataset.nodata) |
| if np.any(data[:, valid] == S1_PORTABLE_NODATA): |
| raise ValueError(f"valid source pixels collide with {S1_PORTABLE_NODATA}: {source}") |
| converted = data.copy() |
| converted[:, ~valid] = S1_PORTABLE_NODATA |
| profile = dataset.profile.copy() |
| profile.update(dtype="float32", nodata=S1_PORTABLE_NODATA, compress="deflate", predictor=3) |
|
|
| def writer(path: Path) -> None: |
| with rasterio.open(path, "w", **profile) as output: |
| output.write(converted) |
| _copy_tags(dataset, output) |
|
|
| _atomic_raster_write(destination, writer) |
| return { |
| "bands": int(dataset.count), |
| "height": int(dataset.height), |
| "width": int(dataset.width), |
| "valid_spatial_pixels": int(valid.sum()), |
| "invalid_spatial_pixels": int(valid.size - valid.sum()), |
| "source_nodata": str(dataset.nodata), |
| "portable_nodata": S1_PORTABLE_NODATA, |
| } |
|
|
|
|
| def verify_portable_s1(source: Path, destination: Path) -> dict[str, Any]: |
| """Prove a portable S1 raster is a value-preserving source derivative.""" |
| if not destination.is_file(): |
| raise FileNotFoundError(destination) |
| with rasterio.open(source) as upstream, rasterio.open(destination) as portable: |
| original = upstream.read().astype("float32") |
| derived = portable.read().astype("float32") |
| valid = valid_pixels(original, upstream.nodata) |
| if original.shape != derived.shape: |
| raise ValueError(f"shape mismatch: {source} vs {destination}") |
| if portable.nodata != S1_PORTABLE_NODATA: |
| raise ValueError(f"unexpected portable nodata {portable.nodata}: {destination}") |
| if upstream.crs != portable.crs or upstream.transform != portable.transform: |
| raise ValueError(f"georeferencing mismatch: {source} vs {destination}") |
| if not np.array_equal(original[:, valid], derived[:, valid]): |
| raise ValueError(f"valid values changed: {source} vs {destination}") |
| if not np.all(derived[:, ~valid] == S1_PORTABLE_NODATA): |
| raise ValueError(f"invalid values were not normalized: {destination}") |
| return { |
| "valid_spatial_pixels": int(valid.sum()), |
| "invalid_spatial_pixels": int(valid.size - valid.sum()), |
| "valid_values_identical": True, |
| "georeferencing_identical": True, |
| "nodata": S1_PORTABLE_NODATA, |
| } |
|
|
|
|
| def normalize_binary_mask_in_place(path: Path) -> dict[str, Any]: |
| """Convert one binary mask to uint8 0/1 with nodata 255, preserving validity.""" |
| path = path.resolve() |
| with rasterio.open(path) as dataset: |
| if dataset.count != 1: |
| raise ValueError(f"binary mask must have one band: {path}") |
| source = dataset.read(1) |
| valid = valid_pixels(source, dataset.nodata) |
| positive = valid & (source > 0) |
| converted = np.full(source.shape, BINARY_PORTABLE_NODATA, dtype="uint8") |
| converted[valid] = positive[valid].astype("uint8") |
| profile = dataset.profile.copy() |
| profile.update( |
| dtype="uint8", |
| count=1, |
| nodata=BINARY_PORTABLE_NODATA, |
| compress="deflate", |
| predictor=2, |
| ) |
| source_nodata = dataset.nodata |
|
|
| def writer(destination: Path) -> None: |
| with rasterio.open(destination, "w", **profile) as output: |
| output.write(converted, 1) |
| _copy_tags(dataset, output) |
|
|
| _atomic_raster_write(path, writer) |
| return { |
| "valid_pixels": int(valid.sum()), |
| "invalid_pixels": int(valid.size - valid.sum()), |
| "positive_pixels": int(positive.sum()), |
| "source_nodata": str(source_nodata), |
| "portable_nodata": BINARY_PORTABLE_NODATA, |
| } |
|
|
|
|
| def verify_portable_binary_mask(path: Path) -> dict[str, Any]: |
| with rasterio.open(path) as dataset: |
| values = dataset.read(1) |
| if dataset.count != 1 or dataset.dtypes[0] != "uint8": |
| raise ValueError(f"portable binary raster must be one uint8 band: {path}") |
| if dataset.nodata != BINARY_PORTABLE_NODATA: |
| raise ValueError(f"unexpected binary nodata {dataset.nodata}: {path}") |
| unique = set(int(value) for value in np.unique(values)) |
| if not unique <= {0, 1, BINARY_PORTABLE_NODATA}: |
| raise ValueError(f"non-binary values {sorted(unique)}: {path}") |
| valid = values != BINARY_PORTABLE_NODATA |
| return { |
| "valid_pixels": int(valid.sum()), |
| "invalid_pixels": int(valid.size - valid.sum()), |
| "positive_pixels": int((values == 1).sum()), |
| "values": sorted(unique), |
| "nodata": BINARY_PORTABLE_NODATA, |
| } |
|
|
