Upload visualization folder

README.md

@@ -0,0 +1,163 @@
+# Cloud Removal Visualization & Evaluation
+
+Benchmark evaluation workspace for the **DiffCR** paper
+(*Diffusion-Based Cloud Removal for Sentinel-2 Multi-Temporal Imagery*).
+
+Two test datasets are covered:
+
+| Dataset | Samples | Methods |
+|---|---|---|
+| Sen2\_MTC\_Old | 313 | 12 |
+| Sen2\_MTC\_New | 687 | 12 |
+
+---
+
+## Directory Layout
+
+```
+visualization/
+├── paper-report.png          ← reference metrics table from the paper
+│
+├── data/
+│   ├── Sen2_MTC_New/
+│   │   ├── GT/               ← 687 cloud-free ground-truth images  ({id}.png)
+│   │   └── inputs/           ← 687 × 3 cloudy input images
+│   │                            ({id}_A1.png  {id}_A2.png  {id}_A3.png)
+│   └── Sen2_MTC_Old/
+│       ├── GT/               ← 313 ground-truth images
+│       └── inputs/           ← 313 × 3 cloudy inputs
+│
+├── results/
+│   ├── Sen2_MTC_New/
+│   │   ├── ae/               ← prediction images for each method ({id}.png)
+│   │   ├── crtsnet/
+│   │   ├── ctgan/
+│   │   ├── ddpmcr/
+│   │   ├── diffcr/           ← DiffCR [Ours]
+│   │   ├── dsen2cr/
+│   │   ├── mcgan/
+│   │   ├── pix2pix/
+│   │   ├── pmaa/
+│   │   ├── stgan/
+│   │   ├── stnet/
+│   │   └── uncrtaints/
+│   └── Sen2_MTC_Old/
+│       └── (same 12 methods)
+│
+└── eval/
+    ├── metrics.py            ← PSNR / SSIM / FID / LPIPS evaluation
+    ├── plot.py               ← comparison figure generation
+    └── requirements.txt      ← Python dependencies
+```
+
+---
+
+## Quick Start
+
+### 1. Install dependencies
+
+```bash
+pip install -r eval/requirements.txt
+```
+
+> **CUDA note** – SSIM uses the 3-D Gaussian kernel from the paper, which
+> requires a CUDA-enabled PyTorch installation to reproduce the exact paper
+> values.  PSNR, FID and LPIPS are fully reproducible on CPU.
+> Install the correct torch wheel for your GPU from https://pytorch.org.
+
+---
+
+### 2. Run evaluation
+
+```bash
+# Evaluate all 12 methods on both datasets (prints a full summary table):
+python eval/metrics.py
+
+# One specific method:
+python eval/metrics.py --method diffcr
+
+# One specific dataset:
+python eval/metrics.py --dataset Sen2_MTC_New
+
+# One method + one dataset:
+python eval/metrics.py --dataset Sen2_MTC_Old --method diffcr
+
+# Fast check (skip FID and LPIPS):
+python eval/metrics.py --no-fid --no-lpips
+
+# Arbitrary directory pair:
+python eval/metrics.py --gt /path/to/GT --pred /path/to/Out
+```
+
+Expected output (excerpt, requires CUDA for exact SSIM):
+
+```
+Method          | Sen2_MTC Old                        | Sen2_MTC New
+                |    PSNR   SSIM       FID  LPIPS |    PSNR   SSIM       FID  LPIPS
+--------------------------------------------------------------------------------
+...
+diffcr          |  29.112  0.886    89.845   0.258 |  19.150  0.671    83.162   0.291
+```
+
+---
+
+### 3. Generate comparison figures
+
+```bash
+# Generate the exact figures used in the paper:
+python eval/plot.py --paper-samples
+
+# Paper figures for one dataset:
+python eval/plot.py --paper-samples --dataset Sen2_MTC_New
+python eval/plot.py --paper-samples --dataset Sen2_MTC_Old
+
+# Any specific sample:
+python eval/plot.py --dataset Sen2_MTC_New --id T12TUR_R027_55
+
+# List all available sample IDs:
+python eval/plot.py --dataset Sen2_MTC_New --list
+
+# Generate figures for every sample:
+python eval/plot.py --dataset Sen2_MTC_New --all
+```
+
+Figures are saved as PDF to `eval/plots/` by default.
+
+---
+
+## Methods
+
+| Method | Venue | Abbrev |
+|---|---|---|
+| MCGAN | CVPRW 2017 | mcgan |
+| Pix2Pix | CVPR 2017 | pix2pix |
+| AE | ECTI-CON 2018 | ae |
+| STNet | TGRS 2020 | stnet |
+| DSen2-CR | ISPRS J PHOTOGRAM 2020 | dsen2cr |
+| STGAN | WACV 2020 | stgan |
+| CTGAN | ICIP 2022 | ctgan |
+| CR-TS-Net | TGRS 2022 | crtsnet |
+| PMAA | arXiv 2023 | pmaa |
+| UnCRtainTS | CVPRW 2023 | uncrtaints |
+| DDPM-CR | Remote Sensing 2023 | ddpmcr |
+| **DiffCR [Ours]** | **TGRS 2024** | **diffcr** |
+
+---
+
+## Paper Results
+
+![Paper metrics table](paper-report.png)
+
+---
+
+## Notes
+
+- All images use the unified naming scheme `{id}.png` (GT and predictions)
+  and `{id}_A{1,2,3}.png` (cloudy inputs).
+- `results/Sen2_MTC_Old/diffcr/` images are stored in their original
+  coordinate convention; `eval/plot.py` applies a horizontal flip
+  automatically when rendering the Old-dataset comparison figure so that
+  all panels share a consistent visual orientation.
+- `migrate.py` in the project root was the one-time script used to produce
+  the current layout from the original raw experiment directories.
+  It is kept for reference but does not need to be re-run.

data/Sen2_MTC_New/GT.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f9ee0b141b46bae7d711cdfc0d2868616ebc01f366ed88e6423bb8f18677f5c
+size 84162925

data/Sen2_MTC_New/inputs.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a3cf90a863ca6281e1bb0c27425877b68c1397bf791cb80bd821501ddc7a688
+size 188730536

data/Sen2_MTC_Old/GT.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a063dc216d3824eec8723365c8f03c2d5f357c733ef54269c181c8247243d855
+size 17036847

data/Sen2_MTC_Old/inputs.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ecbb77390f60f2d6dd708b7e13369ec574bae4efe71337bf5544ea6ec579220
+size 69421346

eval/metrics.py

