code/scripts/v4_eval_fulldata.py

"""
V4: Evaluate all full-data conditions on the validation set.
Supports kvasir (binary), cvc (binary), refuge2 (3-class).
Saves predicted masks, overlay visualizations, and per-image metrics.

Usage:
  CUDA_VISIBLE_DEVICES=0 python scripts/v4_eval_fulldata.py --dataset kvasir
  CUDA_VISIBLE_DEVICES=0 python scripts/v4_eval_fulldata.py --dataset cvc
  CUDA_VISIBLE_DEVICES=0 python scripts/v4_eval_fulldata.py --dataset refuge2
"""
import sys
sys.path.insert(0, "/data/sichengli/Code/PixelGen")

import argparse
import os
import json
import random
import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from PIL import Image
import torchvision.transforms as transforms
import torchvision.transforms.functional as TF
import segmentation_models_pytorch as smp

from segmentation.metrics import compute_dice_iou_binary, compute_dice_iou_multiclass


# ─── Config ───────────────────────────────────────────────────────────
DATASET_CONFIGS = {
    "kvasir": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/Kvasir-SEG/Kvasir-SEG",
        "img_subdir": "images", "mask_subdir": "masks",
        "file_ext": (".jpg", ".png", ".jpeg"),
        "multi_split": False, "train_ratio": 0.9,
        "task": "binary", "num_classes": 1,
    },
    "cvc": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/CVC-ClinicDB",
        "img_subdir": "PNG/Original", "mask_subdir": "PNG/Ground Truth",
        "file_ext": (".png",),
        "multi_split": False, "train_ratio": 0.9,
        "task": "binary", "num_classes": 1,
    },
    "refuge2": {
        "data_root": "/data2/sichengli/Data/test/Segmentation/REFUGE2",
        "splits": ["train", "val"],
        "file_ext": (".jpg", ".png", ".jpeg"),
        "mask_ext": (".bmp", ".png"),
        "multi_split": True, "val_ratio": 0.1,
        "task": "multiclass", "num_classes": 3,
        "class_mapping": {0: 0, 128: 1, 255: 2},
    },
}

WORK_DIR_BASE = "/data/sichengli/Code/PixelGen/synergy_v4_workdir"
RESOLUTION = 256
SPLIT_SEED = 42
EVAL_SEED = 42

IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD = [0.229, 0.224, 0.225]

CONDITIONS = ["no_aug", "baseline", "cycle", "consist", "cycle_consist"]


# ─── Mask Processing ─────────────────────────────────────────────────
def process_mask(mask_pil, task, class_mapping=None):
    mask_np = np.array(mask_pil)
    if task == "binary":
        mask_np = (mask_np > 127).astype(np.float32)
        return torch.from_numpy(mask_np).unsqueeze(0)
    else:
        result = np.zeros_like(mask_np, dtype=np.int64)
        for pixel_val, class_idx in class_mapping.items():
            result[mask_np == pixel_val] = class_idx
        for pixel_val in np.unique(mask_np):
            if pixel_val not in class_mapping:
                closest = min(class_mapping.keys(), key=lambda x: abs(x - pixel_val))
                result[mask_np == pixel_val] = class_mapping[closest]
        return torch.from_numpy(result).long()


