#!/usr/bin/env python3 """ Combined M&Ms-2 preprocessing script (mirrors prepare_acdc.py): 1. Read per-patient folders from raw_dataset/MnMs2_original/{train,val,test}/ 2. Copy SAX ED/ES (image + GT) into standardised lvsa_SR_ED/ES naming 3. Sabotage slices with random in-plane shifts 4. Generate JSON index for QC software Notes: - Only SAX is processed. LAX files are 2D single-slice and don't fit the multi-slice shift semantic used by the QC pipeline. - Output patient folders are named mnms2_{split}_{id} to avoid ID collisions across train/val/test and with the ACDC sabotaged_dataset/. - M&Ms-2 segmentation labels are 1=LV, 2=MYO, 3=RV (ACDC uses 1=RV, 2=MYO, 3=LV). No remapping is applied — consumers should be aware per dataset. """ import json import shutil import argparse import random from pathlib import Path import numpy as np import nibabel as nib def find_patient_dirs(source_dir: Path): """Find all patient directories across train/, val/, test/ splits. Returns list of (split, patient_dir) tuples. """ patient_dirs = [] for split in ["train", "val", "test"]: split_dir = source_dir / split if not split_dir.exists(): continue for d in sorted(split_dir.iterdir()): if d.is_dir() and d.name.isdigit(): patient_dirs.append((split, d)) return patient_dirs def sabotage_slices(img_path: Path, seg_path: Path | None, sabotage_ratio: float, max_shift: int, dry_run: bool = True) -> list[dict]: """ Randomly shift slices in-plane to simulate respiratory motion misalignment. For each slice (along the z-axis), with probability sabotage_ratio, apply a random x/y pixel shift to both the image and its paired segmentation. Returns a list of dicts describing which slices were shifted and by how much. """ img_nii = nib.load(img_path) img_data = img_nii.get_fdata() n_slices = img_data.shape[2] seg_nii = None seg_data = None if seg_path and seg_path.exists(): seg_nii = nib.load(seg_path) seg_data = seg_nii.get_fdata() shifts = [] for z in range(n_slices): if random.random() >= sabotage_ratio: continue dx = random.randint(-max_shift, max_shift) dy = random.randint(-max_shift, max_shift) if dx == 0 and dy == 0: continue shifts.append({"slice": z, "dx": dx, "dy": dy}) if not dry_run: img_data[:, :, z] = np.roll(img_data[:, :, z], shift=dx, axis=0) img_data[:, :, z] = np.roll(img_data[:, :, z], shift=dy, axis=1) if seg_data is not None: seg_data[:, :, z] = np.roll(seg_data[:, :, z], shift=dx, axis=0) seg_data[:, :, z] = np.roll(seg_data[:, :, z], shift=dy, axis=1) if not dry_run and shifts: # Cast back to original dtype so nibabel doesn't auto-rescale float64 # into the target integer range (which would corrupt stored labels). img_out = img_data.astype(img_nii.get_data_dtype()) nib.save(nib.Nifti1Image(img_out, img_nii.affine, img_nii.header), img_path) if seg_nii is not None and seg_data is not None: seg_out = seg_data.astype(seg_nii.get_data_dtype()) nib.save(nib.Nifti1Image(seg_out, seg_nii.affine, seg_nii.header), seg_path) return shifts def process_patients(source_dir: str, output_dir: str, dry_run: bool = True, sabotage_ratio: float = 0.5, max_shift: int = 5, seed: int = 42): """ Read per-patient directories, rename SAX files to lvsa_SR naming, sabotage slices with random shifts, and generate JSON index. Args: source_dir: MnMs2_original directory containing train/ val/ test/ output_dir: Directory where per-patient folders will be created dry_run: If True, only show what would be done sabotage_ratio: Probability of shifting each slice (0.0 to 1.0) max_shift: Maximum pixel shift in each direction """ source_path = Path(source_dir) param_subdir = f"seed{seed}_ratio{sabotage_ratio}_shift{max_shift}" output_path = Path(output_dir) / param_subdir patient_entries = find_patient_dirs(source_path) if not patient_entries: print(f"Error: No patient directories found in {source_path}") return print(f"\n{'DRY RUN MODE' if dry_run else 'EXECUTING'}") print("=" * 50) print(f"Found {len(patient_entries)} patients across train/val/test") json_index = {} for split, patient_dir in patient_entries: pid = patient_dir.name # e.g. "001" out_name = f"mnms2_{split}_{pid}" rename_map = { f"{pid}_sax_ed.nii.gz": "lvsa_SR_ED.nii.gz", f"{pid}_sax_ed_gt.nii.gz": "seg_lvsa_SR_ED.nii.gz", f"{pid}_sax_es.nii.gz": "lvsa_SR_ES.nii.gz", f"{pid}_sax_es_gt.nii.gz": "seg_lvsa_SR_ES.nii.gz", } missing = [src for src in rename_map if not (patient_dir / src).exists()] if missing: print(f"\n Warning: {split}/{pid} missing {missing}, skipping") continue print(f"\n{out_name}:") patient_out = output_path / out_name if not dry_run: patient_out.mkdir(parents=True, exist_ok=True) for src_name, new_name in rename_map.items(): src = patient_dir / src_name dst = patient_out / new_name if dry_run: print(f" {src_name} -> {out_name}/{new_name}") else: shutil.copy2(src, dst) print(f" Copied: {src_name} -> {out_name}/{new_name}") # Sabotage: randomly shift slices to simulate respiratory misalignment patient_sabotage = {} if sabotage_ratio > 0: for phase in ["ED", "ES"]: img_file = patient_out / f"lvsa_SR_{phase}.nii.gz" seg_file = patient_out / f"seg_lvsa_SR_{phase}.nii.gz" if dry_run: print(f" Would sabotage lvsa_SR_{phase} " f"(ratio={sabotage_ratio}, max_shift={max_shift}px)") else: if img_file.exists(): shifts = sabotage_slices( img_file, seg_file, sabotage_ratio, max_shift, dry_run=False) patient_sabotage[phase] = { "sabotaged": len(shifts) > 0, "shifts": shifts, } if shifts: print(f" Sabotaged lvsa_SR_{phase}: " f"shifted {len(shifts)}/{nib.load(img_file).shape[2]} slices") for s in shifts: print(f" slice {s['slice']}: dx={s['dx']}, dy={s['dy']}") json_index[str(patient_out.resolve())] = patient_sabotage json_name = (f"mnms2_qc_dataset" f"_seed{seed}" f"_ratio{sabotage_ratio}" f"_shift{max_shift}.json") json_path = output_path / json_name if dry_run: print(f"\nWould write JSON index ({len(json_index)} patients) to {json_path}") else: with open(json_path, 'w') as f: json.dump(json_index, f, indent=4, sort_keys=True) print(f"\nWrote JSON index ({len(json_index)} patients) to {json_path}") print("\n" + "=" * 50) if dry_run: print("DRY RUN COMPLETE - no files were copied") print("Run with --execute to perform the operation") else: print(f"COMPLETE - output at {output_path}") def main(): parser = argparse.ArgumentParser(description='Preprocess M&Ms-2 SAX dataset: rename files, sabotage, and generate JSON index') parser.add_argument('--source', type=str, default='raw_dataset/MnMs2_original', help='MnMs2_original directory containing train/ val/ test/') parser.add_argument('--output', type=str, default='sabotaged_dataset/sabotaged_mnms2', help='Parent output directory; a seed{N}_ratio{R}_shift{S} ' 'subfolder is auto-created inside it') parser.add_argument('--execute', action='store_true', help='Actually perform the copy and rename (default is dry run)') parser.add_argument('--sabotage-ratio', type=float, default=0.5, help='Probability of shifting each slice (0.0-1.0, default: 0.5)') parser.add_argument('--max-shift', type=int, default=5, help='Maximum pixel shift per direction (default: 5)') parser.add_argument('--seed', type=int, default=42, help='Random seed for reproducibility (default: 42)') args = parser.parse_args() random.seed(args.seed) np.random.seed(args.seed) process_patients(args.source, args.output, dry_run=not args.execute, sabotage_ratio=args.sabotage_ratio, max_shift=args.max_shift, seed=args.seed) if __name__ == "__main__": main()