evaluation/visual_metric/evaluate_visual.py

import argparse
import csv
import logging
import subprocess
from pathlib import Path

import numpy as np

from image_metrics import CLIPImageMetric, LPIPSMetric, calculate_fid


SUPPORTED_MODEL_EXTENSIONS = (".obj", ".ply", ".glb", ".gltf", ".fbx", ".stl")


def configure_logging(output_dir: Path) -> None:
    output_dir.mkdir(parents=True, exist_ok=True)
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s [%(levelname)s] %(message)s",
        handlers=[logging.FileHandler(output_dir / "visual_evaluation.log"), logging.StreamHandler()],
    )


def render_complete(render_dir: Path, num_views: int) -> bool:
    return all((render_dir / f"{index:03d}.png").exists() for index in range(num_views))


def render_model(
    blender: str,
    render_script: Path,
    model_path: Path,
    output_root: Path,
    split: str,
    resolution: int,
    num_views: int,
    overwrite: bool,
) -> Path:
    render_dir = output_root / split / model_path.stem
    if not overwrite and render_complete(render_dir, num_views):
        logging.info("Skipping existing render: %s", render_dir)
        return render_dir

    render_dir.mkdir(parents=True, exist_ok=True)
    command = [
        blender,
        "-b",
        "-P",
        str(render_script),
        "--",
        "--object",
        str(model_path),
        "--output-folder",
        str(render_dir),
        "--resolution",
        str(resolution),
        "--num-views",
        str(num_views),
    ]
    logging.info("Rendering %s", model_path)
    subprocess.run(command, check=True)
    return render_dir


def compare_render_dirs(gt_dir: Path, pred_dir: Path, lpips_metric: LPIPSMetric, clip_metric: CLIPImageMetric | None, num_views: int) -> dict[str, float]:
    lpips_values = []
    clip_values = []

    for index in range(num_views):
        gt_image = gt_dir / f"{index:03d}.png"
        pred_image = pred_dir / f"{index:03d}.png"
        if not gt_image.exists() or not pred_image.exists():
            logging.warning("Missing rendered view %03d for %s or %s", index, gt_dir.name, pred_dir.name)
            continue
        lpips_values.append(lpips_metric(gt_image, pred_image))
        if clip_metric is not None:
            clip_values.append(clip_metric(pred_image, gt_image))

    return {
        "rgb_lpips": float(np.mean(lpips_values)) if lpips_values else np.nan,
        "clip_score": float(np.mean(clip_values)) if clip_values else np.nan,
    }


def find_prediction(gt_path: Path, pred_dir: Path) -> Path | None:
    for extension in SUPPORTED_MODEL_EXTENSIONS:
        candidate = pred_dir / f"{gt_path.stem}{extension}"
        if candidate.exists():
            return candidate
    return None


def collect_pairs(gt_dir: Path, pred_dir: Path) -> list[tuple[Path, Path]]:
    pairs = []
    for gt_path in sorted(gt_dir.iterdir()):
        if not gt_path.is_file() or gt_path.suffix.lower() not in SUPPORTED_MODEL_EXTENSIONS:
            continue
        pred_path = find_prediction(gt_path, pred_dir)
        if pred_path is None:
            logging.warning("No prediction found for %s", gt_path.name)
            continue
        pairs.append((gt_path, pred_path))
    return pairs


def save_results(results: list[dict[str, object]], output_dir: Path) -> Path:
    csv_path = output_dir / "visual_summary.csv"
    fieldnames = ["model", "prediction", "rgb_lpips", "clip_score", "fid"]
    with csv_path.open("w", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames)
        writer.writeheader()
        for row in results:
            writer.writerow({key: row.get(key, "") for key in fieldnames})
    return csv_path


def build_parser() -> argparse.ArgumentParser:
    default_render_script = Path(__file__).with_name("render.py")
    parser = argparse.ArgumentParser(description="Render and evaluate visual similarity between paired 3D models.")
    parser.add_argument("--gt-dir", type=Path, help="Directory containing ground-truth models.")
    parser.add_argument("--pred-dir", type=Path, help="Directory containing predicted models with matching stems.")
    parser.add_argument("--gt-file", type=Path, help="Ground-truth model for single-pair evaluation.")
    parser.add_argument("--pred-file", type=Path, help="Prediction model for single-pair evaluation.")
    parser.add_argument("--output-dir", type=Path, required=True, help="Directory for renders and visual_summary.csv.")
    parser.add_argument("--blender", default="blender", help="Blender executable.")
    parser.add_argument("--render-script", type=Path, default=default_render_script)
    parser.add_argument("--resolution", type=int, default=512)
    parser.add_argument("--num-views", type=int, default=6)
    parser.add_argument("--lpips-net", choices=("alex", "vgg", "squeeze"), default="alex")
    parser.add_argument("--device", choices=("auto", "cuda", "cpu"), default="auto")
    parser.add_argument("--overwrite-renders", action="store_true")
    parser.add_argument("--skip-clip", action="store_true")
    parser.add_argument("--skip-fid", action="store_true")
    parser.add_argument("--fid-batch-size", type=int, default=50)
    return parser


def main() -> None:
    args = build_parser().parse_args()
    configure_logging(args.output_dir)

    if args.gt_dir and args.pred_dir:
        pairs = collect_pairs(args.gt_dir, args.pred_dir)
    elif args.gt_file and args.pred_file:
        pairs = [(args.gt_file, args.pred_file)]
    else:
        raise SystemExit("Provide either --gt-dir/--pred-dir or --gt-file/--pred-file.")

    if not pairs:
        raise SystemExit("No valid evaluation pairs were found.")

    lpips_metric = LPIPSMetric(net=args.lpips_net, device=args.device)
    clip_metric = None if args.skip_clip else CLIPImageMetric(device=args.device)

    results = []
    for gt_path, pred_path in pairs:
        try:
            gt_render_dir = render_model(
                args.blender,
                args.render_script,
                gt_path,
                args.output_dir,
                "ground_truth",
                args.resolution,
                args.num_views,
                args.overwrite_renders,
            )
            pred_render_dir = render_model(
                args.blender,
                args.render_script,
                pred_path,
                args.output_dir,
                "prediction",
                args.resolution,
                args.num_views,
                args.overwrite_renders,
            )
            row = compare_render_dirs(gt_render_dir, pred_render_dir, lpips_metric, clip_metric, args.num_views)
            row["model"] = gt_path.name
            row["prediction"] = pred_path.name
            results.append(row)
            logging.info("%s: LPIPS=%.6f CLIP=%.6f", gt_path.name, row["rgb_lpips"], row["clip_score"])
        except Exception as exc:
            logging.error("Failed to evaluate %s against %s: %s", gt_path, pred_path, exc)

    if not results:
        raise SystemExit("All visual evaluation pairs failed.")

    if not args.skip_fid:
        fid_value = calculate_fid(
            args.output_dir / "ground_truth",
            args.output_dir / "prediction",
            batch_size=args.fid_batch_size,
            device=args.device,
        )
        for row in results:
            row["fid"] = fid_value

    csv_path = save_results(results, args.output_dir)
    logging.info("Results saved to %s", csv_path)


if __name__ == "__main__":
    main()