File size: 5,778 Bytes
ee594f0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""
preprocess_ucsf.py

Adapts the repo's 1_registration.py + 2_cutbackground.py pipeline to the
UCSF-PDGM file naming you actually have (T1c, T2, FLAIR, tumor_segmentation).

Pipeline per subject (matches the paper's described preprocessing):
    1. Register T1c -> SRI24 atlas (Affine)
    2. Register T2  -> registered T1c (Affine)   [fresh registration, like the repo script]
    3. Register FLAIR -> registered T1c (Affine)
    4. Warp tumor_segmentation using T1c's transform (nearestNeighbor -- masks
       must NOT be intensity-registered, they ride along on T1c's transform)
    5. Crop to combined nonzero bounding box (T1c+T2+FLAIR), then zero-pad to
       (160, 192, 160)

This is SLOW (ANTs registration is CPU-bound). Test on a handful of subjects
first with LIMIT below before committing to the full 500.

Requires: pip install antspyx nibabel numpy
"""

import os
import glob
import numpy as np
import ants
import nibabel as nib

# ---- EDIT THESE FOR YOUR MACHINE ----
RAW_ROOT = r"D:\jainam\UCSF-PDGM-v5"                      # where datadownload.py put the raw files
OUT_ROOT = r"D:\jainam\UCSF-PDGM-v5-preprocessed"          # where final preprocessed volumes go
ATLAS_PATH = r"D:\jainam\CMTLNet\CMTLNet\preprocessing\regdata\spgr_unstrip_lps_b.nii.gz"
TARGET_SHAPE = (160, 192, 160)
LIMIT = None   # set to None to run all subjects; test with a small number first!
# --------------------------------------


def get_bbox_from_mask(mask, outside_value=0):
    coords = np.where(mask != outside_value)
    return (
        [int(coords[0].min()), int(coords[0].max()) + 1],
        [int(coords[1].min()), int(coords[1].max()) + 1],
        [int(coords[2].min()), int(coords[2].max()) + 1],
    )


def crop_to_bbox(image, bbox):
    resizer = tuple(slice(b[0], b[1]) for b in bbox)
    return image[resizer]


def pad_to_shape(arr, target_shape):
    """Pad with zeros to target_shape (assumes arr is <= target on every axis
    after the bbox crop; if not, center-crop the overflow first)."""
    out = np.zeros(target_shape, dtype=arr.dtype)
    src_slices, dst_slices = [], []
    for s, t in zip(arr.shape, target_shape):
        if s <= t:
            pad_start = (t - s) // 2
            src_slices.append(slice(0, s))
            dst_slices.append(slice(pad_start, pad_start + s))
        else:
            start = (s - t) // 2
            src_slices.append(slice(start, start + t))
            dst_slices.append(slice(0, t))
    out[tuple(dst_slices)] = arr[tuple(src_slices)]
    return out


def register_subject(sid: str, atlas):
    raw_folder = os.path.join(RAW_ROOT, f"{sid}_nifti")
    t1c_path = os.path.join(raw_folder, f"{sid}_T1c.nii.gz")
    t2_path = os.path.join(raw_folder, f"{sid}_T2.nii.gz")
    flair_path = os.path.join(raw_folder, f"{sid}_FLAIR.nii.gz")
    mask_path = os.path.join(raw_folder, f"{sid}_tumor_segmentation.nii.gz")

    if not all(os.path.exists(p) for p in [t1c_path, t2_path, flair_path, mask_path]):
        print(f"  [skip] {sid}: missing one or more raw files")
        return

    # 1. T1c -> atlas
    t1c = ants.image_read(t1c_path)
    reg_t1c = ants.registration(fixed=atlas, moving=t1c, type_of_transform="Affine")
    t1c_warped = reg_t1c["warpedmovout"]

    # 2. T2 -> registered T1c
    t2 = ants.image_read(t2_path)
    reg_t2 = ants.registration(fixed=t1c_warped, moving=t2, type_of_transform="Affine")
    t2_warped = reg_t2["warpedmovout"]

    # 3. FLAIR -> registered T1c
    flair = ants.image_read(flair_path)
    reg_flair = ants.registration(fixed=t1c_warped, moving=flair, type_of_transform="Affine")
    flair_warped = reg_flair["warpedmovout"]

    # 4. mask rides on T1c's transform, nearest-neighbor (no independent registration)
    mask = ants.image_read(mask_path)
    mask_warped = ants.apply_transforms(
        fixed=atlas, moving=mask,
        transformlist=reg_t1c["fwdtransforms"],
        interpolator="nearestNeighbor",
    )

    # convert to numpy for crop/pad
    t1c_np = t1c_warped.numpy()
    t2_np = t2_warped.numpy()
    flair_np = flair_warped.numpy()
    mask_np = mask_warped.numpy()

    combined = t1c_np + t2_np + flair_np
    bbox = get_bbox_from_mask(combined)

    t1c_c = pad_to_shape(crop_to_bbox(t1c_np, bbox), TARGET_SHAPE)
    t2_c = pad_to_shape(crop_to_bbox(t2_np, bbox), TARGET_SHAPE)
    flair_c = pad_to_shape(crop_to_bbox(flair_np, bbox), TARGET_SHAPE)
    mask_c = pad_to_shape(crop_to_bbox(mask_np, bbox), TARGET_SHAPE)
    mask_c = (mask_c > 0).astype(np.uint8)

    out_folder = os.path.join(OUT_ROOT, sid)
    os.makedirs(out_folder, exist_ok=True)
    affine = np.eye(4)  # spatial correspondence no longer meaningful post-crop/pad; identity is fine for a CNN pipeline
    nib.Nifti1Image(t1c_c.astype(np.float32), affine).to_filename(os.path.join(out_folder, "T1C.nii.gz"))
    nib.Nifti1Image(t2_c.astype(np.float32), affine).to_filename(os.path.join(out_folder, "T2.nii.gz"))
    nib.Nifti1Image(flair_c.astype(np.float32), affine).to_filename(os.path.join(out_folder, "FLAIR.nii.gz"))
    nib.Nifti1Image(mask_c, affine).to_filename(os.path.join(out_folder, "mask.nii.gz"))
    print(f"  [done] {sid}  final shape={t1c_c.shape}")


if __name__ == "__main__":
    import warnings
    warnings.filterwarnings("ignore")

    atlas = ants.image_read(ATLAS_PATH)

    subject_folders = sorted(glob.glob(os.path.join(RAW_ROOT, "UCSF-PDGM-*_nifti")))
    sids = [os.path.basename(f).replace("_nifti", "") for f in subject_folders]

    if LIMIT is not None:
        sids = sids[:LIMIT]

    print(f"Processing {len(sids)} subjects...")
    for i, sid in enumerate(sids):
        print(f"[{i+1}/{len(sids)}] {sid}")
        try:
            register_subject(sid, atlas)
        except Exception as e:
            print(f"  [ERROR] {sid}: {e}")