# ─── Dataset ──────────────────────────────────────────────────────────
class ValDataset(Dataset):
    """Validation set with filenames preserved."""
    def __init__(self, dataset_name):
        cfg = DATASET_CONFIGS[dataset_name]
        self.task = cfg["task"]
        self.class_mapping = cfg.get("class_mapping")
        self.normalize = transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)

        if cfg["multi_split"]:
            all_pairs = []
            for s in cfg["splits"]:
                img_dir = os.path.join(cfg["data_root"], s, "images")
                mask_dir = os.path.join(cfg["data_root"], s, "mask")
                img_files = sorted([f for f in os.listdir(img_dir) if f.endswith(cfg["file_ext"])])
                for img_f in img_files:
                    base = os.path.splitext(img_f)[0]
                    img_path = os.path.join(img_dir, img_f)
                    for ext in cfg["mask_ext"]:
                        candidate = os.path.join(mask_dir, base + ext)
                        if os.path.exists(candidate):
                            all_pairs.append((img_path, candidate, f"{s}_{base}"))
                            break
            random.seed(SPLIT_SEED)
            # Need to shuffle pairs consistently (without fname)
            pairs_for_shuffle = [(ip, mp) for ip, mp, _ in all_pairs]
            fnames_for_shuffle = [fn for _, _, fn in all_pairs]
            combined = list(zip(pairs_for_shuffle, fnames_for_shuffle))
            random.shuffle(combined)
            split_idx = int(len(combined) * (1 - cfg.get("val_ratio", 0.1)))
            val_combined = combined[split_idx:]
            self.pairs = [(ip, mp, fn) for (ip, mp), fn in val_combined]
        else:
            img_dir = os.path.join(cfg["data_root"], cfg["img_subdir"])
            mask_dir = os.path.join(cfg["data_root"], cfg["mask_subdir"])
            all_files = sorted([f for f in os.listdir(img_dir) if f.endswith(cfg["file_ext"])])
            random.seed(SPLIT_SEED)
            indices = list(range(len(all_files)))
            random.shuffle(indices)
            split_idx = int(len(indices) * cfg["train_ratio"])
            val_indices = indices[split_idx:]
            val_files = [all_files[i] for i in sorted(val_indices)]
            self.pairs = []
            for f in val_files:
                ip = os.path.join(img_dir, f)
                mp = os.path.join(mask_dir, f)
                if os.path.exists(mp):
                    self.pairs.append((ip, mp, os.path.splitext(f)[0]))

        print(f"[ValDataset-{dataset_name}] {len(self.pairs)} validation samples")

    def __len__(self):
        return len(self.pairs)

    def __getitem__(self, idx):
        img_path, mask_path, fname = self.pairs[idx]
        image = Image.open(img_path).convert("RGB")
        mask = Image.open(mask_path).convert("L")

        image = TF.resize(image, (RESOLUTION, RESOLUTION),
                          interpolation=transforms.InterpolationMode.BILINEAR)
        mask = TF.resize(mask, (RESOLUTION, RESOLUTION),
                         interpolation=transforms.InterpolationMode.NEAREST)

        image_tensor = self.normalize(TF.to_tensor(image))
        mask_tensor = process_mask(mask, self.task, self.class_mapping)
        raw_image = TF.to_tensor(image)

        return image_tensor, mask_tensor, raw_image, fname


# ─── Visualization ────────────────────────────────────────────────────
def make_overlay_binary(raw_img, gt_mask, pred_mask):
    img_np = (raw_img.permute(1, 2, 0).numpy() * 255).astype(np.uint8)

    gt_overlay = img_np.copy()
    gt_overlay[gt_mask > 0.5, 1] = np.clip(gt_overlay[gt_mask > 0.5, 1].astype(np.int32) + 100, 0, 255).astype(np.uint8)

    pred_overlay = img_np.copy()
    tp = (pred_mask > 0.5) & (gt_mask > 0.5)
    fp = (pred_mask > 0.5) & (gt_mask < 0.5)
    fn = (pred_mask < 0.5) & (gt_mask > 0.5)
    pred_overlay[tp, 1] = np.clip(pred_overlay[tp, 1].astype(np.int32) + 100, 0, 255).astype(np.uint8)
    pred_overlay[fp, 0] = np.clip(pred_overlay[fp, 0].astype(np.int32) + 100, 0, 255).astype(np.uint8)
    pred_overlay[fn, 2] = np.clip(pred_overlay[fn, 2].astype(np.int32) + 100, 0, 255).astype(np.uint8)

    return Image.fromarray(np.concatenate([img_np, gt_overlay, pred_overlay], axis=1))


