Upload metrics.py

metrics.py

@@ -0,0 +1,160 @@
+import os
+import json
+import torch
+import numpy as np
+import torchvision
+from tqdm import tqdm
+from PIL import Image
+
+from gaussian_renderer import render
+from gaussian_renderer import GaussianModel
+from scene.cameras import Camera
+from utils.graphics_utils import getWorld2View2, getProjectionMatrix
+
+import lpips
+import piq
+from pytorch_fid import fid_score
+from skimage.metrics import structural_similarity as ssim_fn
+
+# ----------------------------
+# Utils
+# ----------------------------
+def load_cameras(camera_json):
+    with open(camera_json, 'r') as f:
+        cams = json.load(f)
+
+    cameras = []
+    for cam in cams:
+        W2C = np.array(cam["world_view_transform"])
+        P = np.array(cam["projection_matrix"])
+
+        camera = Camera(
+            colmap_id=cam["id"],
+            R=W2C[:3, :3].T,
+            T=W2C[:3, 3],
+            FoVx=cam["FoVx"],
+            FoVy=cam["FoVy"],
+            image=torch.zeros(3, cam["height"], cam["width"]),
+            image_name=cam["image_name"],
+            uid=cam["id"]
+        )
+
+        camera.world_view_transform = torch.tensor(W2C).cuda()
+        camera.projection_matrix = torch.tensor(P).cuda()
+        camera.full_proj_transform = camera.world_view_transform @ camera.projection_matrix
+        camera.camera_center = camera.world_view_transform.inverse()[3, :3]
+
+        cameras.append(camera)
+
+    return cameras
+
+
+def load_gt(gt_dir, name):
+    img = Image.open(os.path.join(gt_dir, name + ".png")).convert("RGB")
+    img = torchvision.transforms.ToTensor()(img)
+    return img.cuda()
+
+
+# ----------------------------
+# Render function
+# ----------------------------
+@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.tensor([0, 0, 0], device="cuda", dtype=torch.float32)
+
+    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
+# ----------------------------
+def compute_metrics(preds, gt_dir):
+    psnr, ssim, lp, niqe = [], [], [], []
+
+    lpips_fn = lpips.LPIPS(net='alex').cuda()
+
+    for name, pred in preds.items():
+        gt = load_gt(gt_dir, 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
+            )
+        )
+        lp.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(lp),
+        "NIQE": np.mean(niqe)
+    }
+
+
+def compute_fid(pred_dir, gt_dir):
+    return fid_score.calculate_fid_given_paths(
+        [pred_dir, gt_dir],
+        batch_size=8,
+        device="cuda",
+        dims=2048
+    )
+
+
+# ----------------------------
+# Main
+# ----------------------------
+if __name__ == "__main__":
+
+    ply_a = "ply_a.ply"
+    ply_b = "ply_b.ply"
+    camera_json = "cameras.json"
+    gt_dir = "gt"
+
+    cameras = load_cameras(camera_json)
+
+    preds_a = render_ply(ply_a, cameras, "renders_a")
+    preds_b = render_ply(ply_b, cameras, "renders_b")
+
+    metrics_a = compute_metrics(preds_a, gt_dir)
+    metrics_b = compute_metrics(preds_b, gt_dir)
+
+    fid_a = compute_fid("renders_a", gt_dir)
+    fid_b = compute_fid("renders_b", gt_dir)
+
+    print("\n====== Model A ======")
+    for k, v in metrics_a.items():
+        print(f"{k}: {v:.4f}")
+    print(f"FID: {fid_a:.4f}")
+
+    print("\n====== Model B ======")
+    for k, v in metrics_b.items():
+        print(f"{k}: {v:.4f}")
+    print(f"FID: {fid_b:.4f}")