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}") |