@@ -0,0 +1,572 @@
+"""
+eval/metrics.py
+
+Unified evaluation script for cloud-removal methods on Sen2_MTC datasets.
+Computes PSNR, SSIM, FID and LPIPS – same implementation used in the paper.
+
+Usage
+-----
+# Evaluate every method on both datasets (prints a summary table):
+    python metrics.py
+
+# Evaluate one specific method / dataset:
+    python metrics.py --dataset Sen2_MTC_New --method diffcr
+
+# Evaluate an arbitrary pair of directories:
+    python metrics.py --gt /path/to/GT --pred /path/to/Out
+
+.. note on reproducibility::
+
+    PSNR, FID and LPIPS are fully reproducible on CPU.
+    **SSIM requires a CUDA-enabled PyTorch build** to match the exact paper
+    values; the 3-D Gaussian kernel implementation uses `.cuda()` internally
+    and its floating-point accumulation order differs on CPU, leading to
+    slightly different SSIM numbers.  Install the correct torch wheel for
+    your GPU from https://pytorch.org before running a full benchmark.
+
+The script expects the following layout (created by migrate.py):
+
+    visualization/
+    ├── data/
+    │   ├── Sen2_MTC_New/GT/   ← ground-truth images  ({id}.png)
+    │   └── Sen2_MTC_Old/GT/
+    └── results/
+        ├── Sen2_MTC_New/{method}/   ← prediction images ({id}.png)
+        └── Sen2_MTC_Old/{method}/
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from glob import glob
+
+import cv2
+import lpips
+import numpy as np
+import torch
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+# eval/ lives one level below the project root
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+DATASETS: list[str] = ["Sen2_MTC_Old", "Sen2_MTC_New"]
+
+# Order matches the paper table (top → bottom)
+METHODS: list[str] = [
+    "mcgan",
+    "pix2pix",
+    "ae",
+    "stnet",
+    "dsen2cr",
+    "stgan",
+    "ctgan",
+    "crtsnet",
+    "pmaa",
+    "uncrtaints",
+    "ddpmcr",
+    "diffcr",
+]
+
+
+# ---------------------------------------------------------------------------
+# Image helpers
+# ---------------------------------------------------------------------------
+
+
+def _convert_input_type_range(img: np.ndarray) -> np.ndarray:
+    """Convert image to float32 in [0, 1]."""
+    img_type = img.dtype
+    img = img.astype(np.float32)
+    if img_type == np.uint8:
+        img /= 255.0
+    elif img_type != np.float32:
+        raise TypeError(f"Unsupported dtype: {img_type}")
+    return img
+
+
+def _convert_output_type_range(img: np.ndarray, dst_type) -> np.ndarray:
+    if dst_type == np.uint8:
+        img = img.round()
+    else:
+        img /= 255.0
+    return img.astype(dst_type)
+
+
+def reorder_image(img: np.ndarray, input_order: str = "HWC") -> np.ndarray:
+    if input_order not in ("HWC", "CHW"):
+        raise ValueError(f"input_order must be 'HWC' or 'CHW', got '{input_order}'")
+    if img.ndim == 2:
+        img = img[..., None]
+    if input_order == "CHW":
+        img = img.transpose(1, 2, 0)
+    return img
+
+
+# ---------------------------------------------------------------------------
+# PSNR
+# ---------------------------------------------------------------------------
+
+
+def calculate_psnr(
+    img1: np.ndarray,
+    img2: np.ndarray,
+    crop_border: int,
+    input_order: str = "HWC",
+) -> float:
+    """Peak Signal-to-Noise Ratio.
+
+    Accepts uint8 [0, 255] or float32 [0, 1] images.
+    """
+    assert img1.shape == img2.shape, f"Shape mismatch: {img1.shape} vs {img2.shape}"
+    img1 = reorder_image(img1, input_order).astype(np.float64)
+    img2 = reorder_image(img2, input_order).astype(np.float64)
+
+    if crop_border:
+        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
+        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
+
+    mse = np.mean((img1 - img2) ** 2)
+    if mse == 0:
+        return float("inf")
+    max_val = 1.0 if img1.max() <= 1.0 else 255.0
+    return 20.0 * np.log10(max_val / np.sqrt(mse))
+
+
+# ---------------------------------------------------------------------------
+# SSIM – 3-D Gaussian kernel (paper implementation)
+# ---------------------------------------------------------------------------
+
+
+def _generate_3d_gaussian_kernel(device: torch.device) -> torch.nn.Conv3d:
+    """Build the 11×11×11 separable Gaussian Conv3d used in the paper."""
+    kernel_1d = cv2.getGaussianKernel(11, 1.5)  # (11, 1)
+    window_2d = np.outer(kernel_1d, kernel_1d.T)  # (11, 11)
+    kernel_3d = np.stack(
+        [window_2d * k for k in kernel_1d],
+        axis=0,  # (11, 11, 11)
+    )
+    conv3d = torch.nn.Conv3d(
+        1,
+        1,
+        (11, 11, 11),
+        stride=1,
+        padding=(5, 5, 5),
+        bias=False,
+        padding_mode="replicate",
+    )
+    conv3d.weight.requires_grad_(False)
+    conv3d.weight[0, 0] = torch.tensor(kernel_3d)
+    return conv3d.to(device)
+
+
+def _apply_3d_gaussian(img: torch.Tensor, conv3d: torch.nn.Conv3d) -> torch.Tensor:
+    return conv3d(img.unsqueeze(0).unsqueeze(0)).squeeze(0).squeeze(0)
+
+
+def _ssim_3d(
+    img1: np.ndarray,
+    img2: np.ndarray,
+    max_value: float,
+    device: torch.device,
+) -> float:
+    """3-D SSIM over all three channels simultaneously (paper metric)."""
+    assert img1.ndim == 3 and img2.ndim == 3
+    C1 = (0.01 * max_value) ** 2
+    C2 = (0.03 * max_value) ** 2
+
+    kernel = _generate_3d_gaussian_kernel(device)
+
+    t1 = torch.tensor(img1.astype(np.float64)).float().to(device)
+    t2 = torch.tensor(img2.astype(np.float64)).float().to(device)
+
+    mu1 = _apply_3d_gaussian(t1, kernel)
+    mu2 = _apply_3d_gaussian(t2, kernel)
+
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_sq = _apply_3d_gaussian(t1**2, kernel) - mu1_sq
+    sigma2_sq = _apply_3d_gaussian(t2**2, kernel) - mu2_sq
+    sigma12 = _apply_3d_gaussian(t1 * t2, kernel) - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / (
+        (mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2)
+    )
+    return float(ssim_map.mean())
+
+
+def calculate_ssim(
+    img1: np.ndarray,
+    img2: np.ndarray,
+    crop_border: int,
+    input_order: str = "HWC",
+    device: torch.device | None = None,
+) -> float:
+    """Structural Similarity using the 3-D Gaussian kernel (paper implementation).
+
+    Requires CUDA by default; falls back to CPU if no GPU is available.
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    assert img1.shape == img2.shape, f"Shape mismatch: {img1.shape} vs {img2.shape}"
+
+    img1 = reorder_image(img1, input_order).astype(np.float64)
+    img2 = reorder_image(img2, input_order).astype(np.float64)
+
+    if crop_border:
+        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
+        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
+
+    max_val = 1 if img1.max() <= 1.0 else 255
+
+    with torch.no_grad():
+        return _ssim_3d(img1, img2, max_val, device)
+
+
+# ---------------------------------------------------------------------------
+# FID
+# ---------------------------------------------------------------------------
+
+
+def calculate_fid(gt_dir: str, pred_dir: str) -> float:
+    """Compute FID via the pytorch-fid command-line tool."""
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    num_workers = 0 if sys.platform == "win32" else 4
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "pytorch_fid",
+            gt_dir,
+            pred_dir,
+            "--device",
+            device,
+            "--batch-size",
+            "4",
+            "--num-workers",
+            str(num_workers),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    output = result.stdout + result.stderr
+    for line in output.splitlines():
+        line = line.strip()
+        if "fid" in line.lower():
+            try:
+                return float(line.split()[-1])
+            except ValueError:
+                pass
+    print(f"[WARN] Could not parse FID output:\n{output}", file=sys.stderr)
+    return float("nan")
+
+
+# ---------------------------------------------------------------------------
+# LPIPS
+# ---------------------------------------------------------------------------
+
+
+def calculate_lpips(
+    gt_dir: str,
+    pred_dir: str,
+    device: torch.device | None = None,
+) -> float:
+    """Mean LPIPS (AlexNet backbone) over matched image pairs."""
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    loss_fn = lpips.LPIPS(net="alex", verbose=False).to(device)
+
+    gt_map = _stem_map(gt_dir)
+    pred_map = _stem_map(pred_dir)
+    keys = sorted(set(gt_map) & set(pred_map))
+
+    if not keys:
+        print(
+            f"[WARN] No common files between {gt_dir} and {pred_dir}", file=sys.stderr
+        )
+        return float("nan")
+
+    scores: list[float] = []
+    for k in tqdm(keys, desc="LPIPS", leave=False):
+        t1 = lpips.im2tensor(lpips.load_image(gt_map[k])).to(device)
+        t2 = lpips.im2tensor(lpips.load_image(pred_map[k])).to(device)
+        scores.append(loss_fn(t1, t2).item())
+
+    return float(np.mean(scores))
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _stem_map(directory: str) -> dict[str, str]:
+    """Return {stem: full_path} for every .png in *directory*."""
+    return {
+        os.path.splitext(os.path.basename(f))[0]: f
+        for f in glob(os.path.join(directory, "*.png"))
+    }
+
+
+def evaluate_pair(
+    gt_dir: str,
+    pred_dir: str,
+    desc: str = "",
+    device: torch.device | None = None,
+) -> dict | None:
+    """Compute all four metrics for one (GT, prediction) directory pair.
+
+    Returns a dict with keys: n, PSNR, SSIM, FID, LPIPS.
+    Returns None if no common files are found.
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    gt_map = _stem_map(gt_dir)
+    pred_map = _stem_map(pred_dir)
+    keys = sorted(set(gt_map) & set(pred_map))
+
+    if not keys:
+        print(
+            f"[WARN] No common files – GT: {gt_dir!r}  Pred: {pred_dir!r}",
+            file=sys.stderr,
+        )
+        return None
+
+    psnr_list: list[float] = []
+    ssim_list: list[float] = []
+
+    for k in tqdm(keys, desc=desc or "PSNR/SSIM", leave=False):
+        img_gt = cv2.imread(gt_map[k])
+        img_pred = cv2.imread(pred_map[k])
+        if img_gt is None or img_pred is None:
+            print(f"[WARN] Could not read image for key '{k}'", file=sys.stderr)
+            continue
+        if img_gt.shape != img_pred.shape:
+            print(
+                f"[WARN] Shape mismatch for '{k}': {img_gt.shape} vs {img_pred.shape}",
+                file=sys.stderr,
+            )
+            continue
+        psnr_list.append(calculate_psnr(img_gt, img_pred, crop_border=0))
+        ssim_list.append(calculate_ssim(img_gt, img_pred, crop_border=0, device=device))
+
+    if not psnr_list:
+        return None
+
+    fid_score = calculate_fid(gt_dir, pred_dir)
+    lpips_score = calculate_lpips(gt_dir, pred_dir, device=device)
+
+    return {
+        "n": len(psnr_list),
+        "PSNR": float(np.mean(psnr_list)),
+        "SSIM": float(np.mean(ssim_list)),
+        "FID": fid_score,
+        "LPIPS": lpips_score,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Pretty table
+# ---------------------------------------------------------------------------
+
+
+def _fmt(v: float | None, width: int, decimals: int) -> str:
+    if v is None or (isinstance(v, float) and np.isnan(v)):
+        return f"{'N/A':>{width}}"
+    return f"{v:>{width}.{decimals}f}"
+
+
+def print_table(
+    all_results: dict[str, dict[str, dict]],
+    datasets: list[str],
+    methods: list[str],
+) -> None:
+    col = 38  # width of one dataset block
+    sep = "-" * (16 + col * len(datasets))
+
+    # Header
+    print("\n" + "=" * len(sep))
+    header = f"{'Method':<16}"
+    for ds in datasets:
+        label = ds.replace("Sen2_MTC_", "Sen2_MTC ")
+        header += f"{'| ' + label:<{col}}"
+    print(header)
+
+    sub = f"{'':16}"
+    for _ in datasets:
+        sub += f"| {'PSNR':>7} {'SSIM':>6} {'FID':>9} {'LPIPS':>6} "
+    print(sub)
+    print(sep)
+
+    for m in methods:
+        row = f"{m:<16}"
+        for ds in datasets:
+            r = all_results.get(ds, {}).get(m)
+            if r:
+                row += (
+                    f"| {_fmt(r['PSNR'], 7, 3)}"
+                    f"  {_fmt(r['SSIM'], 6, 3)}"
+                    f"  {_fmt(r['FID'], 9, 3)}"
+                    f"  {_fmt(r['LPIPS'], 6, 3)} "
+                )
+            else:
+                row += f"|{'SKIP':^{col - 2}} "
+        print(row)
+
+    print("=" * len(sep))
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def _parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Evaluate cloud-removal metrics (PSNR / SSIM / FID / LPIPS)"
+    )
+    p.add_argument(
+        "--dataset",
+        type=str,
+        default=None,
+        choices=DATASETS,
+        help="Evaluate only this dataset (default: both)",
+    )
+    p.add_argument(
+        "--method",
+        type=str,
+        default=None,
+        help="Evaluate only this method (default: all)",
+    )
+    p.add_argument(
+        "--gt",
+        type=str,
+        default=None,
+        help="Ground-truth directory (use together with --pred for a custom pair)",
+    )
+    p.add_argument(
+        "--pred",
+        type=str,
+        default=None,
+        help="Prediction directory",
+    )
+    p.add_argument(
+        "--no-fid",
+        action="store_true",
+        help="Skip FID computation (much faster, useful for quick checks)",
+    )
+    p.add_argument(
+        "--no-lpips",
+        action="store_true",
+        help="Skip LPIPS computation",
+    )
+    return p.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}")
+
+    # ---- custom pair -------------------------------------------------------
+    if args.gt and args.pred:
+        print(f"GT  : {args.gt}")
+        print(f"Pred: {args.pred}")
+        res = evaluate_pair(args.gt, args.pred, desc="custom", device=device)
+        if res:
+            print(
+                f"\nPSNR  = {res['PSNR']:.3f}\n"
+                f"SSIM  = {res['SSIM']:.3f}\n"
+                f"FID   = {res['FID']:.3f}\n"
+                f"LPIPS = {res['LPIPS']:.3f}\n"
+                f"(n = {res['n']})"
+            )
+        return
+
+    # ---- standard evaluation loop ------------------------------------------
+    datasets = [args.dataset] if args.dataset else DATASETS
+    methods = [args.method] if args.method else METHODS
+
+    all_results: dict[str, dict[str, dict]] = {ds: {} for ds in datasets}
+
+    for ds in datasets:
+        gt_dir = os.path.join(ROOT, "data", ds, "GT")
+        if not os.path.isdir(gt_dir):
+            print(f"[ERROR] GT directory not found: {gt_dir}", file=sys.stderr)
+            continue
+
+        for m in methods:
+            pred_dir = os.path.join(ROOT, "results", ds, m)
+            if not os.path.isdir(pred_dir):
+                print(f"  SKIP  {ds}/{m}  (not found)")
+                continue
+
+            print(f"\n[{ds}] [{m}]")
+
+            gt_map = _stem_map(gt_dir)
+            pred_map = _stem_map(pred_dir)
+            n_common = len(set(gt_map) & set(pred_map))
+            print(
+                f"  GT: {len(gt_map)} imgs  |  Pred: {len(pred_map)} imgs  |  Common: {n_common}"
+            )
+
+            # PSNR / SSIM
+            psnr_list: list[float] = []
+            ssim_list: list[float] = []
+            keys = sorted(set(gt_map) & set(pred_map))
+
+            for k in tqdm(keys, desc="PSNR/SSIM", leave=False):
+                ig = cv2.imread(gt_map[k])
+                ip = cv2.imread(pred_map[k])
+                if ig is None or ip is None or ig.shape != ip.shape:
+                    continue
+                psnr_list.append(calculate_psnr(ig, ip, crop_border=0))
+                ssim_list.append(calculate_ssim(ig, ip, crop_border=0, device=device))
+
+            if not psnr_list:
+                print("  [WARN] No valid image pairs found.")
+                continue
+
+            psnr_mean = float(np.mean(psnr_list))
+            ssim_mean = float(np.mean(ssim_list))
+            print(f"  PSNR = {psnr_mean:.3f}  |  SSIM = {ssim_mean:.3f}")
+
+            # FID
+            fid_score: float = float("nan")
+            if not args.no_fid:
+                print("  Computing FID ...", end=" ", flush=True)
+                fid_score = calculate_fid(gt_dir, pred_dir)
+                print(f"{fid_score:.3f}")
+
+            # LPIPS
+            lpips_score: float = float("nan")
+            if not args.no_lpips:
+                lpips_score = calculate_lpips(gt_dir, pred_dir, device=device)
+                print(f"  LPIPS = {lpips_score:.3f}")
+
+            all_results[ds][m] = {
+                "n": len(psnr_list),
+                "PSNR": psnr_mean,
+                "SSIM": ssim_mean,
+                "FID": fid_score,
+                "LPIPS": lpips_score,
+            }
+
+    # ---- summary table -----------------------------------------------------
+    if any(all_results[ds] for ds in datasets):
+        print_table(all_results, datasets, methods)
+
+
+if __name__ == "__main__":
+    main()

eval/plot.py

@@ -0,0 +1,387 @@
+"""
+eval/plot.py
+
+Generate comparison figures for all cloud-removal methods.
+
+The script reads from the cleaned-up directory layout created by migrate.py:
+
+    visualization/
+    ├── data/
+    │   ├── Sen2_MTC_New/
+    │   │   ├── GT/        {id}.png
+    │   │   └── inputs/    {id}_A1.png  {id}_A2.png  {id}_A3.png
+    │   └── Sen2_MTC_Old/
+    │       ├── GT/
+    │       └── inputs/
+    └── results/
+        ├── Sen2_MTC_New/{method}/{id}.png
+        └── Sen2_MTC_Old/{method}/{id}.png
+
+Usage
+-----
+# Generate the exact figures that appear in the paper:
+    python plot.py --paper-samples
+
+# Generate paper figures for one dataset only:
+    python plot.py --paper-samples --dataset Sen2_MTC_New
+    python plot.py --paper-samples --dataset Sen2_MTC_Old
+
+# Generate a figure for any arbitrary sample ID:
+    python plot.py --dataset Sen2_MTC_New --id T12TUR_R027_55
+
+# List all available sample IDs for a dataset:
+    python plot.py --dataset Sen2_MTC_New --list
+
+# Custom output directory:
+    python plot.py --paper-samples --out-dir /path/to/figures
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+from glob import glob
+from typing import Optional
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+
+matplotlib.rcParams["font.family"] = "Times New Roman"
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+# eval/ is one level below the project root
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+DATASETS = ["Sen2_MTC_Old", "Sen2_MTC_New"]
+
+# Display order in the 4×4 grid (row-major, after the 4 input/GT panels)
+METHODS: list[str] = [
+    "mcgan",
+    "pix2pix",
+    "ae",
+    "stnet",
+    "dsen2cr",
+    "stgan",
+    "ctgan",
+    "crtsnet",
+    "pmaa",
+    "uncrtaints",
+    "ddpmcr",
+    "diffcr",
+]
+
+METHOD_LABELS: list[str] = [
+    "MCGAN",
+    "Pix2Pix",
+    "AE",
+    "STNet",
+    "DSen2-CR",
+    "STGAN",
+    "CTGAN",
+    "CR-TS-Net",
+    "PMAA",
+    "UnCRtainTS",
+    "DDPM-CR",
+    "DiffCR [Ours]",
+]
+
+INPUT_LABELS: list[str] = [
+    r"Cloudy $T_1$",
+    r"Cloudy $T_2$",
+    r"Cloudy $T_3$",
+    "Ground-Truth",
+]
+
+ALL_LABELS: list[str] = INPUT_LABELS + METHOD_LABELS
+
+# Some methods in the Old dataset store outputs with a horizontal flip
+# relative to the other methods' spatial convention.  We correct for display.
+FLIP_H_FOR_DISPLAY: dict[str, set[str]] = {
+    "Sen2_MTC_Old": {"diffcr"},
+}
+
+# The exact sample IDs used in the paper figures
+PAPER_SAMPLES: dict[str, list[str]] = {
+    "Sen2_MTC_New": ["T12TUR_R027_55"],
+    "Sen2_MTC_Old": ["42WVD_70008000", "14SQB_20006000"],
+}
+
+
+# ---------------------------------------------------------------------------
+# I/O helpers
+# ---------------------------------------------------------------------------
+
+
+def _find_input(inputs_dir: str, sample_id: str, channel: str) -> Optional[str]:
+    """Locate {id}_A{1|2|3}.png in *inputs_dir*."""
+    direct = os.path.join(inputs_dir, f"{sample_id}_{channel}.png")
+    if os.path.exists(direct):
+        return direct
+    # Fallback – glob for any file containing the id and channel tag
+    hits = glob(os.path.join(inputs_dir, f"{sample_id}*{channel}*"))
+    return hits[0] if hits else None
+
+
+def _load(path: str, flip_h: bool = False) -> np.ndarray:
+    """Load an image as float [0,1] RGBA/RGB via matplotlib.
+
+    matplotlib.imread returns:
+    - PNG: float32 [0,1]  (RGBA or RGB depending on file)
+    - other: uint8  [0,255]
+    We normalise everything to float32 [0,1] and strip the alpha channel.
+    """
+    img = plt.imread(path)
+    # Normalise uint8 to float
+    if img.dtype == np.uint8:
+        img = img.astype(np.float32) / 255.0
+    # Drop alpha channel if present
+    if img.ndim == 3 and img.shape[2] == 4:
+        img = img[:, :, :3]
+    # Clip to valid range (handles tiny float rounding errors)
+    img = np.clip(img, 0.0, 1.0)
+    if flip_h:
+        img = img[:, ::-1, :]
+    return img
+
+
+# ---------------------------------------------------------------------------
+# Core plotting function
+# ---------------------------------------------------------------------------
+
+
+def plot_sample(
+    dataset: str,
+    sample_id: str,
+    out_dir: Optional[str] = None,
+    dpi: int = 300,
+    verbose: bool = True,
+) -> Optional[str]:
+    """Generate a 4×4 comparison grid for *sample_id* in *dataset*.
+
+    Returns the path of the saved figure, or None on failure.
+    """
+    data_dir = os.path.join(ROOT, "data", dataset)
+    results_dir = os.path.join(ROOT, "results", dataset)
+    inputs_dir = os.path.join(data_dir, "inputs")
+    gt_dir = os.path.join(data_dir, "GT")
+
+    # ---- Locate source files -----------------------------------------------
+    a1 = _find_input(inputs_dir, sample_id, "A1")
+    a2 = _find_input(inputs_dir, sample_id, "A2")
+    a3 = _find_input(inputs_dir, sample_id, "A3")
+    gt = os.path.join(gt_dir, f"{sample_id}.png")
+
+    missing: list[str] = []
+    for tag, path in [("A1", a1), ("A2", a2), ("A3", a3), ("GT", gt)]:
+        if not path or not os.path.exists(path):
+            missing.append(tag)
+
+    if missing:
+        print(f"[WARN] {dataset}/{sample_id}: missing {missing} – skipping.")
+        return None
+
+    # ---- Build image grid --------------------------------------------------
+    flip_set = FLIP_H_FOR_DISPLAY.get(dataset, set())
+
+    grid: list[np.ndarray] = [
+        _load(a1),
+        _load(a2),
+        _load(a3),
+        _load(gt),
+    ]
+
+    for method in METHODS:
+        pred_path = os.path.join(results_dir, method, f"{sample_id}.png")
+        flip = method in flip_set
+        if os.path.exists(pred_path):
+            grid.append(_load(pred_path, flip_h=flip))
+        else:
+            if verbose:
+                print(
+                    f"  [WARN] missing {dataset}/{method}/{sample_id}.png  → black panel"
+                )
+            # Placeholder: black image with same shape as GT
+            grid.append(np.zeros_like(grid[3]))
+
+    assert len(grid) == 16, f"Expected 16 panels, got {len(grid)}"
+
+    # ---- Render figure -----------------------------------------------------
+    fig, axes = plt.subplots(4, 4, figsize=(8, 8), dpi=dpi)
+    fig.subplots_adjust(
+        left=0.01,
+        right=0.99,
+        top=0.99,
+        bottom=0.06,
+        wspace=0.04,
+        hspace=0.10,
+    )
+
+    for idx, (ax, img, label) in enumerate(zip(axes.flat, grid, ALL_LABELS)):
+        ax.imshow(img)
+        ax.set_title(label, y=-0.18, fontsize=7)
+        ax.axis("off")
+
+    # ---- Save --------------------------------------------------------------
+    if out_dir is None:
+        out_dir = os.path.join(ROOT, "eval", "plots")
+    os.makedirs(out_dir, exist_ok=True)
+
+    out_path = os.path.join(out_dir, f"{dataset}_{sample_id}.pdf")
+    fig.savefig(out_path, bbox_inches="tight")
+    plt.close(fig)
+
+    if verbose:
+        print(f"Saved: {out_path}")
+    return out_path
+
+
+# ---------------------------------------------------------------------------
+# Batch helpers
+# ---------------------------------------------------------------------------
+
+
+def available_ids(dataset: str) -> list[str]:
+    """Return sorted list of sample IDs that have at least one input image."""
+    inputs_dir = os.path.join(ROOT, "data", dataset, "inputs")
+    a1_files = sorted(glob(os.path.join(inputs_dir, "*_A1.png")))
+    return [os.path.basename(f).replace("_A1.png", "") for f in a1_files]
+
+
+def generate_paper_figures(
+    datasets: Optional[list[str]] = None,
+    out_dir: Optional[str] = None,
+) -> list[str]:
+    """Generate all figures referenced in the paper."""
+    if datasets is None:
+        datasets = DATASETS
+    saved: list[str] = []
+    for ds in datasets:
+        for sid in PAPER_SAMPLES.get(ds, []):
+            print(f"\n--- {ds} / {sid} ---")
+            path = plot_sample(ds, sid, out_dir=out_dir)
+            if path:
+                saved.append(path)
+    return saved
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def _parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Generate comparison figures for cloud-removal methods"
+    )
+    p.add_argument(
+        "--dataset",
+        type=str,
+        default=None,
+        choices=DATASETS,
+        help="Dataset to use (default: both when --paper-samples is set)",
+    )
+    p.add_argument(
+        "--id",
+        type=str,
+        default=None,
+        metavar="SAMPLE_ID",
+        help="Generate a figure for this specific sample ID",
+    )
+    p.add_argument(
+        "--paper-samples",
+        action="store_true",
+        help="Generate the exact figures used in the paper",
+    )
+    p.add_argument(
+        "--all",
+        action="store_true",
+        help="Generate figures for ALL available samples in the chosen dataset",
+    )
+    p.add_argument(
+        "--list",
+        action="store_true",
+        help="List available sample IDs and exit",
+    )
+    p.add_argument(
+        "--out-dir",
+        type=str,
+        default=None,
+        help="Output directory (default: eval/plots/)",
+    )
+    p.add_argument(
+        "--dpi",
+        type=int,
+        default=300,
+        help="Figure resolution in DPI (default: 300)",
+    )
+    return p.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+
+    # Determine which datasets to process
+    if args.dataset:
+        datasets = [args.dataset]
+    else:
+        datasets = DATASETS
+
+    # ---- list mode ---------------------------------------------------------
+    if args.list:
+        for ds in datasets:
+            ids = available_ids(ds)
+            print(f"\n{ds}  ({len(ids)} samples)")
+            for i, sid in enumerate(ids):
+                print(f"  {sid}")
+                if i >= 29 and len(ids) > 30:
+                    print(f"  ... and {len(ids) - 30} more (use --all to see all)")
+                    break
+        return
+
+    # ---- paper figures -----------------------------------------------------
+    if args.paper_samples:
+        saved = generate_paper_figures(datasets=datasets, out_dir=args.out_dir)
+        print(f"\n{len(saved)} figure(s) saved.")
+        return
+
+    # ---- single sample -----------------------------------------------------
+    if args.id:
+        if len(datasets) > 1:
+            print("[INFO] --id specified without --dataset; trying both datasets.")
+        for ds in datasets:
+            plot_sample(ds, args.id, out_dir=args.out_dir, dpi=args.dpi)
+        return
+
+    # ---- all samples -------------------------------------------------------
+    if args.all:
+        if not args.dataset:
+            print("[ERROR] Please specify --dataset when using --all.")
+            return
+        ids = available_ids(args.dataset)
+        print(f"Generating {len(ids)} figures for {args.dataset} …")
+        for sid in ids:
+            plot_sample(
+                args.dataset, sid, out_dir=args.out_dir, dpi=args.dpi, verbose=False
+            )
+            print(f"  done: {sid}")
+        print("Finished.")
+        return
+
+    # ---- no action specified -----------------------------------------------
+    print(
+        "No action specified. Examples:\n"
+        "  python plot.py --paper-samples\n"
+        "  python plot.py --dataset Sen2_MTC_New --id T12TUR_R027_55\n"
+        "  python plot.py --dataset Sen2_MTC_New --list\n"
+        "  python plot.py --dataset Sen2_MTC_New --all\n"
+    )
+
+
+if __name__ == "__main__":
+    main()

