lunar-toolkit 0.1.0.dev2__py3-none-any.whl

lunar_toolkit/cli/pairs.py

@@ -0,0 +1,236 @@
+"""pairs - rank NAC stereo pairs, or pick illumination-diverse images for SfS."""
+
+import argparse
+import sys
+from pathlib import Path
+
+COMMAND = "pairs"
+
+
+def add_parser(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser(
+        COMMAND,
+        help="Rank NAC stereo pairs (or select SfS images with --sfs) over a box, point+radius or AOI polygon.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples
+--------
+  lunar pairs --point -89.67 129.8 --radius-km 3 --top 20
+  lunar pairs --bbox 355 -5 5 5 --conv 15 45 --csv pairs.csv
+  lunar pairs --point -89.67 129.8 --radius-km 3 --sfs --inc 80 95 --list sfs_images.txt
+  lunar pairs --point -89.67 129.8 --radius-km 3 --sfs --coverage --views 3
+  lunar pairs --aoi aoi.geojson --sfs --coverage
+  lunar pairs --point -89.5 0 --radius-km 30 --engine duckdb --workspace work/pole
+
+--bbox is WEST SOUTH EAST NORTH (degrees, positive east; WEST > EAST crosses 0/360).
+--aoi takes a GeoJSON / WKT file or a WKT string (lon lat, degrees, positive east).
+The search region is also the AOI that overlaps / coverage are measured in.
+--sfs output (and --list) is sorted by sub-solar azimuth, as ASP SfS expects.
+--engine duckdb ranks pairs with a DuckDB spatial self-join (same pairs and metrics as
+the Python engine); auto uses it from 300 images when the spatial extension loads.
+--workspace keeps the images and pairs tables in DIR/lunar.duckdb (see lunar workspace).
+""",
+    )
+    p.add_argument("--dataset", choices=["edr", "cdr"], default="edr", help="Index to search (default: edr).")
+    region = p.add_mutually_exclusive_group(required=True)
+    region.add_argument("--bbox", nargs=4, type=float, metavar=("WEST", "SOUTH", "EAST", "NORTH"))
+    region.add_argument("--point", nargs=2, type=float, metavar=("LAT", "LON"))
+    region.add_argument(
+        "--aoi", metavar="FILE_OR_WKT", help="Area of interest: GeoJSON / WKT file or WKT polygon string."
+    )
+    p.add_argument("--radius-km", type=float, default=1.0, metavar="KM")
+    p.add_argument("--inc", nargs=2, type=float, metavar=("MIN", "MAX"), help="Incidence angle range.")
+    p.add_argument("--emi-max", type=float, default=None, metavar="DEG", help="Maximum emission angle.")
+    p.add_argument(
+        "--conv",
+        nargs=2,
+        type=float,
+        default=(10.0, 60.0),
+        metavar=("MIN", "MAX"),
+        help="Convergence angle limits (default: 10 60).",
+    )
+    p.add_argument("--max-inc-diff", type=float, default=20.0, metavar="DEG")
+    p.add_argument(
+        "--max-az-diff",
+        type=float,
+        default=30.0,
+        metavar="DEG",
+        help="Maximum sub-solar azimuth difference within a pair.",
+    )
+    p.add_argument("--min-overlap", type=float, default=0.1, metavar="FRAC")
+    p.add_argument(
+        "--sfs", action="store_true", help="Select illumination-diverse images instead of stereo pairs."
+    )
+    p.add_argument(
+        "--az-bin",
+        type=float,
+        default=30.0,
+        metavar="DEG",
+        help="--sfs: azimuth bin width / minimum separation (default: 30).",
+    )
+    p.add_argument("--per-bin", type=int, default=1, metavar="N")
+    p.add_argument("--max-images", type=int, default=None, metavar="N")
+    p.add_argument(
+        "--greedy",
+        action="store_true",
+        help="--sfs: enforce --az-bin separation between all picks instead of fixed bins.",
+    )
+    p.add_argument(
+        "--coverage", action="store_true", help="--sfs: per-location greedy selection over an AOI grid."
+    )
+    p.add_argument(
+        "--views",
+        type=int,
+        default=3,
+        metavar="N",
+        help="--sfs --coverage: target distinct Sun azimuths per location (default: 3).",
+    )
+    p.add_argument(
+        "--engine",
+        choices=["auto", "python", "duckdb"],
+        default="auto",
+        help="Stereo pair engine (default: auto = duckdb from 300 images).",
+    )
+    p.add_argument(
+        "--workspace",
+        type=Path,
+        metavar="DIR",
+        help="Write the images and pairs tables to DIR/lunar.duckdb (implies --engine duckdb).",
+    )
+    p.add_argument("--top", type=int, default=30, metavar="N", help="Rows to print (default: 30).")
+    p.add_argument("--csv", metavar="FILE", help="Write the full result to CSV.")
+    p.add_argument("--list", metavar="FILE", help="--sfs: write selected product IDs, one per line.")
+    p.add_argument(
+        "--data-dir", type=Path, default=None, metavar="DIR", help="Override Parquet data directory."
+    )
+
+
+def run(args: argparse.Namespace) -> int:
+    from ..lroc.cumindex import CumIndex
+    from ._utils import region_args
+
+    ci = CumIndex(dataset=args.dataset, data_dir=args.data_dir)
+    region = region_args(args)
+    aoi = region.get("aoi", region)
+    try:
+        df = ci.search(
+            **region,
+            incidence_angle=tuple(args.inc) if args.inc else None,
+            emission_angle=(0.0, args.emi_max) if args.emi_max is not None else None,
+            nac_only=True,
+            wkt=True,
+        )
+    except FileNotFoundError as exc:
+        print(exc, file=sys.stderr)
+        return 1
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+    obs = ci.to_observations(df)
+    print(f"{len(obs)} image(s) in region")
+
+    if args.sfs:
+        from ..selection import select_for_coverage, select_illumination_diverse
+
+        if args.coverage:
+            res = select_for_coverage(
+                obs,
+                aoi,
+                azimuth_sep_deg=args.az_bin,
+                views_per_cell=args.views,
+                max_images=args.max_images,
+            )
+            vf = res.attrs.get("view_fractions", {})
+            if vf:
+                print(
+                    "AOI fraction by number of distinct Sun azimuths: "
+                    + ", ".join(f"{k}: {v:.0%}" for k, v in vf.items())
+                )
+        else:
+            res = select_illumination_diverse(
+                obs,
+                azimuth_bin_deg=args.az_bin,
+                per_bin=args.per_bin,
+                max_images=args.max_images,
+                aoi=aoi,
+                method="greedy" if args.greedy else "bins",
+            )
+        print(f"{len(res)} image(s) selected (sorted by Sun azimuth)")
+        cols = [
+            c
+            for c in (
+                "product_id",
+                "start_time",
+                "sub_solar_azimuth",
+                "incidence",
+                "emission",
+                "pixel_scale",
+                "aoi_coverage",
+                "selection_score",
+            )
+            if c in res.columns
+        ]
+        if args.list:
+            Path(args.list).write_text("".join(f"{p}\n" for p in res["product_id"]))
+            print(f"Wrote {args.list}")
+    else:
+        res = _stereo_pairs(
+            obs,
+            args,
+            aoi=aoi,
+            convergence=tuple(args.conv),
+            max_incidence_diff=args.max_inc_diff,
+            max_azimuth_diff=args.max_az_diff,
+            min_overlap=args.min_overlap,
+        )
+        if res is None:
+            return 1
+        print(f"{len(res)} pair(s)")
+        cols = [
+            "product_id_1",
+            "product_id_2",
+            "convergence",
+            "b_h",
+            "incidence_diff",
+            "azimuth_diff",
+            "resolution_ratio",
+            "aoi_coverage",
+            "dt_days",
+            "score",
+        ]
+
+    if not res.empty:
+        print(res[cols].head(args.top).to_string(index=False, float_format=lambda v: f"{v:.3g}"))
+    if args.csv:
+        res.drop(columns=[c for c in ("footprint_wkt",) if c in res.columns]).to_csv(args.csv, index=False)
+        print(f"Wrote {args.csv}")
+    return 0
+
+
+def _stereo_pairs(obs, args: argparse.Namespace, **kwargs):
+    """find_stereo_pairs, or its DuckDB engine (--engine / --workspace); None on error."""
+    from ..stereo import find_stereo_pairs
+    from ..workspace import (
+        PAIRS_ENGINE_THRESHOLD,
+        Workspace,
+        WorkspaceError,
+        find_stereo_pairs_duckdb,
+        spatial_available,
+        workspace_path,
+    )
+
+    engine = "duckdb" if args.workspace else args.engine
+    if engine == "auto":
+        engine = "duckdb" if len(obs) >= PAIRS_ENGINE_THRESHOLD and spatial_available() else "python"
+    if engine == "python":
+        return find_stereo_pairs(obs, **kwargs)
+    try:
+        if args.workspace:
+            with Workspace(args.workspace) as ws:
+                res = find_stereo_pairs_duckdb(obs, workspace=ws, **kwargs)
+            print(f"Wrote images and pairs to {workspace_path(args.workspace)}")
+            return res
+        return find_stereo_pairs_duckdb(obs, **kwargs)
+    except WorkspaceError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return None

lunar_toolkit/cli/process.py

@@ -0,0 +1,138 @@
+"""process - download and run the ISIS + GDAL pipeline on LROC NAC images."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from ..constants import DEFAULT_PROJECTION
+
+COMMAND = "process"
+
+
+def add_parser(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser(
+        COMMAND,
+        help="Run the ISIS + GDAL pipeline on LROC NAC images.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples
+--------
+  lunar process M1096757719LE
+  lunar process M1096757719LE M1096757719RE --workers 2
+  lunar process --from-file ids.txt --output-dir ./output
+  lunar process /data/M1096757719LE.IMG --keep --resolution 1
+  lunar process https://pds.lroc.im-ldi.com/data/.../M1096757719LE.IMG
+
+Everything is written to --output-dir: the GeoTIFF <id>.tif (map-projected I/F,
+DEFLATE-compressed) plus intermediates (<id>.IMG, <id>.cal.echo.cub, <id>.map.cub),
+which are removed after success unless --keep.  Steps whose output exists are
+skipped, so re-running resumes (use --force to redo them).
+""",
+    )
+    p.add_argument(
+        "sources",
+        nargs="*",
+        metavar="SOURCE",
+        help="Product IDs (e.g. M1096757719LE), local .IMG paths, or PDS URLs.",
+    )
+    p.add_argument(
+        "--from-file",
+        metavar="FILE",
+        help="Text file of sources, one per line (#comments ignored).",
+    )
+    p.add_argument(
+        "--output-dir",
+        default=None,
+        metavar="DIR",
+        help="Output directory (default: current working directory).",
+    )
+    p.add_argument(
+        "--keep",
+        action="store_true",
+        help="Keep the downloaded EDR and the intermediate ISIS cubes.",
+    )
+    p.add_argument("--force", action="store_true", help="Redo steps whose output exists.")
+    p.add_argument(
+        "--workers",
+        type=int,
+        default=1,
+        metavar="N",
+        help="Parallel workers for batch processing (default: 1).",
+    )
+    p.add_argument(
+        "--projection",
+        default=DEFAULT_PROJECTION,
+        metavar="PROJ",
+        help=f"ISIS map projection for mosrange (default: {DEFAULT_PROJECTION}).",
+    )
+    p.add_argument("--resolution", type=float, default=None, metavar="M", help="Map resolution in m/pixel.")
+    p.add_argument(
+        "--no-web",
+        dest="web",
+        action="store_false",
+        help="Use local SPICE kernels in spiceinit instead of the USGS web service.",
+    )
+    p.add_argument(
+        "--data-dir",
+        type=Path,
+        default=None,
+        metavar="DIR",
+        help="Override Parquet data directory.",
+    )
+
+
+def run(args: argparse.Namespace) -> int:
+    from ..lroc.nac import NacImageCollection, NacProcessor
+    from ._utils import load_sources
+
+    sources = load_sources(args)
+    if not sources:
+        print("No sources provided. Pass product IDs, paths, URLs, or --from-file.", file=sys.stderr)
+        return 1
+
+    output_dir = Path(args.output_dir) if args.output_dir else Path.cwd()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Route: product IDs -> NacImageCollection; existing paths / URLs -> processor directly
+    direct_sources: list[str] = []
+    id_sources: list[str] = []
+    for s in sources:
+        s = s.strip()
+        if s.startswith(("http://", "https://")) or Path(s).exists():
+            direct_sources.append(s)
+        else:
+            id_sources.append(s)
+
+    opts = {
+        "projection": args.projection,
+        "resolution": args.resolution,
+        "web": args.web,
+        "keep": args.keep,
+        "force": args.force,
+    }
+    ok = total = 0
+
+    if id_sources:
+        collection = NacImageCollection.from_sources(id_sources, data_dir=args.data_dir)
+        results = collection.process(output_dir, workers=args.workers, **opts)
+        for pid, tif in results.items():
+            total += 1
+            if tif:
+                print(f"  {pid}  ->  {tif}")
+                ok += 1
+            else:
+                print(f"  {pid}  -  FAILED", file=sys.stderr)
+
+    if direct_sources:
+        proc = NacProcessor(output_dir, **opts)
+        tifs = proc.process_batch(direct_sources, max_workers=args.workers)
+        for src, tif in zip(direct_sources, tifs):
+            total += 1
+            label = Path(src).name if not src.startswith("http") else src
+            if tif:
+                print(f"  {label}  ->  {tif}")
+                ok += 1
+            else:
+                print(f"  {label}  -  FAILED", file=sys.stderr)
+
+    return 0 if ok == total else 1

lunar_toolkit/cli/query.py

@@ -0,0 +1,70 @@
+"""query - print metadata for LROC NAC images from the Parquet index."""
+
+import argparse
+import sys
+from pathlib import Path
+
+COMMAND = "query"
+
+
+def add_parser(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser(
+        COMMAND,
+        help="Print metadata for LROC NAC images from the Parquet index.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples
+--------
+  lunar query M1096757719LE
+  lunar query M1096757719LE M1096757719RE
+  lunar query --from-file ids.txt
+  lunar query /path/to/M1096757719LE.IMG
+""",
+    )
+    p.add_argument(
+        "sources",
+        nargs="*",
+        metavar="SOURCE",
+        help="Product IDs, local .IMG paths, or a text file of IDs.",
+    )
+    p.add_argument(
+        "--from-file",
+        metavar="FILE",
+        help="Text file of product IDs or paths, one per line.",
+    )
+    p.add_argument(
+        "--data-dir",
+        type=Path,
+        default=None,
+        metavar="DIR",
+        help="Override Parquet data directory.",
+    )
+
+
+def run(args: argparse.Namespace) -> int:
+    from ..lroc.nac import NacImageCollection
+    from ._utils import extract_product_id, load_sources
+
+    sources = load_sources(args)
+    if not sources:
+        print("No sources provided. Pass product IDs or --from-file.", file=sys.stderr)
+        return 1
+
+    product_ids = [extract_product_id(s) for s in sources]
+
+    collection = NacImageCollection.from_sources(product_ids, data_dir=args.data_dir)
+    found = {img.product_id: img for img in collection}
+
+    for pid in product_ids:
+        img = found.get(pid)
+        print(pid)
+        if img is None:
+            print("  (not found in index)")
+        else:
+            items = img.metadata_items()
+            width = max((len(label) for label, _ in items), default=30) + 2
+            for label, value in items:
+                print(f"  {label:<{width}} {value}")
+        print()
+
+    return 0

lunar_toolkit/cli/reference.py

@@ -0,0 +1,233 @@
+"""reference - Artemis III candidate regions, PGDA LOLA 5 m site DEMs and Bertone et al. (2026) SfS DEMs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+COMMAND = "reference"
+
+
+def add_parser(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser(
+        COMMAND,
+        help="Reference data for the Artemis III regions: crop windows, PGDA LOLA 5 m DEMs, Bertone SfS DEMs.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples
+--------
+  lunar reference list
+  lunar reference show malapert                 # bbox, ROI projwin, PGDA site, Zenodo zip
+  lunar reference crop 11 --crop-km 2.5         # 2.5 km window at the ROI centre
+  lunar reference crop malapert --center -85.98 -0.26 --format wkt
+  lunar reference pgda malapert --kind surf toterr -o ref
+  lunar reference pgda malapert --kind clones --clones 10 -o ref
+  lunar reference pgda malapert --kind xyzi --csv --crop-km 2.5 -o ref
+  lunar reference sdem malapert --list           # zip members (remote central directory)
+  lunar reference sdem malapert --remote --member GLDELEV GLDSIGM -o ref
+  lunar reference sdem malapert --download -o ref --member GLDELEV
+
+REGION is an id (0-12), name, slug, unique part of a name or PGDA site
+(11, "Malapert Massif", malapert-massif, malapert, Site23).  The ROI is the
+polar stereographic square the SfS DEM covers (= the PGDA site extent);
+projwin is ULX ULY LRX LRY in metres (+proj=stere +lat_0=-90 +R=1737400).
+Existing files are skipped (--force to redo); downloads resume.
+""",
+    )
+    sp = p.add_subparsers(dest="ref_cmd", required=True)
+
+    sp.add_parser("list", help="List the 13 regions.").add_argument(
+        "--json", action="store_true", help="Print JSON instead of a table."
+    )
+
+    show = sp.add_parser("show", help="Show one region.")
+    show.add_argument("region", metavar="REGION")
+    show.add_argument("--crop-km", type=float, default=None, metavar="KM", help="Also print a crop window.")
+    show.add_argument("--json", action="store_true", help="Print JSON.")
+
+    crop = sp.add_parser("crop", help="Print a square crop window centred on a region.")
+    crop.add_argument("region", metavar="REGION")
+    crop.add_argument("--crop-km", type=float, default=2.5, metavar="KM", help="Side length (default: 2.5).")
+    crop.add_argument(
+        "--center", nargs=2, type=float, metavar=("LAT", "LON"), help="Centre (default: ROI centre)."
+    )
+    crop.add_argument(
+        "--format",
+        choices=("projwin", "bounds", "wkt", "geojson"),
+        default="projwin",
+        help="projwin (ULX ULY LRX LRY), bounds (XMIN YMIN XMAX YMAX), lon/lat WKT or GeoJSON.",
+    )
+
+    pg = sp.add_parser("pgda", help="Download a region's PGDA LOLA 5 m site files.")
+    pg.add_argument("region", metavar="REGION")
+    pg.add_argument(
+        "--kind",
+        nargs="+",
+        default=["surf"],
+        metavar="KIND",
+        help="surf ldec toterr slp slperr xyzi clones rois (default: surf).",
+    )
+    pg.add_argument("--clones", type=int, default=None, metavar="N", help="Only the first N clones.")
+    pg.add_argument("--csv", action="store_true", help="Also write each .xyzi as an ASP CSV.")
+    pg.add_argument("--crop-km", type=float, default=None, metavar="KM", help="Crop the --csv points.")
+    pg.add_argument("--list", action="store_true", help="Print the URLs only.")
+    pg.add_argument("--refresh", action="store_true", help="Re-read the PGDA product page.")
+    _common(pg)
+
+    sd = sp.add_parser("sdem", help="List / download / extract a region's Bertone et al. Zenodo zip.")
+    sd.add_argument("region", metavar="REGION")
+    sd.add_argument(
+        "--member",
+        nargs="+",
+        default=["GLDELEV"],
+        metavar="PAT",
+        help="Members to extract: product code / substring or glob (default: GLDELEV).",
+    )
+    mode = sd.add_mutually_exclusive_group()
+    mode.add_argument("--list", action="store_true", help="List zip members (reads only the directory).")
+    mode.add_argument("--remote", action="store_true", help="Extract members remotely (no full zip).")
+    mode.add_argument(
+        "--download", action="store_true", help="Download the whole zip (1-4 GB), then extract."
+    )
+    sd.add_argument("--zip", type=Path, default=None, metavar="ZIP", help="Extract from this local zip.")
+    _common(sd)
+
+
+def _common(p: argparse.ArgumentParser) -> None:
+    p.add_argument(
+        "--output-dir", "-o", type=Path, default=Path("."), metavar="DIR", help="Destination (default: .)."
+    )
+    p.add_argument("--force", action="store_true", help="Download / extract again even if present.")
+
+
+def _region_info(reg, crop_km: float | None = None) -> dict:
+    from .. import reference as ref
+
+    roi = reg.roi
+    info = {
+        "id": reg.id,
+        "name": reg.name,
+        "slug": reg.slug,
+        "center_lonlat": reg.center,
+        "bbox": reg.bbox,
+        "roi_projwin": roi.projwin,
+        "roi_size_km": (roi.width / 1000.0, roi.height / 1000.0),
+        "bbox_projwin": tuple(round(v, 1) for v in reg.bbox_projwin),
+        "pgda_site": reg.pgda_site,
+        "pgda_url": ref.PGDA_SITES[reg.pgda_site].url if reg.pgda_site else None,
+        "zenodo_file": reg.zenodo_file,
+        "zenodo_size_gb": round(reg.zenodo_size / 1e9, 2),
+        "zenodo_md5": reg.zenodo_md5,
+        "zenodo_url": reg.zenodo_url,
+    }
+    if crop_km:
+        info["crop_projwin"] = ref.crop_window(reg, crop_km).projwin
+    return info
+
+
+def run(args: argparse.Namespace) -> int:
+    from .. import reference as ref
+
+    try:
+        if args.ref_cmd == "list":
+            return _list(args)
+        reg = ref.get_region(args.region)
+        if args.ref_cmd == "show":
+            info = _region_info(reg, args.crop_km)
+            if args.json:
+                print(json.dumps(info, indent=2))
+            else:
+                for k, v in info.items():
+                    print(f"{k:15s} {' '.join(f'{x:g}' for x in v) if isinstance(v, tuple) else v}")
+            return 0
+        if args.ref_cmd == "crop":
+            return _crop(args, reg)
+        if args.ref_cmd == "pgda":
+            return _pgda(args, reg)
+        return _sdem(args, reg)
+    except (KeyError, ValueError) as exc:
+        print(f"Error: {exc.args[0] if exc.args else exc}", file=sys.stderr)
+        return 1
+
+
+def _list(args: argparse.Namespace) -> int:
+    from .. import reference as ref
+
+    if args.json:
+        print(json.dumps([_region_info(r) for r in ref.REGIONS], indent=2))
+        return 0
+    print(f"{'id':>2}  {'name':27s} {'pgda':9s} {'zip GB':>6}  roi projwin (ULX ULY LRX LRY, m)")
+    for r in ref.REGIONS:
+        pw = " ".join(f"{v:.0f}" for v in r.projwin)
+        print(f"{r.id:>2}  {r.name:27s} {r.pgda_site or '-':9s} {r.zenodo_size / 1e9:6.2f}  {pw}")
+    return 0
+
+
+def _crop(args: argparse.Namespace, reg) -> int:
+    from .. import reference as ref
+
+    box = ref.crop_window(reg, args.crop_km, tuple(args.center) if args.center else None)
+    if args.format == "projwin":
+        print(" ".join(f"{v:.3f}".rstrip("0").rstrip(".") for v in box.projwin))
+    elif args.format == "bounds":
+        print(" ".join(f"{v:.3f}".rstrip("0").rstrip(".") for v in box.bounds))
+    elif args.format == "wkt":
+        print(box.wkt())
+    else:
+        print(json.dumps({"type": "Polygon", "coordinates": [box.ring_lonlat()]}))
+    return 0
+
+
+def _pgda(args: argparse.Namespace, reg) -> int:
+    from .. import reference as ref
+
+    index = ref.pgda_index(refresh=args.refresh)
+    if args.list:
+        for kind, urls in ref.pgda_urls(reg, args.kind, args.clones, index).items():
+            for u in urls:
+                print(f"{kind:7s} {u}")
+        return 0
+    paths = ref.download_pgda(reg, args.kind, args.output_dir, args.clones, args.force, index=index)
+    for kind, files in paths.items():
+        for f in files:
+            print(f"{kind:7s} {f}")
+    if args.csv:
+        box = ref.crop_window(reg, args.crop_km) if args.crop_km else None
+        for f in paths.get("xyzi", []):
+            out = f.with_suffix(f"{'_crop' if box else ''}.csv")
+            ref.write_asp_csv(f, out, box)
+            print(f"csv     {out}  (--csv-format '{ref.ASP_CSV_FORMAT}' --csv-srs '{ref.PS_SRS}')")
+    return 0
+
+
+def _sdem(args: argparse.Namespace, reg) -> int:
+    from .. import reference as ref
+
+    if args.list:
+        members = ref.sdem_members(args.zip or reg)
+        for row in members.itertuples():
+            print(f"{row.size:>12,}  {row.name}")
+        print(f"{len(members)} members, {members['size'].sum() / 1e9:.2f} GB uncompressed")
+        return 0
+    if args.remote:
+        source = reg
+    elif args.zip:
+        source = args.zip
+    elif args.download:
+        source = ref.download_sdem(reg, args.output_dir, force=args.force)
+    else:
+        local = args.output_dir / reg.zenodo_file
+        if not local.exists():
+            print(
+                f"{local} not found: pass --download (whole zip, {reg.zenodo_size / 1e9:.1f} GB), "
+                "--remote (selected members only) or --zip",
+                file=sys.stderr,
+            )
+            return 1
+        source = local
+    out_dir = args.output_dir / reg.zenodo_file.removesuffix(".zip")
+    for path in ref.extract_sdem(source, args.member, out_dir, force=args.force):
+        print(path)
+    return 0