"""Turn a chest CT into model input. Modes: npz a cube already preprocessed for this model (key ``ct``); centre-cropped to the input size totalseg NIfTI; lungs segmented with TotalSegmentator, then the exact preprocessing used in training fast NIfTI; same preprocessing, but the lungs are found by HU threshold instead of TotalSegmentator center NIfTI; same preprocessing, but the cube is centred on the middle of the volume NIfTI preprocessing: reorient to LPS, resample to the model's spacing (trilinear), pad with air, crop a cube around the lungs, store depth-first as raw HU int16, then centre-crop to the model's input size. ``totalseg`` needs the ``TotalSegmentator`` package and a GPU for reasonable speed; the other modes need ``monai`` and ``nibabel`` only. """ from __future__ import annotations import os import tempfile from typing import Optional, Sequence, Tuple import numpy as np import torch AIR_HU = -1024.0 LUNG_LABELS = (10, 11, 12, 13, 14) # TotalSegmentator lung lobes MODES = ("npz", "totalseg", "fast", "center") def crop_starts(shape: Sequence[int], roi: Sequence[int], lo: Sequence[int], hi: Sequence[int]) -> Tuple[int, ...]: """Start per axis of a crop of size ``roi`` around the box ``lo``..``hi``, kept inside the volume.""" starts = [] for size, r, a, b in zip(shape, roi, lo, hi): if size <= r: starts.append(0) continue a, b = int(a), int(b) extent = b - a + 1 start = (a + b) // 2 - r // 2 if extent >= r else a - (r - extent) // 2 starts.append(int(np.clip(start, 0, size - r))) return tuple(starts) def hu_lung_box(vol: np.ndarray) -> Optional[Tuple[np.ndarray, np.ndarray]]: """Bounding box of the lungs found by HU threshold, or None. The body is the largest connected region above -500 HU (this drops the table), filled slice by slice along the last (I-S) axis; the lungs are air below -400 HU strictly inside it, keeping the two largest connected regions. """ from scipy import ndimage lab, n = ndimage.label(vol > -500) if n == 0: return None sizes = ndimage.sum_labels(np.ones_like(lab, dtype=np.int8), lab, index=np.arange(1, n + 1)) body = lab == (int(np.argmax(sizes)) + 1) filled = np.zeros_like(body) for z in range(body.shape[2]): filled[:, :, z] = ndimage.binary_fill_holes(body[:, :, z]) air = filled & ~body & (vol < -400) lab, n = ndimage.label(air) if n == 0: return None sizes = ndimage.sum_labels(np.ones_like(lab, dtype=np.int8), lab, index=np.arange(1, n + 1)) keep = np.argsort(sizes)[::-1][:2] + 1 lungs = np.isin(lab, keep) if lungs.sum() < 10000: return None coords = np.argwhere(lungs) return coords.min(0), coords.max(0) def run_totalsegmentator(nifti_path: str, out_path: str, device: str = "gpu") -> str: """Segment the scan with TotalSegmentator (multi-label output) and return the mask path.""" from totalsegmentator.python_api import totalsegmentator totalsegmentator(nifti_path, out_path, ml=True, device=device, quiet=True) return out_path def preprocess_nifti(nifti_path: str, spacing_mm: float, cube_size: int, mode: str = "fast", totalseg_mask: Optional[str] = None, device: str = "gpu", return_volume: bool = False): """NIfTI to a raw-HU int16 cube [cube, cube, cube] in the model's layout (LPS, depth-first). With return_volume, also returns the resampled volume (depth-first) and the crop start per axis. """ from monai.transforms import (Compose, EnsureChannelFirstd, LoadImaged, Orientationd, Spacingd, SpatialPadd) if mode not in ("totalseg", "fast", "center"): raise ValueError(f"mode must be totalseg, fast or center for NIfTI input, got {mode!r}") tmp = None if mode == "totalseg" and totalseg_mask is None: tmp = tempfile.mkdtemp() totalseg_mask = run_totalsegmentator(nifti_path, os.path.join(tmp, "seg.nii.gz"), device) keys = ("ct", "seg") if mode == "totalseg" else ("ct",) roi = (cube_size,) * 3 steps = [LoadImaged(keys=keys, reader="NibabelReader"), EnsureChannelFirstd(keys=keys), Orientationd(keys=keys, axcodes="LPS", labels=(("L", "R"), ("P", "A"), ("I", "S"))), Spacingd(keys=("ct",), pixdim=(spacing_mm,) * 3, mode="trilinear", align_corners=True)] if mode == "totalseg": steps.append(Spacingd(keys=("seg",), pixdim=(spacing_mm,) * 3, mode="nearest", align_corners=True)) steps.append(SpatialPadd(keys=("ct",), spatial_size=roi, constant_values=AIR_HU)) if mode == "totalseg": steps.append(SpatialPadd(keys=("seg",), spatial_size=roi, constant_values=0.0)) paths = {"ct": nifti_path, **({"seg": totalseg_mask} if mode == "totalseg" else {})} d = Compose(steps)(paths) ct = np.asarray(d["ct"])[0] if mode == "totalseg": lungs = np.isin(np.asarray(d["seg"])[0], LUNG_LABELS) if not lungs.any(): raise ValueError(f"{nifti_path}: TotalSegmentator found no lungs") coords = np.argwhere(lungs) starts = crop_starts(ct.shape, roi, coords.min(0), coords.max(0)) elif mode == "fast": box = hu_lung_box(ct) if box is None: c = tuple(x // 2 for x in ct.shape) box = (c, c) starts = crop_starts(ct.shape, roi, box[0], box[1]) else: c = tuple(s // 2 for s in ct.shape) starts = crop_starts(ct.shape, roi, c, c) full = ct ct = ct[tuple(slice(s, s + r) for s, r in zip(starts, roi))] ct = np.clip(np.round(ct), np.iinfo(np.int16).min, np.iinfo(np.int16).max) if tmp is not None: for f in os.listdir(tmp): os.remove(os.path.join(tmp, f)) os.rmdir(tmp) cube = np.ascontiguousarray(np.transpose(ct, (2, 0, 1))).astype(np.int16) if return_volume: return cube, np.transpose(full, (2, 0, 1)), (starts[2], starts[0], starts[1]) return cube def center_crop(volume: np.ndarray, size: int) -> np.ndarray: off = [(s - size) // 2 for s in volume.shape[-3:]] if min(off) < 0: raise ValueError(f"volume {volume.shape[-3:]} is smaller than {size}^3") return volume[..., off[0]:off[0] + size, off[1]:off[1] + size, off[2]:off[2] + size] def load_volume(path: str, config: dict, mode: Optional[str] = None, totalseg_mask: Optional[str] = None, device: str = "gpu") -> torch.Tensor: """Read an npz cube or a NIfTI scan and return a [1, 1, S, S, S] raw-HU tensor for the model. ``config`` is the model config (a dict or the loaded config object; its ``input`` block sets spacing, cube and crop size). ``mode`` defaults to ``npz`` for .npz files and ``fast`` for NIfTI. """ inp = config["input"] if isinstance(config, dict) else config.input if mode is None: mode = "npz" if path.endswith(".npz") else "fast" if mode not in MODES: raise ValueError(f"mode must be one of {MODES}, got {mode!r}") if mode == "npz": with np.load(path) as d: cube = d["ct"] cube = cube[0] if cube.ndim == 4 else cube else: cube = preprocess_nifti(path, inp["spacing_mm"], inp["cube_size"], mode, totalseg_mask, device) cube = center_crop(cube, inp["crop_size"]) return torch.from_numpy(np.ascontiguousarray(cube)).unsqueeze(0).unsqueeze(0)