| |
| |
|
|
| import argparse |
| import logging |
| import sys |
| import time |
| from multiprocessing import Pool |
| from pathlib import Path |
|
|
| import nibabel as nib |
| import numpy as np |
| from PIL import Image |
|
|
| INPUT_ROOT = Path("./BraTS2023-PED") |
| OUTPUT_BASE = Path("./BraTS2023-PED/slides") |
|
|
| DATA_SUBDIRS = [ |
| "ASNR-MICCAI-BraTS2023-PED-Challenge-TrainingData", |
| "ASNR-MICCAI-BraTS2023-PED-Challenge-ValidationData", |
| ] |
|
|
| TARGET_MODALITIES = { |
| "t1n": "t1n", |
| "t2w": "t2w", |
| } |
|
|
| NUM_SLICES = 64 |
| DONE_MARKER = "_DONE" |
|
|
| LOW_PERCENTILE = 0.5 |
| HIGH_PERCENTILE = 99.5 |
| MIN_FOREGROUND_RATIO = 0.015 |
|
|
|
|
| def setup_logging(): |
| OUTPUT_BASE.mkdir(parents=True, exist_ok=True) |
| log_path = OUTPUT_BASE / "slice_brats_ped_t1n_t2w.log" |
|
|
| fmt = "%(asctime)s [%(levelname)s] %(message)s" |
| handler_file = logging.FileHandler(log_path, mode="a", encoding="utf-8") |
| handler_console = logging.StreamHandler(sys.stdout) |
|
|
| logging.basicConfig( |
| level=logging.INFO, |
| format=fmt, |
| handlers=[handler_file, handler_console], |
| ) |
|
|
| try: |
| sys.stdout.reconfigure(line_buffering=True) |
| except Exception: |
| pass |
|
|
|
|
| def get_slice_axis(data: np.ndarray) -> int: |
| if data.ndim != 3: |
| raise ValueError(f"Only 3D volume is supported, but got shape={data.shape}") |
| return 2 |
|
|
|
|
| def normalize_mri_volume(data: np.ndarray) -> np.ndarray: |
| vol = data.astype(np.float32) |
| vol = np.nan_to_num(vol, nan=0.0, posinf=0.0, neginf=0.0) |
|
|
| foreground = vol[vol > 0] |
| if foreground.size == 0: |
| return np.zeros_like(vol, dtype=np.uint8) |
|
|
| lo = np.percentile(foreground, LOW_PERCENTILE) |
| hi = np.percentile(foreground, HIGH_PERCENTILE) |
|
|
| if hi <= lo: |
| lo = float(foreground.min()) |
| hi = float(foreground.max()) |
| if hi <= lo: |
| return np.zeros_like(vol, dtype=np.uint8) |
|
|
| vol = np.clip(vol, lo, hi) |
| vol = (vol - lo) / (hi - lo) * 255.0 |
| vol = np.clip(vol, 0, 255).astype(np.uint8) |
| return vol |
|
|
|
|
| def is_informative_slice(slice_2d: np.ndarray) -> bool: |
| sl = np.nan_to_num(slice_2d.astype(np.float32), nan=0.0, posinf=0.0, neginf=0.0) |
| nonzero_ratio = np.count_nonzero(sl > 0) / sl.size |
| return nonzero_ratio >= MIN_FOREGROUND_RATIO |
|
|
|
|
| def get_valid_slice_indices(data: np.ndarray, slice_axis: int): |
| valid_indices = [] |
| n_slices = data.shape[slice_axis] |
|
|
| for idx in range(n_slices): |
| if slice_axis == 0: |
| sl = data[idx, :, :] |
| elif slice_axis == 1: |
| sl = data[:, idx, :] |
| else: |
| sl = data[:, :, idx] |
|
|
| if is_informative_slice(sl): |
| valid_indices.append(idx) |
|
|
| return valid_indices |
|
|
|
|
| def sample_indices_from_valid(valid_indices, num_slices): |
| if len(valid_indices) == 0: |
| return [] |
|
|
| if len(valid_indices) >= num_slices: |
| pos = np.linspace(0, len(valid_indices) - 1, num_slices, dtype=int) |
| return [valid_indices[p] for p in pos] |
| else: |
| pos = np.linspace(0, len(valid_indices) - 1, num_slices) |
| pos = np.round(pos).astype(int) |
| return [valid_indices[p] for p in pos] |
|
|
|
|
| def discover_brats_files(): |
| tasks = [] |
|
|
| for subdir_name in DATA_SUBDIRS: |
| subdir = INPUT_ROOT / subdir_name |
| if not subdir.exists(): |
| logging.warning(f"Skip missing directory: {subdir}") |
| continue |
|
|
| split_name = "train" if "TrainingData" in subdir_name else "val" |
|
|
| for case_dir in sorted(subdir.iterdir()): |
| if not case_dir.is_dir(): |
| continue |
|
|
| case_id = case_dir.name |
|
|
| modality_paths = {} |
| for modality in TARGET_MODALITIES: |
| matched = sorted(case_dir.glob(f"*-{modality}.nii.gz")) |
| if len(matched) == 0: |
| logging.warning(f"Skip {case_id}: missing {modality} in {case_dir}") |
| continue |
| modality_paths[modality] = matched[0] |
|
|
| for modality, nii_path in modality_paths.items(): |
| out_dir = OUTPUT_BASE / split_name / modality / case_id |
| if (out_dir / DONE_MARKER).exists(): |
| logging.info(f"Skip {case_id} [{modality}]: already done") |
| continue |
|
|
| tasks.append((nii_path, out_dir, case_id, split_name, modality)) |
|
|
| return tasks |
|
|
|
|
| def process_one_volume(args): |
| nii_path, out_dir, case_id, split_name, modality = args |
|
|
| try: |
| img = nib.load(str(nii_path)) |
| data = np.asarray(img.dataobj) |
|
|
| if data.ndim != 3: |
| return (case_id, modality, False, f"Expected 3D data, got shape={data.shape}") |
|
|
| slice_axis = get_slice_axis(data) |
| n_slices = data.shape[slice_axis] |
|
|
| if n_slices <= 0: |
| return (case_id, modality, False, f"Invalid number of slices: {n_slices}") |
|
|
| norm_data = normalize_mri_volume(data) |
| valid_indices = get_valid_slice_indices(data, slice_axis) |
|
|
| if len(valid_indices) == 0: |
| indices = np.linspace(0, n_slices - 1, NUM_SLICES, dtype=int).tolist() |
| else: |
| indices = sample_indices_from_valid(valid_indices, NUM_SLICES) |
|
|
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| for i, idx in enumerate(indices): |
| if slice_axis == 0: |
| sl = norm_data[idx, :, :] |
| elif slice_axis == 1: |
| sl = norm_data[:, idx, :] |
| else: |
| sl = norm_data[:, :, idx] |
|
|
| Image.fromarray(sl, mode="L").save(out_dir / f"slice_{i:03d}.png") |
|
|
| (out_dir / DONE_MARKER).touch() |
|
|
| return ( |
| case_id, |
| modality, |
| True, |
| f"OK | split={split_name} | valid_slices={len(valid_indices)}/{n_slices}" |
| ) |
|
|
| except Exception as e: |
| return (case_id, modality, False, str(e)) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser( |
| description="Slice BraTS2023-PED T1n/T2w NIfTI volumes to PNG" |
| ) |
| parser.add_argument("--workers", type=int, default=8, help="number of workers") |
| parser.add_argument("--num_slices", type=int, default=64, help="number of sampled slices") |
| args = parser.parse_args() |
|
|
| global NUM_SLICES |
| NUM_SLICES = args.num_slices |
|
|
| setup_logging() |
|
|
| logging.info(f"Input root: {INPUT_ROOT}") |
| logging.info(f"Output dir: {OUTPUT_BASE}") |
| logging.info(f"Target modalities: {list(TARGET_MODALITIES.keys())}") |
| logging.info( |
| f"Settings -> percentile normalize: " |
| f"p{LOW_PERCENTILE}-p{HIGH_PERCENTILE}, " |
| f"num_slices={NUM_SLICES}, workers={args.workers}" |
| ) |
|
|
| tasks = discover_brats_files() |
| total = len(tasks) |
|
|
| logging.info(f"Found {total} volumes to process.") |
|
|
| if total == 0: |
| logging.info("Nothing to do.") |
| return |
|
|
| done = 0 |
| failed = 0 |
| failed_files = [] |
| t0 = time.time() |
|
|
| with Pool(processes=args.workers) as pool: |
| for case_id, modality, success, msg in pool.imap_unordered(process_one_volume, tasks): |
| done += 1 |
| if success: |
| logging.info(f"SUCCESS {case_id} [{modality}]: {msg}") |
| else: |
| failed += 1 |
| failed_files.append((case_id, modality, msg)) |
| logging.error(f"FAILED {case_id} [{modality}]: {msg}") |
|
|
| if done % 10 == 0 or done == total: |
| elapsed = time.time() - t0 |
| rate = done / elapsed if elapsed > 0 else 0 |
| eta = (total - done) / rate if rate > 0 else 0 |
| logging.info( |
| f"{done}/{total} done ({done/total*100:.1f}%) | " |
| f"{rate:.2f} vol/s | ETA {eta/60:.1f} min" |
| ) |
|
|
| elapsed = time.time() - t0 |
| logging.info( |
| f"All done: success={done - failed}, failed={failed}, time={elapsed/60:.2f} min" |
| ) |
|
|
| if failed_files: |
| fail_path = OUTPUT_BASE / "failed_brats_ped_t1n_t2w.txt" |
| with open(fail_path, "w", encoding="utf-8") as f: |
| for case_id, modality, msg in failed_files: |
| f.write(f"{case_id}\t{modality}\t{msg}\n") |
| logging.info(f"Failed file list saved to: {fail_path}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
