| |
|
|
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import subprocess |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| p = argparse.ArgumentParser(description="Run alignment, GT-camera rendering, and rendered visual metrics.") |
| p.add_argument("--sample_id", required=True) |
| p.add_argument("--data_root", default="data") |
| p.add_argument("--gt_key", default="gt") |
| p.add_argument("--models", required=True, help="Comma-separated model keys under data_root.") |
| p.add_argument("--blender_bin", required=True) |
| p.add_argument("--clip_model_path", required=True) |
| p.add_argument("--out_dir", required=True) |
| p.add_argument( |
| "--alignment", |
| choices=["identity", "bbox", "object_bbox", "depth_bbox", "depth_camera"], |
| default="bbox", |
| ) |
| p.add_argument( |
| "--ground_policy", |
| choices=["exclude", "include"], |
| default="exclude", |
| help="Whether bbox alignment and geometry IoU exclude detected ground planes.", |
| ) |
| p.add_argument( |
| "--geometry_frame_mode", |
| default="first_only", |
| help="Geometry frames used for IoU-B extraction: first_only, first_mid_last, last_only, or exact:<frame>.", |
| ) |
| p.add_argument("--camera_convention", choices=["auto", "world_to_camera", "camera_to_world"], default="auto") |
| p.add_argument("--camera_rotation_only", action="store_true") |
| p.add_argument("--image_glob", default="frames/*,selected_frames/*,eval_frames/*,scene.png") |
| p.add_argument("--scene_filename", default=None) |
| p.add_argument("--clip_batch_size", type=int, default=32) |
| p.add_argument("--resolution_x", type=int, default=768) |
| p.add_argument("--resolution_y", type=int, default=432) |
| p.add_argument("--samples", type=int, default=32) |
| p.add_argument("--render_engine", choices=["BLENDER_EEVEE", "BLENDER_EEVEE_NEXT", "CYCLES"], default="BLENDER_EEVEE") |
| p.add_argument("--transparent", action=argparse.BooleanOptionalAction, default=False) |
| p.add_argument("--skip_rendered_visual_metrics", action="store_true") |
| p.add_argument("--keep_selected_image_metrics", action="store_true") |
| p.add_argument( |
| "--strict_selected_images", |
| action="store_true", |
| help="Fail if selected images are missing when --keep_selected_image_metrics is used.", |
| ) |
| return p.parse_args() |
|
|
|
|
| def project_root() -> Path: |
| return Path(__file__).resolve().parents[1] |
|
|
|
|
| def run(cmd: list[str]) -> None: |
| print("\n>>> " + " ".join(cmd), flush=True) |
| proc = subprocess.run(cmd, text=True) |
| if proc.returncode != 0: |
| raise SystemExit(proc.returncode) |
|
|
|
|
| def load_json(path: Path) -> dict[str, Any]: |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def write_json(path: Path, payload: dict[str, Any]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
|
|
| def merge_final_report( |
| *, |
| geometry_report: Path, |
| render_manifest: Path | None, |
| rendered_visual_report: Path | None, |
| final_report: Path, |
| ) -> None: |
| geometry = load_json(geometry_report) |
| rendered_visual = load_json(rendered_visual_report) if rendered_visual_report and rendered_visual_report.exists() else None |
|
|
| visual_by_model: dict[str, Any] = {} |
| if rendered_visual: |
| visual_by_model = {row["model"]: row for row in rendered_visual.get("summary", [])} |
|
|
| summary: list[dict[str, Any]] = [] |
| for row in geometry.get("summary", []): |
| key = row["model"] |
| visual = visual_by_model.get(key, {}) |
| pl_raw = visual.get("pl_raw") |
| n_clip_raw = visual.get("n_clip_raw") |
| summary.append( |
| { |
| "model": key, |
| "scene_aabb_iou_mean": row.get("scene_aabb_iou_mean", 0.0), |
| "scene_obb_iou_mean": row.get("scene_obb_iou_mean", 0.0), |
| "object_aabb_iou_penalized_mean": row.get("object_aabb_iou_penalized_mean", 0.0), |
| "object_obb_iou_penalized_mean": row.get("object_obb_iou_penalized_mean", 0.0), |
| "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, |
| "rendered_pl_raw": pl_raw, |
| "rendered_pl_score_100": visual.get("pl_score_100"), |
| "rendered_n_clip_raw": n_clip_raw, |
| "rendered_n_clip_score_100": visual.get("n_clip_score_100"), |
| "rendered_clip_similarity_mean": visual.get("clip_similarity_mean"), |
| "rendered_frame_count": visual.get("frame_count"), |
| "alignment_mode": row.get("alignment_mode"), |
| "alignment_scale": row.get("alignment_scale"), |
| } |
| ) |
|
|
| payload = { |
| "sample_id": geometry.get("sample_id"), |
| "definition": { |
| "geometry": "IoU-B on aligned .blend/.glb/.gltf geometry.", |
| "object_iou": "Hungarian object matching on AABB IoU; unmatched/missing objects are penalized by max(gt_count,pred_count).", |
| "rendered_visual": "GT-camera renders after alignment, then PL and VIGA-style image-image N-CLIP.", |
| "pl": "100 * mean normalized RGB MSE; lower is better.", |
| "n_clip": "10 * mean(1 - CLIPSim); lower is better.", |
| }, |
| "paths": { |
| "geometry_report": str(geometry_report), |
| "render_manifest": str(render_manifest) if render_manifest else None, |
| "rendered_visual_report": str(rendered_visual_report) if rendered_visual_report else None, |
| }, |
| "geometry_report": geometry, |
| "rendered_visual_report": rendered_visual, |
| "summary": summary, |
| "rankings": { |
| "scene_aabb_desc": sorted(summary, key=lambda x: x["scene_aabb_iou_mean"], reverse=True), |
| "scene_obb_desc": sorted(summary, key=lambda x: x["scene_obb_iou_mean"], reverse=True), |
| "object_aabb_pen_desc": sorted(summary, key=lambda x: x["object_aabb_iou_penalized_mean"], reverse=True), |
| "pl_asc": sorted(summary, key=lambda x: x.get("pl") if x.get("pl") is not None else float("inf")), |
| "n_clip_asc": sorted(summary, key=lambda x: x.get("n_clip") if x.get("n_clip") is not None else float("inf")), |
| "rendered_pl_score_desc": sorted(summary, key=lambda x: x.get("rendered_pl_score_100") or 0.0, reverse=True), |
| "rendered_nclip_score_desc": sorted(summary, key=lambda x: x.get("rendered_n_clip_score_100") or 0.0, reverse=True), |
| }, |
| } |
| write_json(final_report, payload) |
| print(json.dumps(summary, indent=2, ensure_ascii=False)) |
| print(f"SAVED {final_report}") |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| root = project_root() |
| out_dir = Path(args.out_dir).resolve() |
| reports_dir = out_dir / "reports" |
| renders_dir = out_dir / "renders" |
| alignments_dir = out_dir / "alignments" |
| reports_dir.mkdir(parents=True, exist_ok=True) |
|
|
| geometry_report = reports_dir / "geometry_alignment_report.json" |
| render_manifest = renders_dir / "render_manifest.json" |
| rendered_visual_report = reports_dir / "rendered_visual_metrics.json" |
| final_report = reports_dir / "final_report.json" |
|
|
| geometry_cmd = [ |
| sys.executable, |
| str(root / "scripts" / "run_big_eval.py"), |
| "--sample_id", |
| args.sample_id, |
| "--data_root", |
| args.data_root, |
| "--gt_key", |
| args.gt_key, |
| "--models", |
| args.models, |
| "--blender_bin", |
| args.blender_bin, |
| "--clip_model_path", |
| args.clip_model_path, |
| "--clip_batch_size", |
| str(args.clip_batch_size), |
| "--out_json", |
| str(geometry_report), |
| "--alignment_dir", |
| str(alignments_dir), |
| "--scene_meta_dir", |
| str(out_dir / "scene_meta"), |
| "--alignment", |
| args.alignment, |
| "--ground_policy", |
| args.ground_policy, |
| "--geometry_frame_mode", |
| args.geometry_frame_mode, |
| "--camera_convention", |
| args.camera_convention, |
| "--image_glob", |
| args.image_glob, |
| ] |
| if not args.strict_selected_images: |
| geometry_cmd.append("--allow_missing_images") |
| if args.camera_rotation_only: |
| geometry_cmd.append("--camera_rotation_only") |
| if args.scene_filename: |
| geometry_cmd.extend(["--scene_filename", args.scene_filename]) |
| if not args.keep_selected_image_metrics: |
| geometry_cmd.append("--skip_selected_image_metrics") |
| run(geometry_cmd) |
|
|
| render_cmd = [ |
| args.blender_bin, |
| "--factory-startup", |
| "--background", |
| "--python", |
| str(root / "scripts" / "render_aligned_eval_images.py"), |
| "--", |
| "--report_json", |
| str(geometry_report), |
| "--out_dir", |
| str(renders_dir), |
| "--models", |
| args.models, |
| "--resolution_x", |
| str(args.resolution_x), |
| "--resolution_y", |
| str(args.resolution_y), |
| "--samples", |
| str(args.samples), |
| "--engine", |
| args.render_engine, |
| ] |
| if args.transparent: |
| render_cmd.append("--transparent") |
| run(render_cmd) |
|
|
| if not args.skip_rendered_visual_metrics: |
| visual_cmd = [ |
| sys.executable, |
| str(root / "scripts" / "eval_rendered_visual_metrics.py"), |
| "--manifest", |
| str(render_manifest), |
| "--clip_model_path", |
| args.clip_model_path, |
| "--out_json", |
| str(rendered_visual_report), |
| "--models", |
| args.models, |
| "--batch_size", |
| str(args.clip_batch_size), |
| ] |
| run(visual_cmd) |
| else: |
| rendered_visual_report = None |
|
|
| merge_final_report( |
| geometry_report=geometry_report, |
| render_manifest=render_manifest, |
| rendered_visual_report=rendered_visual_report, |
| final_report=final_report, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
