Upload metrics.py

metrics.py

@@ -0,0 +1,139 @@
+import os
+import json
+import torch
+import numpy as np
+import torchvision
+from tqdm import tqdm
+
+from gaussian_renderer import render, GaussianModel
+from scene.cameras import Camera
+
+import lpips
+import piq
+from pytorch_fid import fid_score
+from skimage.metrics import structural_similarity as ssim_fn
+
+# --------------------------------------------------
+# Camera loading (same cameras for both ply)
+# --------------------------------------------------
+def load_cameras(camera_json):
+    with open(camera_json, 'r') as f:
+        cam_data = json.load(f)
+
+    cameras = []
+    for cam in cam_data:
+        camera = Camera(
+            colmap_id=cam["id"],
+            R=np.array(cam["R"]),
+            T=np.array(cam["T"]),
+            FoVx=cam["FoVx"],
+            FoVy=cam["FoVy"],
+            image=torch.zeros(3, cam["height"], cam["width"]),
+            image_name=cam["image_name"],
+            uid=cam["id"]
+        )
+        cameras.append(camera.cuda())
+
+    return cameras
+
+
+# --------------------------------------------------
+# Render a ply under fixed cameras
+# --------------------------------------------------
+@torch.no_grad()
+def render_ply(ply_path, cameras, out_dir, sh_degree=3):
+    os.makedirs(out_dir, exist_ok=True)
+
+    gaussians = GaussianModel(sh_degree)
+    gaussians.load_ply(ply_path)
+    gaussians = gaussians.cuda()
+
+    bg = torch.zeros(3, device="cuda")
+
+    rendered = {}
+
+    for cam in tqdm(cameras, desc=f"Rendering {os.path.basename(ply_path)}"):
+        img = render(
+            cam,
+            gaussians,
+            pipeline=None,
+            background=bg
+        )["render"].clamp(0, 1)
+
+        torchvision.utils.save_image(
+            img, os.path.join(out_dir, cam.image_name + ".png")
+        )
+        rendered[cam.image_name] = img
+
+    return rendered
+
+
+# --------------------------------------------------
+# Metrics: A = GT, B = Pred
+# --------------------------------------------------
+def compute_metrics(gt_imgs, pred_imgs):
+    psnr, ssim, lpips_v, niqe = [], [], [], []
+
+    lpips_fn = lpips.LPIPS(net='alex').cuda()
+
+    for name in gt_imgs.keys():
+        gt = gt_imgs[name]
+        pred = pred_imgs[name]
+
+        psnr.append(piq.psnr(pred, gt).item())
+
+        ssim.append(
+            ssim_fn(
+                gt.permute(1,2,0).cpu().numpy(),
+                pred.permute(1,2,0).cpu().numpy(),
+                channel_axis=2,
+                data_range=1.0
+            )
+        )
+
+        lpips_v.append(
+            lpips_fn(pred.unsqueeze(0), gt.unsqueeze(0)).item()
+        )
+
+        niqe.append(
+            piq.niqe(pred.unsqueeze(0)).item()
+        )
+
+    return {
+        "PSNR": np.mean(psnr),
+        "SSIM": np.mean(ssim),
+        "LPIPS": np.mean(lpips_v),
+        "NIQE": np.mean(niqe)
+    }
+
+
+def compute_fid(dir_a, dir_b):
+    return fid_score.calculate_fid_given_paths(
+        [dir_a, dir_b],
+        batch_size=8,
+        device="cuda",
+        dims=2048
+    )
+
+
+# --------------------------------------------------
+# Main
+# --------------------------------------------------
+if __name__ == "__main__":
+
+    ply_gt = "A.ply"     # reference
+    ply_pred = "B.ply"   # compared model
+    camera_json = "cameras.json"
+
+    cameras = load_cameras(camera_json)
+
+    gt_imgs = render_ply(ply_gt, cameras, "render_A")
+    pred_imgs = render_ply(ply_pred, cameras, "render_B")
+
+    metrics = compute_metrics(gt_imgs, pred_imgs)
+    fid = compute_fid("render_A", "render_B")
+
+    print("\n===== A (GT) vs B (Pred) =====")
+    for k, v in metrics.items():
+        print(f"{k}: {v:.4f}")
+    print(f"FID: {fid:.4f}")