def make_overlay_multiclass(raw_img, gt_mask, pred_mask, num_classes=3):
    """Colors: class1=green, class2=blue."""
    img_np = (raw_img.permute(1, 2, 0).numpy() * 255).astype(np.uint8)
    colors = {1: np.array([0, 100, 0]), 2: np.array([0, 0, 100])}  # class -> RGB delta

    gt_overlay = img_np.copy()
    for c, delta in colors.items():
        mask_c = gt_mask == c
        for ch in range(3):
            gt_overlay[mask_c, ch] = np.clip(gt_overlay[mask_c, ch].astype(np.int32) + delta[ch], 0, 255).astype(np.uint8)

    pred_overlay = img_np.copy()
    for c, delta in colors.items():
        tp = (pred_mask == c) & (gt_mask == c)
        fp = (pred_mask == c) & (gt_mask != c)
        for ch in range(3):
            pred_overlay[tp, ch] = np.clip(pred_overlay[tp, ch].astype(np.int32) + delta[ch], 0, 255).astype(np.uint8)
        pred_overlay[fp, 0] = np.clip(pred_overlay[fp, 0].astype(np.int32) + 100, 0, 255).astype(np.uint8)

    # FN for any foreground
    fn = (pred_mask == 0) & (gt_mask > 0)
    pred_overlay[fn, 2] = np.clip(pred_overlay[fn, 2].astype(np.int32) + 100, 0, 255).astype(np.uint8)

    return Image.fromarray(np.concatenate([img_np, gt_overlay, pred_overlay], axis=1))


