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)