#!/usr/bin/env python3 from __future__ import annotations import argparse import json from pathlib import Path from typing import Any import cv2 import numpy as np from PIL import Image def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Evaluate rendered GT/model images") parser.add_argument("--manifest", required=True) parser.add_argument("--clip_model_path", required=True) parser.add_argument("--out_json", required=True) parser.add_argument("--models", default=None) parser.add_argument("--batch_size", type=int, default=32) return parser.parse_args() def read_image_rgb(path: Path) -> np.ndarray: bgr = cv2.imread(str(path), cv2.IMREAD_COLOR) if bgr is None: raise ValueError(f"Unable to decode image: {path}") return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB) def photometric_loss(gt_frame: np.ndarray, pred_frame: np.ndarray) -> float: if pred_frame.shape[:2] != gt_frame.shape[:2]: h, w = gt_frame.shape[:2] pred_frame = cv2.resize(pred_frame, (w, h), interpolation=cv2.INTER_AREA) gt = gt_frame[..., :3].astype(np.float32) / 255.0 pred = pred_frame[..., :3].astype(np.float32) / 255.0 return float(np.mean(np.square(gt - pred))) def score_lower_is_better(raw: float, bad_value: float = 1.0) -> float: if bad_value <= 0: return 0.0 return float(100.0 * max(0.0, min(1.0, 1.0 - raw / bad_value))) def encode_image_features( paths: list[Path], model: Any, processor: Any, device: str, batch_size: int, ) -> Any: import torch feats: list[torch.Tensor] = [] with torch.no_grad(): for start in range(0, len(paths), batch_size): chunk_paths = paths[start : start + batch_size] images = [Image.fromarray(read_image_rgb(p)) for p in chunk_paths] inputs = processor(images=images, return_tensors="pt") inputs = {k: v.to(device) for k, v in inputs.items()} image_features = model.get_image_features(**inputs) image_features = image_features / image_features.norm(dim=-1, keepdim=True) feats.append(image_features) return torch.cat(feats, dim=0) def main() -> None: args = parse_args() manifest_path = Path(args.manifest).resolve() manifest = json.loads(manifest_path.read_text(encoding="utf-8")) requested = [x.strip() for x in args.models.split(",") if x.strip()] if args.models else None models = requested or [x for x in manifest["renders"] if x != "gt"] from transformers import CLIPModel, CLIPProcessor import torch device = "cuda" if torch.cuda.is_available() else "cpu" clip_model = CLIPModel.from_pretrained(args.clip_model_path, local_files_only=True).to(device) clip_processor = CLIPProcessor.from_pretrained(args.clip_model_path, local_files_only=True) clip_model.eval() gt_by_frame = {int(item["gt_frame"]): Path(item["path"]) for item in manifest["renders"]["gt"]} results: dict[str, Any] = {} summary: list[dict[str, Any]] = [] for key in models: pairs: list[tuple[Path, Path, int, int]] = [] for item in manifest["renders"].get(key, []): gt_frame = int(item["gt_frame"]) pred_frame = int(item["pred_frame"]) gt_path = gt_by_frame.get(gt_frame) if gt_path is None: raise KeyError(f"Missing rendered GT image for gt_frame={gt_frame}") pairs.append((gt_path, Path(item["path"]), gt_frame, pred_frame)) losses = [photometric_loss(read_image_rgb(g), read_image_rgb(p)) for g, p, _, _ in pairs] gt_feats = encode_image_features([g for g, _, _, _ in pairs], clip_model, clip_processor, device, args.batch_size) pred_feats = encode_image_features([p for _, p, _, _ in pairs], clip_model, clip_processor, device, args.batch_size) sims = torch.nn.functional.cosine_similarity(pred_feats, gt_feats, dim=-1) sim_values = sims.detach().cpu().numpy().astype(float).tolist() nclip_values = [float(1.0 - x) for x in sim_values] pl_raw = float(np.mean(losses)) if losses else 0.0 nclip_raw = float(np.mean(nclip_values)) if nclip_values else 0.0 result = { "frame_count": len(pairs), "pairs": [ {"gt": str(g), "pred": str(p), "gt_frame": gt_frame, "pred_frame": pred_frame} for g, p, gt_frame, pred_frame in pairs ], "pl": { "metric": "PhotometricLoss_RenderedAlignedGTCamera", "pl_raw": pl_raw, "score_100": score_lower_is_better(pl_raw, bad_value=1.0), "frame_losses": losses, "direction": "lower_is_better", }, "n_clip": { "metric": "VIGA_N_CLIP_RenderedAlignedGTCamera", "n_clip_raw": nclip_raw, "clip_similarity_mean": float(np.mean(sim_values)) if sim_values else 0.0, "score_100": float(100.0 * max(0.0, min(1.0, 1.0 - nclip_raw))), "frame_clip_similarity": sim_values, "frame_n_clip": nclip_values, "formula": "mean_i(1 - CLIPSim(pred_render_i, gt_render_i))", "direction": "lower_is_better", }, } results[key] = result summary.append( { "model": key, "pl_raw": pl_raw, "pl_score_100": result["pl"]["score_100"], "n_clip_raw": nclip_raw, "n_clip_score_100": result["n_clip"]["score_100"], "clip_similarity_mean": result["n_clip"]["clip_similarity_mean"], "frame_count": len(pairs), } ) payload = { "manifest": str(manifest_path), "clip_model_path": args.clip_model_path, "clip_device": device, "definition": { "pl": "MSE between GT-camera renders after alignment", "n_clip": "VIGA-style mean(1 - CLIPSim(pred_render, gt_render)) after alignment", }, "results": results, "summary": summary, "rankings": { "pl_score_desc": sorted(summary, key=lambda x: x["pl_score_100"], reverse=True), "nclip_score_desc": sorted(summary, key=lambda x: x["n_clip_score_100"], reverse=True), }, } out_path = Path(args.out_json).resolve() out_path.parent.mkdir(parents=True, exist_ok=True) out_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") print(json.dumps(payload["summary"], indent=2)) print(f"SAVED {out_path}") if __name__ == "__main__": main()