File size: 7,070 Bytes
04c01e0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | """Input preprocessing for the JECT encoder.
Input contract used during pretraining (features degrade without warning otherwise):
1. Orientation LPS, axes ordered (D, H, W) = (R-L, A-P, I-S), as produced by MONAI's
``Orientationd(axcodes="LPS")``.
2. Isotropic resampling, then a lung-centred crop/pad to a fixed cube of raw HU
(int16, padded with -1024 HU):
* 1.5 mm spacing, 256^3 cube: input for the 224 checkpoint
* 1.0 mm spacing, 384^3 cube: input for the 336 checkpoint
Both give a ~336 mm physical field of view at the model input.
3. Centre crop / pad (with -1000 HU) from that cube to the model's input size.
4. HU window, then linear scale to [0, 1]. The default is the general window
(id 2, centre 0, width 2000, i.e. [-1000, 1000]). Pass the same id to the encoder
as ``window_id``; it selects an additive token embedding.
``preprocess_hu_volume`` performs steps 3-4 on an already-resampled cube and is the
usual entry point. ``resample_to_spacing`` covers the resampling in step 2 for raw
NIfTI input; it is a plain trilinear resize without the lung-bounding-box crop, so
features differ slightly from those of the original pipeline.
"""
from __future__ import annotations
import os
from typing import Optional, Sequence, Tuple
import numpy as np
import torch
try: # importable as a package module or as a plain script in this directory
from .ject_encoder import CT_TYPE_MAP, DEFAULT_CT_TYPE, GENERAL_WINDOW_ID, WINDOW_PARAMS
except ImportError:
from ject_encoder import CT_TYPE_MAP, DEFAULT_CT_TYPE, GENERAL_WINDOW_ID, WINDOW_PARAMS
Triple = Tuple[int, int, int]
AIR_HU = -1000.0 # pad value for the centre crop/pad
# ---------------------------------------------------------------------------
# Windowing
# ---------------------------------------------------------------------------
def apply_window(volume_hu: np.ndarray, window_id: int = GENERAL_WINDOW_ID) -> np.ndarray:
"""Clamp raw HU to a window and rescale to [0, 1]."""
if window_id not in WINDOW_PARAMS:
raise ValueError(f"window_id must be one of {sorted(WINDOW_PARAMS)}, got {window_id}")
p = WINDOW_PARAMS[window_id]
low = p["center"] - p["width"] / 2.0
high = p["center"] + p["width"] / 2.0
out = (volume_hu.astype(np.float32) - low) / (high - low)
return np.clip(out, 0.0, 1.0)
def ct_type_to_id(ct_type) -> int:
"""Map a ct_type string ('non-contrast' | 'contrast' | 'ldct') to its embedding index."""
if ct_type is None:
return DEFAULT_CT_TYPE
if isinstance(ct_type, (int, np.integer)):
return int(ct_type)
return CT_TYPE_MAP.get(str(ct_type).strip().lower(), DEFAULT_CT_TYPE)
# ---------------------------------------------------------------------------
# Crop / pad
# ---------------------------------------------------------------------------
def make_crop_pad_transform(src_shape: Triple, dst_shape: Triple, random_crop: bool = False):
"""Slices + pads that take ``src_shape`` to exactly ``dst_shape`` (centre crop by default)."""
slices, pads = [], []
for src, dst in zip(src_shape, dst_shape):
if src >= dst:
start = (src - dst) // 2
if random_crop and src > dst:
start = int(np.random.randint(0, src - dst + 1))
slices.append(slice(start, start + dst))
pads.append((0, 0))
else:
slices.append(slice(0, src))
before = (dst - src) // 2
pads.append((before, dst - src - before))
return tuple(slices), tuple(pads)
def apply_crop_pad_3d(arr: np.ndarray, slices, pads, constant: float = AIR_HU) -> np.ndarray:
"""Apply crop/pad to the last three dims of ``arr``."""
cropped = arr[(...,) + tuple(slices)]
if any(a > 0 or b > 0 for a, b in pads):
pad_width = [(0, 0)] * (cropped.ndim - 3) + list(pads)
cropped = np.pad(cropped, pad_width=pad_width, mode="constant", constant_values=constant)
return cropped
def center_crop_pad(volume_hu: np.ndarray, target: Triple) -> np.ndarray:
"""Centre crop/pad a raw-HU volume (last three dims) to ``target``, padding with air."""
slices, pads = make_crop_pad_transform(tuple(volume_hu.shape[-3:]), tuple(target))
return apply_crop_pad_3d(volume_hu, slices, pads, constant=AIR_HU)
# ---------------------------------------------------------------------------
# Entry points
# ---------------------------------------------------------------------------
def preprocess_hu_volume(volume_hu: np.ndarray, input_size: Triple,
window_id: int = GENERAL_WINDOW_ID) -> torch.Tensor:
"""Convert a raw-HU cube to a model input tensor ``[1, D, H, W]`` in [0, 1].
Crop/pad happens in HU space (padding with air) before windowing, so padded
borders map to 0.0 in the general window.
"""
vol = np.asarray(volume_hu)
if vol.ndim == 4:
if vol.shape[0] != 1:
raise ValueError(f"expected a single-channel volume, got shape {vol.shape}")
vol = vol[0]
if vol.ndim != 3:
raise ValueError(f"expected a 3D HU volume, got shape {vol.shape}")
vol = center_crop_pad(vol, tuple(input_size))
return torch.from_numpy(apply_window(vol, window_id)).unsqueeze(0)
def load_npz_volume(path: str, input_size: Triple, key: str = "ct",
window_id: int = GENERAL_WINDOW_ID) -> torch.Tensor:
"""Load a preprocessed ``.npz`` (raw int16 HU under ``key``) into a model input tensor."""
if not os.path.exists(path) and os.path.exists(path + ".npz"):
path = path + ".npz"
with np.load(path) as d:
if key not in d:
raise KeyError(f"{path} has no '{key}' array (found {list(d.files)})")
ct = d[key]
return preprocess_hu_volume(ct, input_size, window_id=window_id)
def resample_to_spacing(volume_hu: np.ndarray, src_spacing: Sequence[float],
dst_spacing: float = 1.5) -> np.ndarray:
"""Trilinear-resample a raw-HU volume to isotropic ``dst_spacing`` mm.
Convenience for raw NIfTI input. It does not apply the lung-bounding-box crop
used in pretraining; see the module docstring.
"""
vol = np.asarray(volume_hu, dtype=np.float32)
if vol.ndim != 3:
raise ValueError(f"expected a 3D HU volume, got shape {vol.shape}")
if len(src_spacing) != 3:
raise ValueError(f"src_spacing must have 3 entries, got {src_spacing!r}")
scale = [float(s) / float(dst_spacing) for s in src_spacing]
out_shape = tuple(max(1, int(round(n * s))) for n, s in zip(vol.shape, scale))
t = torch.from_numpy(vol)[None, None]
t = torch.nn.functional.interpolate(t, size=out_shape, mode="trilinear", align_corners=True)
return t[0, 0].numpy()
def stack_batch(volumes: Sequence[torch.Tensor]) -> torch.Tensor:
"""Stack [1, D, H, W] tensors into a [B, 1, D, H, W] batch."""
if not volumes:
raise ValueError("stack_batch got an empty list")
return torch.stack([v if v.ndim == 4 else v.unsqueeze(0) for v in volumes], dim=0)
|