#!/usr/bin/env python3 from __future__ import annotations import argparse import csv import hashlib import json import os import subprocess import sys import threading import queue from pathlib import Path REPO_ROOT = Path(__file__).resolve().parents[1] def collect_samples( data_root: Path, models: list[str], only: set[str] | None, default_mode: str, *, mode_by_sample: dict[str, str] | None = None, allow_missing_models: bool = False, ) -> list[tuple[str, str]]: gt_root = data_root / "gt" if not gt_root.is_dir(): raise FileNotFoundError(f"ground-truth directory missing: {gt_root}") out: list[tuple[str, str]] = [] missing_gt = sorted(only - {d.name for d in gt_root.iterdir() if d.is_dir()}) if only else [] if missing_gt: preview = ", ".join(missing_gt[:10]) raise FileNotFoundError(f"track manifest references missing GT samples: {preview}") missing_models: list[str] = [] for d in sorted(gt_root.iterdir()): if not d.is_dir(): continue sid = d.name if only is not None and sid not in only: continue if not _has_scene(d): raise FileNotFoundError(f"GT geometry missing for sample {sid}: {d}") missing = [model for model in models if not _has_scene(data_root / model / sid)] if missing and not allow_missing_models: missing_models.append(f"{sid}: {','.join(missing)}") continue mode = (mode_by_sample or {}).get(sid, default_mode) out.append((sid, mode)) if missing_models: preview = "; ".join(missing_models[:10]) suffix = "" if len(missing_models) <= 10 else f"; ... and {len(missing_models) - 10} more" raise FileNotFoundError(f"requested model geometry is incomplete: {preview}{suffix}") return out def load_track_manifest_sample_ids(manifest_path: Path) -> set[str]: if not manifest_path.is_file(): raise FileNotFoundError(f"track manifest missing: {manifest_path}") def rows_from_payload(payload): if isinstance(payload, list): return payload if isinstance(payload, dict): samples = payload.get("samples") if isinstance(samples, list): return samples return [payload] raise ValueError(f"Unsupported manifest payload: {manifest_path}") rows = [] if manifest_path.suffix.lower() == ".jsonl": for line_no, line in enumerate(manifest_path.read_text(encoding="utf-8").splitlines(), start=1): raw = line.strip() if not raw: continue obj = json.loads(raw) if not isinstance(obj, dict): raise ValueError(f"Expected JSON object at {manifest_path}:{line_no}") rows.append(obj) else: rows = rows_from_payload(json.loads(manifest_path.read_text(encoding="utf-8"))) sample_ids: set[str] = set() for idx, row in enumerate(rows, start=1): if not isinstance(row, dict): raise ValueError(f"Expected JSON object at {manifest_path}:{idx}") sid = row.get("sample_id") or row.get("id") if not sid: raise ValueError(f"Missing sample_id/id at {manifest_path}:{idx}") sample_ids.add(str(sid)) return sample_ids def load_track_manifest_modes(manifest_path: Path, default_mode: str) -> dict[str, str]: modes: dict[str, str] = {} lines = manifest_path.read_text(encoding="utf-8").splitlines() if manifest_path.suffix.lower() == ".jsonl": rows = [json.loads(line) for line in lines if line.strip()] else: payload = json.loads("\n".join(lines)) rows = payload.get("samples", [payload]) if isinstance(payload, dict) else payload for row in rows: sid = row.get("sample_id") or row.get("id") if not sid: continue mode = row.get("geometry_frame_mode") if not mode and row.get("frame") is not None: mode = f"exact:{int(row['frame'])}" modes[str(sid)] = str(mode or default_mode) return modes SCENE_EXTS = (".glb", ".blend", ".gltf") def _has_scene(model_dir: Path) -> bool: if not model_dir.is_dir(): return False for ext in SCENE_EXTS: if (model_dir / f"scene{ext}").exists(): return True return any(model_dir.glob(f"*{ext}") for ext in SCENE_EXTS if list(model_dir.glob(f"*{ext}"))) def _scene_path(model_dir: Path) -> Path | None: for ext in SCENE_EXTS: candidate = model_dir / f"scene{ext}" if candidate.is_file(): return candidate.resolve() for ext in SCENE_EXTS: matches = sorted(model_dir.glob(f"*{ext}")) if model_dir.is_dir() else [] if matches: return matches[0].resolve() return None def _run_config(sid: str, mode: str, models: list[str], args) -> dict: data_root = Path(args.data_root).resolve() scene_keys = ["gt", *models] scenes = {} for key in scene_keys: scene = _scene_path(data_root / key / sid) if scene is None: continue stat = scene.stat() scenes[key] = { "path": str(scene), "size": stat.st_size, "mtime_ns": stat.st_mtime_ns, } payload = { "schema_version": 1, "sample_id": sid, "models": models, "geometry_frame_mode": mode, "alignment": args.alignment, "ground_policy": args.ground_policy, "blender_bin": args.blender_bin, "clip_model_path": args.clip_model_path, "clip_batch_size": args.clip_batch_size, "resolution_x": args.resolution_x, "resolution_y": args.resolution_y, "render_samples": args.render_samples, "render_engine": args.render_engine, "scenes": scenes, } encoded = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8") payload["fingerprint"] = hashlib.sha256(encoded).hexdigest() return payload def run_one(sid: str, mode: str, gpu: str, args) -> tuple[str, bool, str]: out_dir = Path(args.out_root) / sid final = out_dir / "reports" / "final_report.json" config_path = out_dir / "run_config.json" data_root = Path(args.data_root).resolve() requested = [m.strip() for m in args.models.split(",") if m.strip()] present = [m for m in requested if _has_scene(data_root / m / sid)] missing = [m for m in requested if m not in present] if missing and not args.allow_partial: return sid, False, f"missing model geometry: {','.join(missing)}" if not present: return sid, False, "no model geometry" config = _run_config(sid, mode, present, args) if final.exists() and config_path.exists() and not args.force: try: previous = json.loads(config_path.read_text(encoding="utf-8")) if previous.get("fingerprint") == config["fingerprint"]: return sid, True, "cached (matching configuration)" except Exception: pass models_arg = ",".join(present) env = dict(os.environ) env["CUDA_VISIBLE_DEVICES"] = gpu tpw = str(args.threads_per_worker) for var in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS", "VECLIB_MAXIMUM_THREADS", "BLENDER_NUM_THREADS"): env[var] = tpw cmd = [ sys.executable, "scripts/run_blend_glb_eval_pipeline.py", "--sample_id", sid, "--models", models_arg, "--gt_key", "gt", "--data_root", str(data_root), "--blender_bin", args.blender_bin, "--clip_model_path", args.clip_model_path, "--clip_batch_size", str(args.clip_batch_size), "--alignment", args.alignment, "--ground_policy", args.ground_policy, "--geometry_frame_mode", mode, "--resolution_x", str(args.resolution_x), "--resolution_y", str(args.resolution_y), "--samples", str(args.render_samples), "--render_engine", args.render_engine, "--out_dir", str(out_dir), ] logf = out_dir / "pipeline.log" out_dir.mkdir(parents=True, exist_ok=True) with open(logf, "w") as fh: proc = subprocess.run(cmd, cwd=REPO_ROOT, env=env, stdout=fh, stderr=subprocess.STDOUT, text=True) if proc.returncode == 0 and final.exists(): config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8") return sid, True, "ok" return sid, False, f"rc={proc.returncode} (see {logf})" def worker(wq: queue.Queue, gpu: str, args, results: list, lock: threading.Lock): while True: try: sid, mode = wq.get_nowait() except queue.Empty: return sid_, ok, msg = run_one(sid, mode, gpu, args) if not ok and args.retries > 0: sid_, ok, msg = run_one(sid, mode, gpu, args) with lock: results.append((sid_, ok, msg)) n = len(results) print(f"[gpu{gpu}] ({n}) {sid_}: {'OK' if ok else 'FAIL'} {msg}", flush=True) wq.task_done() def aggregate( out_root: Path, samples: list[tuple[str, str]], models: list[str], *, allow_partial: bool = False, ) -> dict: rows = [] missing_reports: list[str] = [] for sid, _ in samples: fr = out_root / sid / "reports" / "final_report.json" if not fr.exists(): missing_reports.append(sid) continue d = json.loads(fr.read_text()) for s in d.get("summary", []): rows.append({ "sample_id": sid, "model": s.get("model"), "scene_aabb_iou": s.get("scene_aabb_iou_mean"), "scene_obb_iou": s.get("scene_obb_iou_mean"), "object_aabb_iou": s.get("object_aabb_iou_penalized_mean"), "object_obb_iou": s.get("object_obb_iou_penalized_mean"), "pl_score": s.get("rendered_pl_score_100"), "n_clip_score": s.get("rendered_n_clip_score_100"), "pl_raw": s.get("rendered_pl_raw"), "n_clip_raw": s.get("rendered_n_clip_raw"), }) found_pairs = {(row["sample_id"], row["model"]) for row in rows} expected_pairs = {(sid, model) for sid, _ in samples for model in models} missing_pairs = sorted(expected_pairs - found_pairs) if not allow_partial and (missing_reports or missing_pairs): details = [] if missing_reports: details.append(f"missing reports={len(missing_reports)}") if missing_pairs: details.append(f"missing sample/model rows={len(missing_pairs)}") raise RuntimeError("incomplete evaluation; " + ", ".join(details)) csv_path = out_root / "results_per_sample.csv" fields = ["sample_id", "model", "scene_aabb_iou", "scene_obb_iou", "object_aabb_iou", "object_obb_iou", "pl_score", "n_clip_score", "pl_raw", "n_clip_raw"] with open(csv_path, "w", newline="") as fh: w = csv.DictWriter(fh, fieldnames=fields) w.writeheader() w.writerows(rows) means = {} for m in models: mr = [r for r in rows if r["model"] == m] if not mr: continue def avg(k): vals = [r[k] for r in mr if isinstance(r[k], (int, float))] return sum(vals) / len(vals) if vals else None pl_raw = avg("pl_raw") n_clip_raw = avg("n_clip_raw") means[m] = { "n": len(mr), "expected_n": len(samples), "coverage": len(mr) / len(samples) if samples else 0.0, "scene_aabb_iou": avg("scene_aabb_iou"), "scene_obb_iou": avg("scene_obb_iou"), "object_aabb_iou": avg("object_aabb_iou"), "object_obb_iou": avg("object_obb_iou"), "pl": 100.0 * pl_raw if pl_raw is not None else None, "n_clip": 10.0 * n_clip_raw if n_clip_raw is not None else None, "pl_raw": pl_raw, "n_clip_raw": n_clip_raw, "pl_score": avg("pl_score"), "n_clip_score": avg("n_clip_score"), } payload = { "schema_version": 1, "complete": not missing_reports and not missing_pairs, "sample_count": len(samples), "models": models, "metric_definitions": { "pl": "100 * mean normalized RGB MSE; lower is better", "n_clip": "10 * mean(1 - CLIPSim); lower is better", "scene_aabb_iou": "scene union AABB IoU; higher is better", "scene_obb_iou": "scene union OBB IoU; higher is better", "object_aabb_iou": "Hungarian-matched object AABB IoU with count penalty; higher is better", "object_obb_iou": "Hungarian-matched object OBB IoU with count penalty; higher is better", }, "missing_reports": missing_reports, "missing_pairs": [{"sample_id": sid, "model": model} for sid, model in missing_pairs], "results": means, } (out_root / "results_summary.json").write_text(json.dumps(payload, indent=2) + "\n") print(f"\n=== aggregated {len(rows)} model-rows over {len({r['sample_id'] for r in rows})} samples ===") print("%-10s %4s | %-9s %-9s %-9s %-9s | %-8s %-8s" % ( "model", "n", "scn_aabb", "scn_obb", "obj_aabb", "obj_obb", "PL", "NCLIP")) print("-" * 80) for m, v in means.items(): print("%-10s %4d | %-9.3f %-9.3f %-9.3f %-9.3f | %-8.2f %-8.2f" % ( m, v["n"], v["scene_aabb_iou"] or 0, v["scene_obb_iou"] or 0, v["object_aabb_iou"] or 0, v["object_obb_iou"] or 0, v["pl"] or 0, v["n_clip"] or 0)) print(f"\nCSV: {csv_path}\nJSON: {out_root/'results_summary.json'}") return payload def main(): pre = argparse.ArgumentParser(add_help=False) pre.add_argument("--protocol", default=None, help="JSON file providing evaluator defaults") pre_args, _ = pre.parse_known_args() protocol_defaults = {} if pre_args.protocol: protocol_path = Path(pre_args.protocol).resolve() protocol_defaults = json.loads(protocol_path.read_text(encoding="utf-8")) if not isinstance(protocol_defaults, dict): raise ValueError(f"protocol must be a JSON object: {protocol_path}") ap = argparse.ArgumentParser(parents=[pre]) ap.add_argument( "--data_root", required=True, help="Dataset root containing gt/ and one directory per submitted model.", ) ap.add_argument("--models", required=True) ap.add_argument("--gpus", default="2,3,5,7") ap.add_argument("--workers_per_gpu", type=int, default=2) ap.add_argument("--threads_per_worker", type=int, default=10, help="cap CPU threads per worker (geometry stage is CPU-bound)") ap.add_argument("--blender_bin", default="blender") ap.add_argument("--clip_model_path", default="openai/clip-vit-base-patch32") ap.add_argument("--clip_batch_size", type=int, default=32) ap.add_argument("--alignment", default="bbox") ap.add_argument( "--ground_policy", choices=["exclude", "include"], default="exclude", help="Whether bbox alignment and geometry IoU exclude detected ground planes.", ) ap.add_argument("--out_root", required=True) ap.add_argument("--only_samples", default=None) ap.add_argument( "--track_manifest", default=None, help="Optional static/dynamic track manifest; sample ids are used as an evaluation filter.", ) ap.add_argument("--default_frame_mode", default="first_only") ap.add_argument("--resolution_x", type=int, default=768) ap.add_argument("--resolution_y", type=int, default=432) ap.add_argument("--render_samples", type=int, default=32) ap.add_argument( "--render_engine", choices=["BLENDER_EEVEE", "BLENDER_EEVEE_NEXT", "CYCLES"], default="BLENDER_EEVEE", ) ap.add_argument("--limit", type=int, default=0, help="cap number of samples (debug)") ap.add_argument("--retries", type=int, default=1) ap.add_argument("--force", action="store_true", help="re-run even if final_report exists") ap.add_argument("--aggregate_only", action="store_true") ap.add_argument( "--allow_partial", action="store_true", help="Allow missing models or failed samples. Off by default for comparable benchmark results.", ) known_destinations = {action.dest for action in ap._actions} unknown_defaults = sorted(set(protocol_defaults) - known_destinations) if unknown_defaults: raise ValueError(f"unknown protocol keys: {', '.join(unknown_defaults)}") ap.set_defaults(**protocol_defaults) args = ap.parse_args() data_root = Path(args.data_root).resolve() models = [m.strip() for m in args.models.split(",") if m.strip()] only = set(s.strip() for s in args.only_samples.split(",") if s.strip()) if args.only_samples else None if args.track_manifest: manifest_path = Path(args.track_manifest).resolve() manifest_ids = load_track_manifest_sample_ids(manifest_path) mode_by_sample = load_track_manifest_modes(manifest_path, args.default_frame_mode) only = manifest_ids if only is None else only & manifest_ids print(f"track_manifest={args.track_manifest} sample_ids={len(manifest_ids)} active_filter={len(only)}") else: mode_by_sample = {} out_root = Path(args.out_root) out_root.mkdir(parents=True, exist_ok=True) samples = collect_samples( data_root, models, only, args.default_frame_mode, mode_by_sample=mode_by_sample, allow_missing_models=args.allow_partial, ) if args.limit: samples = samples[:args.limit] if not samples: raise SystemExit("no evaluation samples found") print(f"collected {len(samples)} samples; gpus={args.gpus} x {args.workers_per_gpu} workers") if not args.aggregate_only: wq: queue.Queue = queue.Queue() for item in samples: wq.put(item) gpus = [g.strip() for g in args.gpus.split(",") if g.strip()] results: list = [] lock = threading.Lock() threads = [] for gpu in gpus: for _ in range(args.workers_per_gpu): t = threading.Thread(target=worker, args=(wq, gpu, args, results, lock)) t.start() threads.append(t) for t in threads: t.join() ok = sum(1 for _, o, _ in results if o) print(f"\n=== eval done: {ok}/{len(results)} ok ===") if ok != len(results) and not args.allow_partial: failed = [f"{sid}: {msg}" for sid, success, msg in results if not success] raise SystemExit("evaluation failed:\n " + "\n ".join(failed)) aggregate(out_root, samples, models, allow_partial=args.allow_partial) if __name__ == "__main__": main()