| 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() |
|
|
