starman / code /mars_terrain.py
enzeeoai's picture
Super-squash history (latest files kept, was 8ef726a569)
d922ac9
Raw History Blame Contribute Delete
19 kB
"""Single-pass, band-by-band global terrain features on the latband5km-v1 grid.
Source: the MOLA-HRSC Blended DEM (200 m/pixel simple-cylindrical GeoTIFF),
described by ``source_manifest.json`` next to the raster. The grid is the
permanent latitude-band index from :mod:`planetary_grid`; this module never
changes cell IDs, band edges or column counts.
Each latitude band is read exactly once as a windowed strip of full-width pixel
rows plus a two-row halo, equalized east-west to ~200 m of ground spacing, and
reduced to per-cell statistics with pure array operations (no per-cell polygon
rasterization). Output is one Parquet file per 100 bands.
The planet-independent half of that work - block averaging, Horn slope, the
per-cell reductions, the ``terrain-v0.2`` feature definitions and the Parquet
assembly - lives in :mod:`terrain_features` and is shared verbatim with
:mod:`earth_terrain`. What stays here is Mars: the manifest, the raster
geometry, the spherical ground-spacing arithmetic and the read window.
Usage:
python mars_terrain.py --bands 1000-1099 --workers 4
python mars_terrain.py --bands 0-2133 --resume --workers 8 --out DIR
Conventions and deliberate choices are documented in ``band_context`` and
``process_band``; the ones that matter for interpretation are:
* Statistics are computed on the *analysis* grid (after east-west block
averaging), so ``n_samples_200m`` counts analysis pixels. ``n_native_samples`` and
``n_valid_native_samples`` carry the native pixel accounting, which partitions the
raster exactly.
* The block factor ``k`` is a function of latitude, but one ``k`` is used for
every row of a band's read window so the three rows of a Horn stencil stay
column-aligned. ``k`` is taken at the band's centre latitude; where the rows
of the window do not all agree the cell is flagged ``mixed_block_factor``.
* Elevations are passed through as published (metres, areoid per the manifest's
own inference) and are context only.
"""
from __future__ import annotations
import argparse
import json
import math
import sys
import time
from concurrent.futures import ProcessPoolExecutor, as_completed
from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path
import numpy as np
import rasterio
from rasterio.windows import Window
import terrain_features as tf
from planetary_grid import PLANETS, VERSION as GRID_VERSION, PlanetBandGrid
# Re-exported so that every name this module published before the shared
# feature code was split out of it still resolves here. Callers may import
# either module; these are the same objects.
from terrain_features import ( # noqa: F401
ANALYSIS_SPACING_M, BANDS_PER_GROUP, BLOCK_HALO, COUNT_FEATURES, ELEV_PERCENTILES,
FEATURE_VERSION, FLOAT_FEATURES, LOW_COVERAGE_FRACTION, POLAR_DISTORTION_LAT,
RELIEF_WINDOW, ROW_HALO, SLOPE_PERCENTILES, SLOPE_THRESHOLDS,
AnalysisSegment, _constant, _sum, _window_extreme, block_average_ew,
detrended_roughness, ew_block_factor, group_is_complete, group_path,
grouped_percentiles, horn_slope_deg, local_relief, parse_band_range, plan_groups,
wrap_blocks, write_atomic,
)
PLANET = 'mars'
DEFAULT_SOURCE_DIR = Path('data/raw/mars/mola_hrsc')
DEFAULT_OUT_DIR = Path('data/processed/mars/terrain')
# --------------------------------------------------------------------------
# provenance
# --------------------------------------------------------------------------
def code_version(path: Path | None = None) -> str:
"""SHA-256 over this driver and ``terrain_features.py``, in that order.
Every row names the code that made it. The feature maths lives in
``terrain_features``, so hashing the driver alone would leave a change to a
feature definition invisible in provenance. ``path`` overrides the driver
file only; the shared module is always included.
Rows written before the split (feature_version ``terrain-v0.1`` at commit
ccdb979) carry the digest of ``mars_terrain.py`` alone and will not equal
this value; that is expected, not a mismatch in the data.
"""
driver = Path(path) if path else Path(__file__).resolve()
return tf.code_version(driver, Path(tf.__file__).resolve())
def load_source_manifest(source_dir: Path) -> dict:
"""Read ``source_manifest.json`` and pull out the fields the pipeline needs."""
source_dir = Path(source_dir)
manifest_path = source_dir / 'source_manifest.json'
manifest = json.loads(manifest_path.read_text(encoding='utf8'))
try:
product = manifest['product']
info = {
'manifest_path': manifest_path,
'dem_path': source_dir / product['file'],
'source_product': str(product['name']),
'source_version': str(product['version']),
'source_checksum': str(manifest['sha256']['value']),
'nodata': float(manifest['nodata']['value']),
'body_radius_m': float(manifest.get('crs', {}).get('body_radius_m', PLANETS[PLANET]['a_m'])),
}
except KeyError as exc:
raise ValueError(f'{manifest_path} is missing required key {exc}') from exc
if not info['dem_path'].exists():
raise FileNotFoundError(f'DEM named by the manifest is missing: {info["dem_path"]}')
radius = PLANETS[PLANET]['a_m']
if not math.isclose(info['body_radius_m'], radius, rel_tol=1e-9):
raise ValueError(
f'Manifest body radius {info["body_radius_m"]} disagrees with the grid reference {radius}')
return info
# --------------------------------------------------------------------------
# grid / raster geometry
# --------------------------------------------------------------------------
def band_row_range(lat_top: float, res_deg: float, height: int,
lat_min: float, lat_max: float) -> tuple[int, int]:
"""Pixel rows whose CENTRE latitude lies in [lat_min, lat_max).
Returns a half-open ``(start, stop)`` clipped to the raster. Adjacent bands
share an edge value exactly, so the row sets partition the raster with no
gap and no overlap.
"""
first = math.floor((lat_top - lat_max) / res_deg - 0.5) + 1
last = math.floor((lat_top - lat_min) / res_deg - 0.5)
return max(first, 0), min(last + 1, height)
@dataclass(frozen=True)
class RasterContext:
"""Immutable description of the DEM, validated once per worker."""
path: Path
width: int
height: int
lat_top: float
lon_left: float
res_deg: float
nodata: float
radius_m: float
@property
def dy_m(self) -> float:
"""North-south ground spacing of one pixel row, in metres."""
return math.radians(self.res_deg) * self.radius_m
def row_center_lat(self, rows: np.ndarray) -> np.ndarray:
return self.lat_top - (np.asarray(rows, dtype=np.float64) + 0.5) * self.res_deg
def col_center_lon(self, cols: np.ndarray) -> np.ndarray:
return self.lon_left + (np.asarray(cols, dtype=np.float64) + 0.5) * self.res_deg
def local_metres(self, d_lon: np.ndarray, lat: np.ndarray,
center_lat: float) -> tuple[np.ndarray, np.ndarray]:
"""East/north offsets in metres on the Mars indexing sphere."""
x_m = np.radians(d_lon) * self.radius_m * np.cos(np.deg2rad(lat))
y_m = np.radians(lat - center_lat) * self.radius_m
return x_m, y_m
def raster_context(info: dict) -> RasterContext:
"""Open the DEM only to validate its geometry against the manifest."""
with rasterio.open(info['dem_path']) as src:
transform = src.transform
if transform.b or transform.d:
raise ValueError('A north-up, unrotated geographic raster is required')
res_x, res_y = transform.a, -transform.e
if res_x <= 0 or not math.isclose(res_x, res_y, rel_tol=1e-12):
raise ValueError(f'Square pixels are required, got {res_x} x {res_y}')
if src.nodata is not None and not math.isclose(src.nodata, info['nodata']):
raise ValueError(
f'Raster nodata {src.nodata} disagrees with the manifest value {info["nodata"]}')
width, height = src.width, src.height
span = width * res_x
if abs(span - 360.0) > res_x:
raise ValueError(
f'Longitude coverage must be global for the wrap halo; got {span:.6f} degrees')
return RasterContext(
path=Path(info['dem_path']), width=width, height=height,
lat_top=transform.f, lon_left=transform.c, res_deg=res_x,
nodata=info['nodata'], radius_m=info['body_radius_m'],
)
# --------------------------------------------------------------------------
# array stages
# --------------------------------------------------------------------------
def read_band_strip(src, ctx: RasterContext, row_start: int, row_stop: int,
halo: int = ROW_HALO) -> tuple[np.ndarray, np.ndarray]:
"""Windowed read of a band's rows plus a halo; nodata becomes NaN.
Rows beyond the raster (only at the poles) are returned as all-NaN, which
makes every stencil that needs them NaN as well.
"""
want_start, want_stop = row_start - halo, row_stop + halo
have_start, have_stop = max(want_start, 0), min(want_stop, ctx.height)
out = np.full((want_stop - want_start, ctx.width), np.nan, dtype=np.float64)
if have_stop > have_start:
window = Window(0, have_start, ctx.width, have_stop - have_start)
data = src.read(1, window=window)
sentinel = np.asarray(ctx.nodata).astype(data.dtype)
if float(sentinel) != ctx.nodata:
raise ValueError(f'nodata {ctx.nodata} is not representable in {data.dtype}')
block = data.astype(np.float64)
block[data == sentinel] = np.nan
out[have_start - want_start:have_stop - want_start] = block
return out, ctx.row_center_lat(np.arange(want_start, want_stop))
# --------------------------------------------------------------------------
# one band
# --------------------------------------------------------------------------
def band_context(grid: PlanetBandGrid, ctx: RasterContext, band: int) -> dict:
"""Everything about a band that does not need pixels."""
lat_min = float(grid.edges_deg[band])
lat_max = float(grid.edges_deg[band + 1])
n_cells = int(grid.column_counts[band])
row_start, row_stop = band_row_range(ctx.lat_top, ctx.res_deg, ctx.height, lat_min, lat_max)
center_lat = 0.5 * (lat_min + lat_max)
return {
'band': band, 'lat_min': lat_min, 'lat_max': lat_max,
'center_lat': center_lat, 'n_cells': n_cells, 'lon_step': 360.0 / n_cells,
'row_start': row_start, 'row_stop': row_stop,
'block_factor': ew_block_factor(center_lat, max_factor=ctx.width),
}
def process_band(src, grid: PlanetBandGrid, ctx: RasterContext, band: int) -> dict:
"""Read one band once and reduce it to per-cell features.
Stages follow the read: wrap east-west, nodata to NaN (done in the read),
equalize east-west ground spacing, Horn slope and 1 km relief on the
padded array, then drop the halos and assign analysis pixels to grid
columns by their centre longitude.
"""
meta = band_context(grid, ctx, band)
n_cells = meta['n_cells']
k = meta['block_factor']
native, row_lats = read_band_strip(src, ctx, meta['row_start'], meta['row_stop'])
blocks, source_per_block, valid_per_block = block_average_ew(native, k)
del native
n_blocks = blocks.shape[1]
block_cols = np.arange(n_blocks, dtype=np.int64) * k + (source_per_block - 1) / 2.0
block_lons = ctx.col_center_lon(block_cols)
normalized = (block_lons + 180.0) % 360.0 - 180.0
column_of_block = np.clip(((normalized + 180.0) / meta['lon_step']).astype(np.int64), 0, n_cells - 1)
interior_rows = slice(ROW_HALO, blocks.shape[0] - ROW_HALO)
lats = row_lats
padded = wrap_blocks(blocks)
# True east-west stencil spacing, per output row and column. Unwrapping the
# halo longitudes (rather than assuming 2k pixels) absorbs both the short
# final block and the raster's incomplete longitude ring at the seam.
lon_padded = np.concatenate([block_lons[-BLOCK_HALO:] - 360.0, block_lons,
block_lons[:BLOCK_HALO] + 360.0])
span_deg = lon_padded[2:] - lon_padded[:-2]
dx_m = np.outer(np.cos(np.deg2rad(lats[1:-1])), span_deg) * (math.radians(1.0) * ctx.radius_m / 2.0)
slope_full = horn_slope_deg(padded, dx_m, ctx.dy_m) # shrinks by 1 each side
del dx_m
slope = slope_full[1:-1, 1:-1]
relief = local_relief(padded) # shrinks by 2 each side
elevation = padded[interior_rows, BLOCK_HALO:padded.shape[1] - BLOCK_HALO]
del padded, slope_full
n_rows = elevation.shape[0]
lats_interior = lats[ROW_HALO:len(lats) - ROW_HALO]
# native pixel accounting: exact, and independent of the analysis grid
valid_interior = valid_per_block[interior_rows]
n_native_samples = np.rint(tf._sum(
column_of_block, source_per_block * float(n_rows), n_cells)).astype(np.int64)
n_valid_native_samples = np.rint(tf._sum(
np.broadcast_to(column_of_block, valid_interior.shape).ravel(),
valid_interior.ravel().astype(np.float64), n_cells)).astype(np.int64)
segment = AnalysisSegment(
elevation=elevation, slope=slope, relief=relief,
column_of_block=column_of_block, block_lons=normalized, row_lats=lats_interior)
row = tf.cell_features(
[segment], n_cells, center_lat=meta['center_lat'], lon_step=meta['lon_step'],
n_native_samples=n_native_samples, n_valid_native_samples=n_valid_native_samples,
local_metres=ctx.local_metres)
row['ew_samples_averaged'][:] = k
row_factors = {ew_block_factor(float(lat), max_factor=ctx.width) for lat in lats_interior}
row['quality_flags'] = quality_flags(
meta['center_lat'], row['valid_frac_200m'], row['n_samples_200m'],
mixed_factor=row_factors != {k}, degenerate=n_blocks < RELIEF_WINDOW)
row['band'] = np.full(n_cells, band, dtype=np.int32)
row['column'] = np.arange(n_cells, dtype=np.int32)
return row
def quality_flags(center_lat: float, valid_frac_200m: np.ndarray, n_samples_200m: np.ndarray,
mixed_factor: bool, degenerate: bool) -> list[str]:
"""Per-cell advisory flags, semicolon separated, empty string when clean."""
return tf.quality_flags(center_lat, valid_frac_200m, n_samples_200m,
mixed_factor=mixed_factor, degenerate=degenerate)
# --------------------------------------------------------------------------
# table assembly and output
# --------------------------------------------------------------------------
def build_table(rows: list[dict], provenance: dict):
"""Concatenate per-band results into one Parquet table."""
return tf.build_table(rows, provenance, PLANET)
# --------------------------------------------------------------------------
# driver
# --------------------------------------------------------------------------
def process_group(group: int, bands: list[int], source_dir: Path, out_dir: Path,
provenance: dict) -> dict:
"""Process one band group and write its Parquet file."""
started = time.monotonic()
info = load_source_manifest(source_dir)
ctx = raster_context(info)
grid = PlanetBandGrid.build(PLANET)
rows = []
pixels = 0
with rasterio.open(ctx.path) as src:
for band in bands:
result = process_band(src, grid, ctx, band)
pixels += int(result['n_native_samples'].sum())
rows.append(result)
path = group_path(out_dir, group)
write_atomic(build_table(rows, provenance), path)
return {'group': group, 'bands': len(bands), 'rows': int(sum(len(r['column']) for r in rows)),
'source_pixels': pixels, 'seconds': time.monotonic() - started, 'path': str(path)}
def main(argv=None) -> int:
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument('--bands', default=None,
help='inclusive band range START-END (default: every band)')
parser.add_argument('--source', type=Path, default=DEFAULT_SOURCE_DIR,
help='directory holding source_manifest.json and the DEM')
parser.add_argument('--out', type=Path, default=DEFAULT_OUT_DIR,
help=f'output root; files land in <out>/{FEATURE_VERSION}/')
parser.add_argument('--workers', type=int, default=1, help='band groups in parallel')
parser.add_argument('--resume', action='store_true',
help='skip band groups whose output already covers them')
args = parser.parse_args(argv)
grid = PlanetBandGrid.build(PLANET)
n_bands = len(grid.column_counts)
bands = parse_band_range(args.bands, n_bands) if args.bands else list(range(n_bands))
info = load_source_manifest(args.source)
raster_context(info)
provenance = {
'source_product': info['source_product'],
'source_version': info['source_version'],
'source_checksum': info['source_checksum'],
'code_version': code_version(),
'computed_at': datetime.now(timezone.utc).isoformat(timespec='seconds'),
'dem_file': info['dem_path'].name,
}
work = plan_groups(bands)
if args.resume:
kept = []
for group, group_bands in work:
if group_is_complete(group_path(args.out, group), group_bands):
print(f'group {group:03d}: already complete, skipped', flush=True)
else:
kept.append((group, group_bands))
work = kept
print(f'{len(bands)} bands in {len(work)} groups -> {args.out / FEATURE_VERSION}', flush=True)
started = time.monotonic()
totals = {'rows': 0, 'source_pixels': 0}
def report(result):
totals['rows'] += result['rows']
totals['source_pixels'] += result['source_pixels']
print(f"group {result['group']:03d}: {result['bands']} bands, {result['rows']} rows, "
f"{result['source_pixels']} source pixels, {result['seconds']:.1f}s "
f"-> {result['path']}", flush=True)
if args.workers > 1 and len(work) > 1:
with ProcessPoolExecutor(max_workers=args.workers) as pool:
futures = {pool.submit(process_group, g, b, args.source, args.out, provenance): g
for g, b in work}
for future in as_completed(futures):
report(future.result())
else:
for group, group_bands in work:
report(process_group(group, group_bands, args.source, args.out, provenance))
print(f"done: {totals['rows']} rows, {totals['source_pixels']} source pixels, "
f'{time.monotonic() - started:.1f}s', flush=True)
return 0
if __name__ == '__main__':
sys.exit(main())