CT/liver/scripts/build_training_cache.py

#!/usr/bin/env python3
"""Create training-ready NPZ caches from preprocessed liver manifests.

Outputs:
  data/processed_training/waw_tace_npz/*.npz
  data/processed_training/msd_liver_npz/*.npz
  manifests/waw_tace_training_manifest.csv
  manifests/msd_liver_training_manifest.csv
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Iterable

import numpy as np
import pandas as pd
import SimpleITK as sitk


PHASES = ["native", "arterial", "portal", "delayed"]
PHASE_PRIORITY = ["arterial", "portal", "native", "delayed"]
HU_MIN = -150.0
HU_MAX = 400.0


def rel(path: Path, root: Path) -> str:
    path = path if path.is_absolute() else path.absolute()
    root = root if root.is_absolute() else root.absolute()
    try:
        return str(path.relative_to(root))
    except ValueError:
        return str(path)


def parse_spacing(value: str) -> tuple[float, float, float]:
    parts = [float(x) for x in value.split(",")]
    if len(parts) == 1:
        return (parts[0], parts[0], parts[0])
    if len(parts) != 3:
        raise ValueError("--spacing must be a single value or three comma-separated values")
    return tuple(parts)


def nonempty(value: object) -> bool:
    if value is None or pd.isna(value):
        return False
    return str(value).strip() != ""


def read_image(path: Path) -> sitk.Image:
    return sitk.ReadImage(str(path))


def make_reference_grid(image: sitk.Image, spacing_xyz: tuple[float, float, float]) -> sitk.Image:
    original_spacing = image.GetSpacing()
    original_size = image.GetSize()
    size = [
        max(1, int(round(original_size[i] * original_spacing[i] / spacing_xyz[i])))
        for i in range(3)
    ]
    ref = sitk.Image(size, sitk.sitkFloat32)
    ref.SetOrigin(image.GetOrigin())
    ref.SetSpacing(spacing_xyz)
    ref.SetDirection(image.GetDirection())
    return ref


def resample_to_ref(
    image: sitk.Image,
    ref: sitk.Image,
    *,
    interpolator: int,
    default_value: float = 0.0,
    pixel_type: int | None = None,
) -> sitk.Image:
    if pixel_type is None:
        pixel_type = image.GetPixelID()
    return sitk.Resample(
        image,
        ref,
        sitk.Transform(),
        interpolator,
        default_value,
        pixel_type,
    )


def sitk_to_array(image: sitk.Image) -> np.ndarray:
    return sitk.GetArrayFromImage(image)


def normalize_ct(array: np.ndarray) -> np.ndarray:
    array = np.clip(array.astype(np.float32), HU_MIN, HU_MAX)
    array = (array - HU_MIN) / (HU_MAX - HU_MIN)
    return array.astype(np.float16)


def bbox_from_mask(mask: np.ndarray, margin_vox: tuple[int, int, int]) -> tuple[slice, slice, slice]:
    coords = np.argwhere(mask > 0)
    if coords.size == 0:
        return tuple(slice(0, s) for s in mask.shape)  # type: ignore[return-value]
    lo = coords.min(axis=0)
    hi = coords.max(axis=0) + 1
    for axis in range(3):
        lo[axis] = max(0, lo[axis] - margin_vox[axis])
        hi[axis] = min(mask.shape[axis], hi[axis] + margin_vox[axis])
    return slice(lo[0], hi[0]), slice(lo[1], hi[1]), slice(lo[2], hi[2])


def choose_reference_phase(row: pd.Series) -> str | None:
    # Prefer a phase with manual tumor supervision so the support map keeps its
    # native grid before other phases are resampled onto it.
    for phase in PHASES:
        if int(row.get(f"phase_available_{phase}", 0)) == 1 and nonempty(row.get(f"tumor_mask_{phase}_path")):
            return phase
    for phase in PHASE_PRIORITY:
        if int(row.get(f"phase_available_{phase}", 0)) == 1 and nonempty(row.get(f"ct_{phase}_path")):
            return phase
    return None


def save_npz(path: Path, compressed: bool, **arrays: np.ndarray) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if compressed:
        np.savez_compressed(path, **arrays)
    else:
        np.savez(path, **arrays)


def process_waw_case(
    row: pd.Series,
    root: Path,
    out_dir: Path,
    spacing_xyz: tuple[float, float, float],
    margin_mm: float,
    overwrite: bool,
    compressed: bool,
) -> dict[str, object] | None:
    patient_id = str(row["patient_id"])
    out_path = out_dir / f"{patient_id}.npz"
    if out_path.exists() and not overwrite:
        return {
            "dataset": "waw_tace",
            "patient_id": patient_id,
            "case_id": patient_id,
            "npz_path": rel(out_path, root),
            "skipped_existing": 1,
        }

    ref_phase = choose_reference_phase(row)
    if ref_phase is None:
        return None
    ref_ct_path = root / str(row[f"ct_{ref_phase}_path"])
    ref_grid = make_reference_grid(read_image(ref_ct_path), spacing_xyz)
    margin_vox = tuple(max(1, int(round(margin_mm / s))) for s in spacing_xyz[::-1])

    image_channels = []
    phase_available = []
    liver_union = np.zeros(ref_grid.GetSize()[::-1], dtype=bool)
    tumor_union = np.zeros(ref_grid.GetSize()[::-1], dtype=bool)

    for phase in PHASES:
        ct_path_value = row.get(f"ct_{phase}_path")
        if nonempty(ct_path_value):
            ct = read_image(root / str(ct_path_value))
            ct_resampled = resample_to_ref(
                ct,
                ref_grid,
                interpolator=sitk.sitkLinear,
                default_value=HU_MIN,
                pixel_type=sitk.sitkFloat32,
            )
            image_channels.append(normalize_ct(sitk_to_array(ct_resampled)))
            phase_available.append(1)
        else:
            image_channels.append(np.zeros(ref_grid.GetSize()[::-1], dtype=np.float16))
            phase_available.append(0)

        liver_path_value = row.get(f"liver_mask_{phase}_path")
        if nonempty(liver_path_value):
            liver = read_image(root / str(liver_path_value))
            liver_resampled = resample_to_ref(
                liver,
                ref_grid,
                interpolator=sitk.sitkNearestNeighbor,
                default_value=0,
                pixel_type=sitk.sitkUInt8,
            )
            liver_union |= sitk_to_array(liver_resampled) > 0

        tumor_path_value = row.get(f"tumor_mask_{phase}_path")
        if nonempty(tumor_path_value):
            tumor = read_image(root / str(tumor_path_value))
            tumor_resampled = resample_to_ref(
                tumor,
                ref_grid,
                interpolator=sitk.sitkNearestNeighbor,
                default_value=0,
                pixel_type=sitk.sitkUInt8,
            )
            tumor_union |= sitk_to_array(tumor_resampled) > 0

    crop_source = liver_union | tumor_union
    crop = bbox_from_mask(crop_source, margin_vox)
    image = np.stack([channel[crop] for channel in image_channels], axis=0).astype(np.float16)
    liver_mask = liver_union[crop].astype(np.uint8)
    tumor_mask = tumor_union[crop].astype(np.uint8)

    clinical_cols = [
        c for c in row.index
        if not c.endswith("_missing")
        and c not in set(["dataset", "patient_id", "case_id"])
        and not c.endswith("_path")
        and not c.startswith("ct_")
        and not c.startswith("organ_mask_")
        and not c.startswith("liver_mask_")
        and not c.startswith("tumor_mask_")
    ]
    numeric = pd.to_numeric(row[clinical_cols], errors="coerce")
    clinical_values = numeric.to_numpy(dtype=np.float32)
    clinical_missing = np.isnan(clinical_values).astype(np.uint8)
    clinical_values = np.nan_to_num(clinical_values, nan=0.0)

    save_npz(
        out_path,
        compressed,
        image=image,
        liver_mask=liver_mask,
        tumor_mask=tumor_mask,
        phase_available=np.asarray(phase_available, dtype=np.uint8),
        clinical_values=clinical_values,
        clinical_missing=clinical_missing,
        spacing=np.asarray(spacing_xyz, dtype=np.float32),
        crop_start=np.asarray([crop[0].start, crop[1].start, crop[2].start], dtype=np.int32),
        crop_stop=np.asarray([crop[0].stop, crop[1].stop, crop[2].stop], dtype=np.int32),
        label_response=np.asarray([row.get("label_response", np.nan)], dtype=np.float32),
        label_progression=np.asarray([row.get("label_progression", np.nan)], dtype=np.float32),
        time_pfs=np.asarray([row.get("time_pfs", np.nan)], dtype=np.float32),
        event_pfs=np.asarray([row.get("event_pfs", np.nan)], dtype=np.float32),
        time_os=np.asarray([row.get("time_os", np.nan)], dtype=np.float32),
        event_os=np.asarray([row.get("event_os", np.nan)], dtype=np.float32),
        time_ttp=np.asarray([row.get("time_ttp", np.nan)], dtype=np.float32),
        event_ttp=np.asarray([row.get("event_ttp", np.nan)], dtype=np.float32),
    )

    return {
        "dataset": "waw_tace",
        "patient_id": patient_id,
        "case_id": patient_id,
        "npz_path": rel(out_path, root),
        "reference_phase": ref_phase,
        "spacing_x": spacing_xyz[0],
        "spacing_y": spacing_xyz[1],
        "spacing_z": spacing_xyz[2],
        "shape_c": image.shape[0],
        "shape_z": image.shape[1],
        "shape_y": image.shape[2],
        "shape_x": image.shape[3],
        "phase_available_native": phase_available[0],
        "phase_available_arterial": phase_available[1],
        "phase_available_portal": phase_available[2],
        "phase_available_delayed": phase_available[3],
        "has_liver_mask": int(liver_mask.any()),
        "has_tumor_mask": int(tumor_mask.any()),
        "label_response": row.get("label_response", np.nan),
        "label_progression": row.get("label_progression", np.nan),
        "time_pfs": row.get("time_pfs", np.nan),
        "event_pfs": row.get("event_pfs", np.nan),
        "time_os": row.get("time_os", np.nan),
        "event_os": row.get("event_os", np.nan),
        "time_ttp": row.get("time_ttp", np.nan),
        "event_ttp": row.get("event_ttp", np.nan),
        "skipped_existing": 0,
    }


def build_waw_cache(args: argparse.Namespace, root: Path) -> pd.DataFrame:
    manifest = pd.read_csv(root / "manifests" / "waw_tace_manifest.csv")
    out_dir = root / "data" / "processed_training" / "waw_tace_npz"
    rows = []
    spacing_xyz = parse_spacing(args.spacing)
    iterable: Iterable[tuple[int, pd.Series]] = manifest.iterrows()
    for i, row in iterable:
        if args.limit and len(rows) >= args.limit:
            break
        result = process_waw_case(
            row,
            root,
            out_dir,
            spacing_xyz,
            args.margin_mm,
            args.overwrite,
            args.compressed,
        )
        if result is not None:
            rows.append(result)
        if len(rows) % args.progress_every == 0:
            print(f"WAW cached {len(rows)}/{len(manifest)}")
    df = pd.DataFrame(rows)
    path = root / "manifests" / "waw_tace_training_manifest.csv"
    path.parent.mkdir(parents=True, exist_ok=True)
    df.to_csv(path, index=False)
    print(f"Wrote {path} ({len(df)} rows)")
    return df


def process_msd_case(
    row: pd.Series,
    root: Path,
    out_dir: Path,
    spacing_xyz: tuple[float, float, float],
    margin_mm: float,
    overwrite: bool,
    compressed: bool,
) -> dict[str, object]:
    case_id = str(row["case_id"])
    out_path = out_dir / f"{case_id}.npz"
    if out_path.exists() and not overwrite:
        with np.load(out_path) as data:
            shape = data["image"].shape
        return {
            "dataset": "msd_liver",
            "patient_id": case_id,
            "case_id": case_id,
            "npz_path": rel(out_path, root),
            "shape_c": shape[0],
            "shape_z": shape[1],
            "shape_y": shape[2],
            "shape_x": shape[3],
            "skipped_existing": 1,
        }

    image_src = root / str(row["ct_path"])
    label_src = root / str(row["label_path"])
    image = read_image(image_src)
    label = read_image(label_src)
    ref_grid = make_reference_grid(image, spacing_xyz)
    image_resampled = resample_to_ref(
        image,
        ref_grid,
        interpolator=sitk.sitkLinear,
        default_value=HU_MIN,
        pixel_type=sitk.sitkFloat32,
    )
    label_resampled = resample_to_ref(
        label,
        ref_grid,
        interpolator=sitk.sitkNearestNeighbor,
        default_value=0,
        pixel_type=sitk.sitkUInt8,
    )
    image_arr = normalize_ct(sitk_to_array(image_resampled))
    label_arr = sitk_to_array(label_resampled).astype(np.uint8)
    margin_vox = tuple(max(1, int(round(margin_mm / s))) for s in spacing_xyz[::-1])
    crop = bbox_from_mask(label_arr > 0, margin_vox)
    image_arr = image_arr[crop][None, ...].astype(np.float16)
    label_arr = label_arr[crop].astype(np.uint8)
    save_npz(
        out_path,
        compressed,
        image=image_arr,
        label=label_arr,
        spacing=np.asarray(spacing_xyz, dtype=np.float32),
        crop_start=np.asarray([crop[0].start, crop[1].start, crop[2].start], dtype=np.int32),
        crop_stop=np.asarray([crop[0].stop, crop[1].stop, crop[2].stop], dtype=np.int32),
    )
    return {
        "dataset": "msd_liver",
        "patient_id": case_id,
        "case_id": case_id,
        "npz_path": rel(out_path, root),
        "spacing_x": spacing_xyz[0],
        "spacing_y": spacing_xyz[1],
        "spacing_z": spacing_xyz[2],
        "shape_c": image_arr.shape[0],
        "shape_z": image_arr.shape[1],
        "shape_y": image_arr.shape[2],
        "shape_x": image_arr.shape[3],
        "has_liver_mask": int((label_arr == 1).any()),
        "has_tumor_mask": int((label_arr == 2).any()),
        "skipped_existing": 0,
    }


def build_msd_cache(args: argparse.Namespace, root: Path) -> pd.DataFrame:
    manifest = pd.read_csv(root / "manifests" / "msd_liver_manifest.csv")
    out_dir = root / "data" / "processed_training" / "msd_liver_npz"
    rows = []
    spacing_xyz = parse_spacing(args.spacing)
    for _, row in manifest.iterrows():
        if args.limit and len(rows) >= args.limit:
            break
        rows.append(
            process_msd_case(
                row,
                root,
                out_dir,
                spacing_xyz,
                args.margin_mm,
                args.overwrite,
                args.compressed,
            )
        )
        if len(rows) % args.progress_every == 0:
            print(f"MSD cached {len(rows)}/{len(manifest)}")
    df = pd.DataFrame(rows)
    path = root / "manifests" / "msd_liver_training_manifest.csv"
    path.parent.mkdir(parents=True, exist_ok=True)
    df.to_csv(path, index=False)
    print(f"Wrote {path} ({len(df)} rows)")
    return df


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--project-root", type=Path, default=Path(__file__).resolve().parents[1])
    parser.add_argument("--dataset", choices=["waw", "msd", "all"], default="all")
    parser.add_argument("--spacing", default="2.0", help="Target spacing in xyz order, e.g. 2.0 or 2.0,2.0,2.0.")
    parser.add_argument("--margin-mm", type=float, default=20.0)
    parser.add_argument("--limit", type=int, default=0)
    parser.add_argument("--progress-every", type=int, default=10)
    parser.add_argument("--overwrite", action="store_true")
    parser.add_argument("--compressed", action="store_true", help="Use compressed NPZ. Slower, smaller.")
    args = parser.parse_args()

    root = args.project_root.resolve()
    config_path = root / "data" / "processed_training" / "cache_config.json"
    config_path.parent.mkdir(parents=True, exist_ok=True)
    config_path.write_text(json.dumps(vars(args) | {"project_root": str(root)}, indent=2))

    if args.dataset in {"waw", "all"}:
        build_waw_cache(args, root)
    if args.dataset in {"msd", "all"}:
        build_msd_cache(args, root)


if __name__ == "__main__":
    main()