# ─── Evaluation ───────────────────────────────────────────────────────
@torch.no_grad()
def evaluate_condition(condition, device, dataset_name, loader, task, num_classes, out_dir, work_dir):
    ckpt_path = os.path.join(work_dir, "checkpoints", f"full_{condition}_seed{EVAL_SEED}", "best.pth")
    if not os.path.exists(ckpt_path):
        print(f"  [SKIP] {ckpt_path} not found")
        return None

    out_classes = 1 if task == "binary" else num_classes
    model = smp.Unet(encoder_name="resnet34", encoder_weights="imagenet",
                     in_channels=3, classes=out_classes)
    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
    model.load_state_dict(ckpt["model_state_dict"])
    model = model.to(device).eval()
    print(f"  Loaded: {os.path.basename(ckpt_path)} (best_dice={ckpt['best_dice']:.4f}, epoch={ckpt['epoch']})")

    cond_dir = os.path.join(out_dir, condition)
    pred_dir = os.path.join(cond_dir, "predictions")
    vis_dir = os.path.join(cond_dir, "visualizations")
    os.makedirs(pred_dir, exist_ok=True)
    os.makedirs(vis_dir, exist_ok=True)

    per_image = []
    all_dices = []
    all_ious = []

    for images, masks, raw_images, fnames in loader:
        images = images.to(device)
        masks = masks.to(device)
        bs = images.shape[0]
        logits = model(images)

        for i in range(bs):
            fname = fnames[i]

            if task == "binary":
                dice, iou = compute_dice_iou_binary(logits[i:i+1], masks[i:i+1])
                pred_np = (torch.sigmoid(logits[i, 0]).cpu().numpy() > 0.5).astype(np.uint8) * 255
                overlay = make_overlay_binary(
                    raw_images[i].cpu(),
                    masks[i, 0].cpu().numpy(),
                    (torch.sigmoid(logits[i, 0]).cpu().numpy() > 0.5).astype(np.float32)
                )
            else:
                dice, iou, _, _ = compute_dice_iou_multiclass(logits[i:i+1], masks[i:i+1], num_classes)
                pred_cls = logits[i].argmax(dim=0).cpu().numpy().astype(np.uint8)
                # Save as class indices (0, 1, 2) * 127 for visibility
                pred_np = (pred_cls * 127).astype(np.uint8)
                overlay = make_overlay_multiclass(
                    raw_images[i].cpu(),
                    masks[i].cpu().numpy(),
                    pred_cls,
                    num_classes
                )

            Image.fromarray(pred_np).save(os.path.join(pred_dir, f"{fname}.png"))
            overlay.save(os.path.join(vis_dir, f"{fname}.png"))

            per_image.append({"filename": fname, "dice": round(dice, 4), "iou": round(iou, 4)})
            all_dices.append(dice)
            all_ious.append(iou)

    mean_dice = float(np.mean(all_dices))
    mean_iou = float(np.mean(all_ious))
    std_dice = float(np.std(all_dices))
    std_iou = float(np.std(all_ious))

    result = {
        "condition": condition, "seed": EVAL_SEED, "dataset": dataset_name,
        "num_samples": len(per_image),
        "mean_dice": round(mean_dice, 4), "std_dice": round(std_dice, 4),
        "mean_iou": round(mean_iou, 4), "std_iou": round(std_iou, 4),
        "per_image": per_image,
    }
    with open(os.path.join(cond_dir, "metrics.json"), "w") as f:
        json.dump(result, f, indent=2)

    print(f"  {condition}: Dice={mean_dice:.4f}±{std_dice:.4f}, IoU={mean_iou:.4f}±{std_iou:.4f}")
    return result


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset", type=str, required=True, choices=["kvasir", "cvc", "refuge2"])
    args = parser.parse_args()

    cfg = DATASET_CONFIGS[args.dataset]
    task = cfg["task"]
    num_classes = cfg["num_classes"]
    device = torch.device("cuda:0")

    work_dir = os.path.join(WORK_DIR_BASE, args.dataset)
    out_dir = os.path.join(work_dir, "eval_fulldata")
    os.makedirs(out_dir, exist_ok=True)

    dataset = ValDataset(args.dataset)
    loader = DataLoader(dataset, batch_size=16, shuffle=False, num_workers=4, pin_memory=True)

    print(f"\n{'='*60}")
    print(f"  V4 Full-Data Eval: {args.dataset} ({task})")
    print(f"  Checkpoint seed: {EVAL_SEED}")
    print(f"{'='*60}\n")

    all_results = {}
    for condition in CONDITIONS:
        print(f"\n--- {condition} ---")
        result = evaluate_condition(condition, device, args.dataset, loader,
                                     task, num_classes, out_dir, work_dir)
        if result is not None:
            all_results[condition] = {
                "mean_dice": result["mean_dice"], "std_dice": result["std_dice"],
                "mean_iou": result["mean_iou"], "std_iou": result["std_iou"],
            }

    # Summary
    print(f"\n{'='*60}")
    print(f"  {args.dataset.upper()} SUMMARY (seed={EVAL_SEED})")
    print(f"{'='*60}")
    print(f"{'Condition':<18s} | {'Dice':>12s} | {'IoU':>12s} | {'vs baseline':>12s}")
    print("-" * 60)
    bl = all_results.get("baseline", {}).get("mean_dice")
    for cond in CONDITIONS:
        if cond not in all_results:
            continue
        r = all_results[cond]
        d_str = f"{r['mean_dice']:.4f}±{r['std_dice']:.4f}"
        i_str = f"{r['mean_iou']:.4f}±{r['std_iou']:.4f}"
        delta = f"{r['mean_dice'] - bl:+.4f}" if bl and cond != "baseline" else "-"
        print(f"{cond:<18s} | {d_str:>12s} | {i_str:>12s} | {delta:>12s}")
    print("=" * 60)

    with open(os.path.join(out_dir, "summary.json"), "w") as f:
        json.dump(all_results, f, indent=2)
    print(f"\nResults saved to: {out_dir}")


if __name__ == "__main__":
    main()