Add prepare_mnms2.py

prepare_mnms2.py

@@ -0,0 +1,228 @@
+#!/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()