scripts/build_hq_pair_manifests.py

from __future__ import annotations

import argparse
import csv
import json
import math
import os
import random
import re
from collections import Counter, defaultdict
from pathlib import Path
from statistics import mean, median
from typing import Any

from PIL import Image


PAIR_COLUMNS = [
    "latent",
    "mate",
    "identity_label",
    "subject",
    "fgp",
    "comp_path",
    "lffs_path",
    "domain",
    "device",
    "ppi",
    "capture",
    "split",
]


def read_csv(path: Path) -> list[dict[str, str]]:
    with path.open(newline="", encoding="utf-8") as handle:
        return list(csv.DictReader(handle))


def write_csv(path: Path, rows: list[dict[str, str]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=PAIR_COLUMNS, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def parse_mate_domain(path: str) -> dict[str, str] | None:
    parts = Path(path).parts
    if "nist302g_png" not in parts:
        return None
    domain = "challenger" if "challengers" in parts else "baseline"
    capture = ""
    for idx, part in enumerate(parts):
        if part in {"R", "S", "U", "V", "C"} and idx + 1 < len(parts):
            ppi = parts[idx + 1]
            stem = Path(path).stem
            if "_roll_" in stem:
                capture = "roll"
            elif "_slap_" in stem:
                capture = "slap"
            return {
                "domain": domain,
                "device": part,
                "ppi": ppi,
                "capture": capture,
            }
    return None


def image_metadata(path: Path) -> dict[str, Any]:
    with Image.open(path) as image:
        dpi = image.info.get("dpi")
        return {
            "width": image.size[0],
            "height": image.size[1],
            "dpi_x": float(dpi[0]) if dpi else None,
            "dpi_y": float(dpi[1]) if dpi else None,
        }


def grayscale_quality(path: Path, max_side: int = 768) -> dict[str, float]:
    with Image.open(path) as image:
        image = image.convert("L")
        scale = min(1.0, max_side / max(image.size))
        if scale < 1.0:
            size = (
                max(1, int(round(image.size[0] * scale))),
                max(1, int(round(image.size[1] * scale))),
            )
            image = image.resize(size, Image.Resampling.BILINEAR)
        hist = image.histogram()
    total = sum(hist)
    if total <= 0:
        return {"mean": 0.0, "std": 0.0, "entropy": 0.0, "white_frac": 0.0}
    avg = sum(i * count for i, count in enumerate(hist)) / total
    var = sum(((i - avg) ** 2) * count for i, count in enumerate(hist)) / total
    entropy = 0.0
    for count in hist:
        if count:
            p = count / total
            entropy -= p * math.log2(p)
    return {
        "mean": avg,
        "std": math.sqrt(var),
        "entropy": entropy,
        "white_frac": sum(hist[250:]) / total,
    }


def quality_ok(path: Path, min_std: float, min_entropy: float, max_white_frac: float) -> tuple[bool, dict[str, float]]:
    q = grayscale_quality(path)
    ok = q["std"] >= min_std and q["entropy"] >= min_entropy and q["white_frac"] <= max_white_frac
    return ok, q


def is_hq_vu1000(row: dict[str, str]) -> bool:
    domain = parse_mate_domain(row.get("mate", ""))
    if not domain:
        return False
    return (
        domain["domain"] == "baseline"
        and domain["device"] in {"V", "U"}
        and domain["ppi"] == "1000"
        and domain["capture"] == "roll"
    )


def split_subjects(subjects: list[str], seed: int, train_frac: float, val_frac: float) -> dict[str, str]:
    shuffled = list(subjects)
    random.Random(seed).shuffle(shuffled)
    n_train = int(round(len(shuffled) * train_frac))
    n_val = int(round(len(shuffled) * val_frac))
    split: dict[str, str] = {}
    for subject in shuffled[:n_train]:
        split[subject] = "train"
    for subject in shuffled[n_train : n_train + n_val]:
        split[subject] = "val"
    for subject in shuffled[n_train + n_val :]:
        split[subject] = "test"
    return split


def describe(values: list[int]) -> dict[str, Any]:
    if not values:
        return {}
    return {
        "count": len(values),
        "min": min(values),
        "mean": mean(values),
        "median": median(values),
        "max": max(values),
    }


def summarize_rows(rows: list[dict[str, str]]) -> dict[str, Any]:
    by_id = Counter(row["identity_label"] for row in rows)
    by_subject = Counter(row["subject"] for row in rows)
    by_mate = Counter(row["mate"] for row in rows)
    by_split = Counter(row["split"] for row in rows)
    by_device = Counter((row["domain"], row["device"], row["ppi"], row["capture"]) for row in rows)
    return {
        "rows": len(rows),
        "unique_subjects": len(by_subject),
        "unique_identity_labels": len(by_id),
        "unique_mates": len(by_mate),
        "split_counts": dict(sorted(by_split.items())),
        "device_counts": {str(k): v for k, v in sorted(by_device.items())},
        "rows_per_identity": describe(list(by_id.values())),
        "rows_per_mate": describe(list(by_mate.values())),
        "identity_count_distribution": dict(sorted(Counter(by_id.values()).items())),
        "mate_fanout_distribution": dict(sorted(Counter(by_mate.values()).items())),
    }


def manifest_key(path: Path) -> tuple[str, str]:
    match = re.search(r"paired_302i_(original|enhanced)_(masked|unmasked)\.csv$", path.name)
    if not match:
        raise ValueError(f"Unexpected manifest name: {path}")
    return match.group(1), match.group(2)


def link_exemplars(rows: list[dict[str, str]], link_root: Path) -> int:
    link_root.mkdir(parents=True, exist_ok=True)
    created = 0
    seen: set[str] = set()
    for row in rows:
        src = Path(row["mate"]).resolve()
        if str(src) in seen:
            continue
        seen.add(str(src))
        domain = parse_mate_domain(str(src))
        if domain is None:
            continue
        subject = row["subject"]
        dst = link_root / domain["domain"] / "irr" / domain["device"] / domain["ppi"] / subject / src.name
        dst.parent.mkdir(parents=True, exist_ok=True)
        if dst.exists():
            continue
        rel_src = os.path.relpath(src, dst.parent)
        dst.symlink_to(rel_src)
        created += 1
    return created


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--manifest-root", default="manifests/nist302")
    parser.add_argument("--out-root", default="manifests/nist302_hq_pairs")
    parser.add_argument("--link-exemplar-root", default="data/derived/nist302g_hq_vu1000")
    parser.add_argument("--seed", type=int, default=302)
    parser.add_argument("--train-frac", type=float, default=0.80)
    parser.add_argument("--val-frac", type=float, default=0.10)
    parser.add_argument("--min-std", type=float, default=25.0)
    parser.add_argument("--min-entropy", type=float, default=1.20)
    parser.add_argument("--max-white-frac", type=float, default=0.92)
    parser.add_argument("--no-quality-filter", action="store_true")
    args = parser.parse_args()

    manifest_root = Path(args.manifest_root)
    out_root = Path(args.out_root)
    link_root = Path(args.link_exemplar_root)

    input_manifests = [
        path
        for path in sorted(manifest_root.glob("*_ready/paired_302i_*.csv"))
        if not path.name.endswith("_with_irr.csv")
    ]
    if not input_manifests:
        raise FileNotFoundError(f"No ready paired manifests found under {manifest_root}")

    base_rows = [row for path in input_manifests for row in read_csv(path) if is_hq_vu1000(row)]
    subjects = sorted({row["subject"] for row in base_rows if row.get("subject")})
    subject_split = split_subjects(subjects, args.seed, args.train_frac, args.val_frac)

    quality_cache: dict[str, tuple[bool, dict[str, float]]] = {}
    all_written_rows: list[dict[str, str]] = []
    reports: dict[str, Any] = {}

    for manifest_path in input_manifests:
        variant, mask = manifest_key(manifest_path)
        rows = read_csv(manifest_path)
        kept: list[dict[str, str]] = []
        drop_counts: Counter[str] = Counter()
        quality_values: dict[str, list[float]] = defaultdict(list)

        for row in rows:
            if not is_hq_vu1000(row):
                drop_counts["non_hq_domain"] += 1
                continue
            mate_path = Path(row["mate"])
            try:
                meta = image_metadata(mate_path)
            except Exception:
                drop_counts["mate_unreadable"] += 1
                continue
            if meta["width"] != 1600 or meta["height"] != 1500:
                drop_counts["non_1600x1500"] += 1
                continue
            if meta["dpi_x"] is None or abs(meta["dpi_x"] - 1000.0) > 2.0:
                drop_counts["non_1000dpi"] += 1
                continue
            if not args.no_quality_filter:
                key = str(mate_path)
                if key not in quality_cache:
                    quality_cache[key] = quality_ok(mate_path, args.min_std, args.min_entropy, args.max_white_frac)
                ok, quality = quality_cache[key]
                for q_key, q_value in quality.items():
                    quality_values[q_key].append(q_value)
                if not ok:
                    drop_counts["low_quality_mate"] += 1
                    continue

            domain = parse_mate_domain(row["mate"])
            assert domain is not None
            out_row = dict(row)
            out_row.update(domain)
            out_row["split"] = subject_split[row["subject"]]
            kept.append(out_row)

        out_dir = out_root / f"{variant}_{mask}"
        write_csv(out_dir / f"paired_302i_{variant}_{mask}_hq_vu1000_all.csv", kept)
        for split in ("train", "val", "test"):
            split_rows = [row for row in kept if row["split"] == split]
            write_csv(out_dir / f"paired_302i_{variant}_{mask}_hq_vu1000_{split}.csv", split_rows)
        all_written_rows.extend(kept)
        reports[f"{variant}_{mask}"] = {
            "source": str(manifest_path),
            "dropped": dict(sorted(drop_counts.items())),
            "quality_thresholds": {
                "min_std": args.min_std,
                "min_entropy": args.min_entropy,
                "max_white_frac": args.max_white_frac,
                "enabled": not args.no_quality_filter,
            },
            "quality_observed": {
                key: {
                    "min": min(values),
                    "mean": mean(values),
                    "max": max(values),
                }
                for key, values in quality_values.items()
            },
            "summary": summarize_rows(kept),
            "outputs": {
                "all": str(out_dir / f"paired_302i_{variant}_{mask}_hq_vu1000_all.csv"),
                "train": str(out_dir / f"paired_302i_{variant}_{mask}_hq_vu1000_train.csv"),
                "val": str(out_dir / f"paired_302i_{variant}_{mask}_hq_vu1000_val.csv"),
                "test": str(out_dir / f"paired_302i_{variant}_{mask}_hq_vu1000_test.csv"),
            },
        }

    linked = link_exemplars(all_written_rows, link_root)
    report = {
        "manifest_root": str(manifest_root),
        "out_root": str(out_root),
        "link_exemplar_root": str(link_root),
        "symlinks_created": linked,
        "seed": args.seed,
        "subject_split_counts": dict(sorted(Counter(subject_split.values()).items())),
        "subject_split": subject_split,
        "variants": reports,
    }
    out_root.mkdir(parents=True, exist_ok=True)
    (out_root / "summary_hq_vu1000.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
    print(json.dumps({
        "out_root": str(out_root),
        "link_exemplar_root": str(link_root),
        "subject_split_counts": report["subject_split_counts"],
        "variants": {key: value["summary"]["split_counts"] for key, value in reports.items()},
        "symlinks_created": linked,
    }, indent=2, sort_keys=True))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())