eval/requirements.txt

@@ -0,0 +1,10 @@
+matplotlib>=3.7
+numpy>=1.25
+opencv-contrib-python>=4.5
+Pillow>=10.0
+pytorch-fid>=0.3.0
+lpips>=0.1.4
+scikit-image>=0.17
+torch>=1.9
+torchvision>=0.10
+tqdm>=4.66

migrate.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+"""
+migrate.py  –  One-time reorganisation of the visualization directory.
+
+Run from  D:\\visualization:
+    python migrate.py            # full migration + cleanup
+    python migrate.py --dry-run  # preview only, no files touched
+
+What the script does
+--------------------
+1.  Creates:
+        data/Sen2_MTC_{New,Old}/GT/        one shared ground-truth copy
+        data/Sen2_MTC_{New,Old}/inputs/    cloudy inputs  (_A1 / _A2 / _A3)
+        results/Sen2_MTC_{New,Old}/{method}/  per-method predictions
+
+2.  Copies images with a unified naming scheme:
+        {id}_real_B.png   →  GT/{id}.png
+        {id}_fake_B.png   →  {method}/{id}.png
+        Out_{id}.png      →  {method}/{id}.png    (diffcr convention)
+        {id}_real_A1.png  →  inputs/{id}_A1.png
+
+3.  After verifying every expected directory is non-empty, deletes the
+    original Sen2_MTC_New  and  Sen2_MTC_Old  trees.
+
+Special cases handled
+---------------------
+- pmaa / Sen2_MTC_New  has no Out/ folder: outputs are extracted from the
+  per-sample  test/{psnr_ssim}/  sub-directories.
+- diffcr / Sen2_MTC_New  has no test/ folder: Out/ already contains flat
+  Out_{id}.png  files.
+- diffcr / Sen2_MTC_Old  same as above.
+- ctgan / Sen2_MTC_New  has an extra  save/  directory (ignored).
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sys
+from glob import glob
+
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Project root  (this file lives directly in  D:\visualization\)
+# ---------------------------------------------------------------------------
+ROOT = os.path.dirname(os.path.abspath(__file__))
+
+METHODS: list[str] = [
+    "ae",
+    "crtsnet",
+    "ctgan",
+    "ddpmcr",
+    "diffcr",
+    "dsen2cr",
+    "mcgan",
+    "pix2pix",
+    "pmaa",
+    "stgan",
+    "stnet",
+    "uncrtaints",
+]
+
+# ---------------------------------------------------------------------------
+# Naming helpers
+# ---------------------------------------------------------------------------
+
+
+def strip_id(path: str) -> str:
+    """Extract the clean sample ID from any of the naming conventions used.
+
+    Examples
+    --------
+    T12TUR_R027_0_real_B.png  ->  T12TUR_R027_0
+    T12TUR_R027_0_fake_B.png  ->  T12TUR_R027_0
+    Out_T12TUR_R027_0.png     ->  T12TUR_R027_0
+    GT_T12TUR_R027_0.png      ->  T12TUR_R027_0
+    01WFN_60009000_real_B.png ->  01WFN_60009000
+    """
+    stem = os.path.splitext(os.path.basename(path))[0]
+
+    # Prefix conventions used by diffcr
+    for pfx in ("GT_", "Out_"):
+        if stem.startswith(pfx):
+            return stem[len(pfx) :]
+
+    # Suffix conventions used by most other methods
+    for sfx in ("_real_B", "_fake_B"):
+        if stem.endswith(sfx):
+            return stem[: -len(sfx)]
+
+    # Already a bare ID (should not normally happen)
+    return stem
+
+
+def _copy(src: str, dst: str) -> None:
+    """Copy *src* to *dst*, creating parent directories as needed."""
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    shutil.copy2(src, dst)
+
+
+# ---------------------------------------------------------------------------
+# Migration steps
+# ---------------------------------------------------------------------------
+
+
+def migrate_gt(
+    src_base: str,
+    dst_data: str,
+    dry_run: bool,
+) -> int:
+    """Copy GT images from  ae/GT/  →  data/{dataset}/GT/  with clean names.
+
+    Source name:  {id}_real_B.png
+    Dest name:    {id}.png
+    """
+    src_dir = os.path.join(src_base, "ae", "GT")
+    dst_dir = os.path.join(dst_data, "GT")
+
+    files = sorted(glob(os.path.join(src_dir, "*.png")))
+    if not files:
+        print(f"  [WARN] No GT images found in {src_dir}", file=sys.stderr)
+        return 0
+
+    if not dry_run:
+        os.makedirs(dst_dir, exist_ok=True)
+        for f in tqdm(files, desc="  GT", leave=False):
+            _copy(f, os.path.join(dst_dir, strip_id(f) + ".png"))
+
+    return len(files)
+
+
+def migrate_inputs(
+    src_base: str,
+    dst_data: str,
+    dry_run: bool,
+) -> int:
+    """Extract  real_A1 / real_A2 / real_A3  from  ae/test/**/
+    →  data/{dataset}/inputs/{id}_A{1,2,3}.png
+
+    Source name:  {id}_real_A1.png
+    Dest name:    {id}_A1.png
+    """
+    src_test = os.path.join(src_base, "ae", "test")
+    dst_dir = os.path.join(dst_data, "inputs")
+
+    # ae/test/ contains one sub-folder per sample named after its psnr/ssim score.
+    files = sorted(glob(os.path.join(src_test, "*", "*_real_A?.png")))
+    if not files:
+        print(f"  [WARN] No input images found under {src_test}", file=sys.stderr)
+        return 0
+
+    if not dry_run:
+        os.makedirs(dst_dir, exist_ok=True)
+        for f in tqdm(files, desc="  inputs", leave=False):
+            # e.g. T12TUR_R027_0_real_A1.png  →  T12TUR_R027_0_A1.png
+            new_name = os.path.basename(f).replace("_real_A", "_A")
+            _copy(f, os.path.join(dst_dir, new_name))
+
+    return len(files)
+
+
+def migrate_outputs(
+    src_base: str,
+    dst_results: str,
+    dataset_label: str,
+    dry_run: bool,
+) -> dict[str, int]:
+    """Copy each method's predictions into  results/{dataset}/{method}/{id}.png
+
+    Handles the three different source layouts:
+    a) Standard:     method/Out/{id}_fake_B.png
+    b) diffcr:       method/Out/Out_{id}.png
+    c) pmaa (New):   method/test/{psnr_ssim}/{id}_fake_B.png   (no Out/ folder)
+    """
+    counts: dict[str, int] = {}
+
+    for method in METHODS:
+        src_method = os.path.join(src_base, method)
+
+        if not os.path.isdir(src_method):
+            print(f"  SKIP  {dataset_label}/{method}  (directory not found)")
+            continue
+
+        dst_dir = os.path.join(dst_results, method)
+        files: list[tuple[str, str]] = []  # (src_path, dst_filename)
+
+        # ---- pmaa / Sen2_MTC_New only: no Out/ folder ----------------------
+        if method == "pmaa" and "New" in dataset_label:
+            for subdir in sorted(glob(os.path.join(src_method, "test", "*/"))):
+                for f in sorted(glob(os.path.join(subdir, "*_fake_B.png"))):
+                    files.append((f, strip_id(f) + ".png"))
+
+        # ---- all other methods: use the flat Out/ folder -------------------
+        else:
+            src_out = os.path.join(src_method, "Out")
+            if not os.path.isdir(src_out):
+                print(
+                    f"  SKIP  {dataset_label}/{method}  (Out/ folder not found)",
+                    file=sys.stderr,
+                )
+                continue
+            for f in sorted(glob(os.path.join(src_out, "*.png"))):
+                files.append((f, strip_id(f) + ".png"))
+
+        if not files:
+            print(
+                f"  [WARN] {dataset_label}/{method}: no output images found",
+                file=sys.stderr,
+            )
+            counts[method] = 0
+            continue
+
+        if not dry_run:
+            os.makedirs(dst_dir, exist_ok=True)
+            for src_f, dst_name in tqdm(files, desc=f"  {method}", leave=False):
+                _copy(src_f, os.path.join(dst_dir, dst_name))
+
+        counts[method] = len(files)
+
+    return counts
+
+
+# ---------------------------------------------------------------------------
+# Verification
+# ---------------------------------------------------------------------------
+
+
+def verify(datasets: list[str]) -> bool:
+    """Check that every expected output directory is non-empty."""
+    ok = True
+    print("\nVerification")
+    print("-" * 60)
+
+    for ds in datasets:
+        gt_dir = os.path.join(ROOT, "data", ds, "GT")
+        n_gt = len(glob(os.path.join(gt_dir, "*.png")))
+        status = "OK" if n_gt > 0 else "EMPTY"
+        print(f"  data/{ds}/GT          → {n_gt:4d} files  [{status}]")
+        if n_gt == 0:
+            ok = False
+
+        inp_dir = os.path.join(ROOT, "data", ds, "inputs")
+        n_inp = len(glob(os.path.join(inp_dir, "*.png")))
+        status = "OK" if n_inp > 0 else "EMPTY"
+        print(f"  data/{ds}/inputs      → {n_inp:4d} files  [{status}]")
+        if n_inp == 0:
+            ok = False
+
+        for m in METHODS:
+            d = os.path.join(ROOT, "results", ds, m)
+            if os.path.isdir(d):
+                n = len(glob(os.path.join(d, "*.png")))
+                status = "OK" if n > 0 else "EMPTY"
+                print(f"  results/{ds}/{m:<14} → {n:4d} files  [{status}]")
+                if n == 0:
+                    ok = False
+            else:
+                print(f"  results/{ds}/{m:<14} → MISSING")
+                # Not every method must exist; treat as non-fatal warning.
+
+    return ok
+
+
+# ---------------------------------------------------------------------------
+# Cleanup
+# ---------------------------------------------------------------------------
+
+
+def cleanup(datasets: list[str]) -> None:
+    """Delete the original Sen2_MTC_* directories."""
+    for ds in datasets:
+        old_dir = os.path.join(ROOT, ds)
+        if os.path.isdir(old_dir):
+            print(f"  Removing {old_dir} …")
+            shutil.rmtree(old_dir)
+        else:
+            print(f"  Already gone: {old_dir}")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="Migrate visualization directory to the cleaned-up layout."
+    )
+    ap.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print a summary of what would happen without touching the filesystem.",
+    )
+    ap.add_argument(
+        "--skip-cleanup",
+        action="store_true",
+        help="Do not delete the old Sen2_MTC_* directories after migration.",
+    )
+    ap.add_argument(
+        "--dataset",
+        type=str,
+        default=None,
+        choices=["Sen2_MTC_New", "Sen2_MTC_Old"],
+        help="Migrate only this dataset (default: both).",
+    )
+    args = ap.parse_args()
+
+    datasets = [args.dataset] if args.dataset else ["Sen2_MTC_New", "Sen2_MTC_Old"]
+
+    if args.dry_run:
+        print("=" * 60)
+        print("DRY RUN – no files will be copied or deleted")
+        print("=" * 60)
+
+    total_gt = 0
+    total_inputs = 0
+    total_results: dict[str, dict[str, int]] = {}
+
+    for ds in datasets:
+        src_base = os.path.join(ROOT, ds)
+        dst_data = os.path.join(ROOT, "data", ds)
+        dst_results = os.path.join(ROOT, "results", ds)
+
+        if not os.path.isdir(src_base):
+            print(f"\n[ERROR] Source directory not found: {src_base}", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"\n{'=' * 60}")
+        print(f"  Dataset: {ds}")
+        print(f"{'=' * 60}")
+
+        # Ground truth
+        print("  Step 1/3 – GT images")
+        n_gt = migrate_gt(src_base, dst_data, dry_run=args.dry_run)
+        total_gt += n_gt
+        print(f"    → {n_gt} GT images {'(would copy)' if args.dry_run else 'copied'}")
+
+        # Input images
+        print("  Step 2/3 – Cloudy inputs")
+        n_inp = migrate_inputs(src_base, dst_data, dry_run=args.dry_run)
+        total_inputs += n_inp
+        print(
+            f"    → {n_inp} input images ({n_inp // 3 if n_inp else 0} samples × 3) "
+            f"{'(would copy)' if args.dry_run else 'copied'}"
+        )
+
+        # Per-method outputs
+        print("  Step 3/3 – Method outputs")
+        counts = migrate_outputs(src_base, dst_results, ds, dry_run=args.dry_run)
+        total_results[ds] = counts
+        for method, n in counts.items():
+            print(
+                f"    {method:<14} → {n:4d} images "
+                f"{'(would copy)' if args.dry_run else 'copied'}"
+            )
+
+    # ---- Summary -----------------------------------------------------------
+    print(f"\n{'=' * 60}")
+    print("Summary")
+    print(f"{'=' * 60}")
+    print(f"  GT images   : {total_gt}")
+    print(f"  Input images: {total_inputs}")
+    for ds, counts in total_results.items():
+        total_preds = sum(counts.values())
+        print(f"  Results ({ds}): {total_preds}")
+
+    if args.dry_run:
+        print("\n[DRY RUN] Nothing was written.  Re-run without --dry-run to proceed.")
+        return
+
+    # ---- Verify before deleting --------------------------------------------
+    ok = verify(datasets)
+
+    if not ok:
+        print(
+            "\n[ERROR] Verification found empty directories. "
+            "Old directories were NOT deleted.\n"
+            "Please inspect the output above and re-run.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # ---- Cleanup -----------------------------------------------------------
+    if args.skip_cleanup:
+        print("\n[INFO] --skip-cleanup set: original directories kept.")
+        print("       Delete them manually when you are satisfied with the result.")
+    else:
+        print("\nAll checks passed.  Deleting original directories …")
+        cleanup(datasets)
+        print("Done.")
+
+
+if __name__ == "__main__":
+    main()

results/Sen2_MTC_New/ae.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0f4f9ade3fb57847dae7b03047b18dcbd532a5bb7e3d1c984641e7540eb9546
+size 80777775

results/Sen2_MTC_New/crtsnet.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5387005b11099e688a5878b2c70b58929319838dfe5224af9fd25361c79345b5
+size 72081099

results/Sen2_MTC_New/ctgan.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea6ca30d463dbdb061aa307c27837443668256267625c5e77d720f5c9e914d88
+size 71862201

results/Sen2_MTC_New/ddpmcr.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f80b08d20ac8bf2d3ba198d5fc0e56545279b9114f4cbfca25e5749005899d6
+size 76255668

results/Sen2_MTC_New/diffcr.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4dc39c9b918712304e7417ff3a684791c8cf73b8b21a0d8bb086d8b5720468a0
+size 76906612

results/Sen2_MTC_New/dsen2cr.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:362277361d1c98c2e01c17f6bdf8815f33c8c8db16b1d111ed24896145dce516
+size 75093757

results/Sen2_MTC_New/mcgan.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a27a51b38a258feebdc801b1b405dc10c8ef78cdeb70c6637d218142aaae8891
+size 76440136

results/Sen2_MTC_New/pix2pix.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4fa07468294dc8b6d52709c34391243d08ab967229939c7085079cc88d168ca
+size 65461714

results/Sen2_MTC_New/pmaa.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7cd2c778db4b1f2bbffd107656901ed4c1f7957c851cfc700d54ba4c01b65e83
+size 66349904

results/Sen2_MTC_New/stgan.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4584b58104796132d4c63348fc7830ebb93719c426e90c816c838a01c3324309
+size 71041976

results/Sen2_MTC_New/stnet.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23081ff40bf4c6fab992b92ca973e8c100e4683402f02f4747d2348626e10b36
+size 71763303

results/Sen2_MTC_New/uncrtaints.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf9b99fbdf6651c854dc551f39590b0a5021c214857f5e31caa368e9da82a8cf
+size 71233492

results/Sen2_MTC_Old/ae.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7d663a7de8b8c188063a09a0b23e8c1824eb27ace5da161608e69bde9ec315f
+size 26343290

results/Sen2_MTC_Old/crtsnet.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2105e13b8717fd94f643511bd1872901db712281bbe57006786845ae34cf891b
+size 15463290

results/Sen2_MTC_Old/ctgan.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd8af029938d4700a9b8166efbd4b754f59a3cfb7ced27daac73c0dc7a5733a9
+size 14675294

results/Sen2_MTC_Old/ddpmcr.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94f90c1ff4357b4c8a0769679f0223ca58ede94a0327db7baae00c490bbe504b
+size 17755866

results/Sen2_MTC_Old/diffcr.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddece6453d196e83d51b38a2670adb1a4fed33602cb57f6b81ca922f1b22cdd9
+size 16989551

results/Sen2_MTC_Old/dsen2cr.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86c52e8a383193431ced952a2f5c34458df8be43896febedacd1e06aa81306c4
+size 18424684

results/Sen2_MTC_Old/mcgan.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50194271bb98ec379f589b0a01e871becc494da9ef93329f48d9295fa1baa5f2
+size 20775365

results/Sen2_MTC_Old/pix2pix.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bccaf4628a73696b639946d22c49864b78c87e2904dff28f3a9beb9813907788
+size 14021035

results/Sen2_MTC_Old/pmaa.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:873cbe7d0c4749753185fcd2ba22fbc07978b042ac292d8dc304269ed0464ad9
+size 15326226

results/Sen2_MTC_Old/stgan.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8ff8b58b0895aaac911e64ed0281e61ab7fea178c01fe15af84446a422ec71b
+size 18320727

results/Sen2_MTC_Old/stnet.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffc3fadff8b417043b74dc1a2db2b4e72e6c398dfd4804f9e1c731235ee9a44c
+size 13290229

results/Sen2_MTC_Old/uncrtaints.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a08008e0e8e6158fcd431dbaca0cdd4dbbbfda17ba541da8a0e278369983255a
+size 15294336