import csv import json import math import os import imageio import lpips import matplotlib.pyplot as plt import numpy as np import pandas as pd import scipy.io as sio import torch import tqdm from nerfacc import OccGridEstimator from skimage.metrics import structural_similarity from misc.dataset_utils import read_h5 from misc.eval_utils import load_eval_args, read_json from misc.transient_volrend import torch_laser_kernel from radiance_fields.ngp import NGPRadianceField from utils import render_transient def _to_numpy(x): if isinstance(x, np.ndarray): return x if isinstance(x, torch.Tensor): return x.detach().cpu().numpy() return np.asarray(x) def get_gt_depth(frame, camtoworld, data_root_fp): depth_folder = os.path.join(data_root_fp, "test") number = int(frame["file_path"].split("_")[-1]) ax_flip = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]]) try: fname = os.path.join(depth_folder, f"test_{number:03d}_depth_gt.npy") pos3d = np.load(fname) except Exception: fname = os.path.join(depth_folder, f"test_{number:03d}_depth_gt.h5") pos3d = read_h5(fname) cam_pos = (ax_flip @ camtoworld)[:3, -1] depth = np.sqrt(((pos3d - cam_pos[None, None, :]) ** 2).sum(-1)) return depth.astype(np.float32) def _safe_psnr(gt, pred, mask=None): gt = np.asarray(gt, dtype=np.float64) pred = np.asarray(pred, dtype=np.float64) if mask is not None: mask = np.asarray(mask, dtype=bool) if gt.ndim == 3: if not np.any(mask): return float("nan") gt_eval = gt[mask] pred_eval = pred[mask] else: if not np.any(mask): return float("nan") gt_eval = gt[mask] pred_eval = pred[mask] else: gt_eval = gt.reshape(-1) pred_eval = pred.reshape(-1) if gt_eval.size == 0: return float("nan") mse = np.mean((gt_eval - pred_eval) ** 2) max_val = max(float(np.max(gt_eval)), float(np.max(pred_eval)), 1e-8) return float(20.0 * np.log10(max_val / np.sqrt(mse + 1e-12))) def _save_metrics_csv(path, rows): if not rows: return fieldnames = list(rows[0].keys()) with open(path, "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=fieldnames) writer.writeheader() writer.writerows(rows) def _to_lpips_input(img_01): img_rgb = np.repeat(img_01[..., None], 3, axis=2).astype(np.float32) ten = torch.from_numpy(img_rgb).permute(2, 0, 1).unsqueeze(0) ten = ten * 2.0 - 1.0 return ten def _frame_token(frame_dict): raw = str(frame_dict.get("file_path", frame_dict.get("filepath", ""))) return os.path.splitext(os.path.basename(raw))[0] def _normalize_for_vis(img: np.ndarray, mask: np.ndarray = None, q_low: float = 1.0, q_high: float = 99.5): arr = np.asarray(img, dtype=np.float32) if mask is not None: m = np.asarray(mask, dtype=bool) vals = arr[m] else: vals = arr.reshape(-1) vals = vals[np.isfinite(vals)] if vals.size == 0: return np.zeros_like(arr, dtype=np.float32) lo = float(np.percentile(vals, q_low)) hi = float(np.percentile(vals, q_high)) if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo: hi = lo + 1e-6 out = (arr - lo) / (hi - lo) return np.clip(out, 0.0, 1.0) def _extract_intensity_from_hist(hist: np.ndarray) -> np.ndarray: hist = np.asarray(hist, dtype=np.float32) if hist.ndim != 4: raise ValueError(f"Expected histogram with shape [H, W, n_bins, C], got {hist.shape}") # Use peak intensity over time bins instead of temporal sum. peak_rgb = hist.max(axis=-2) return peak_rgb[..., 0].astype(np.float32) def _to_gamma_domain(img_01: np.ndarray, gamma: float = 2.2) -> np.ndarray: img_01 = np.asarray(img_01, dtype=np.float32) return np.clip(img_01, 0.0, 1.0) ** (1.0 / gamma) def _load_irf_series(path: str, column: str) -> np.ndarray: ext = os.path.splitext(path)[1].lower() if ext == ".csv": df = pd.read_csv(path, sep=",") if column in df.columns: arr = df[column].to_numpy(dtype=np.float64) else: numeric_cols = [c for c in df.columns if np.issubdtype(df[c].dtype, np.number)] if not numeric_cols: raise ValueError(f"No numeric columns found in IRF CSV: {path}") arr = df[numeric_cols[0]].to_numpy(dtype=np.float64) return arr.squeeze() if ext == ".npy": return np.load(path).astype(np.float64).squeeze() if ext == ".mat": mat = sio.loadmat(path) if "out" in mat: return _to_numpy(mat["out"]).astype(np.float64).squeeze() for value in mat.values(): if isinstance(value, np.ndarray) and value.ndim >= 1 and value.size > 1: return _to_numpy(value).astype(np.float64).squeeze() raise ValueError(f"Cannot find valid IRF series in mat file: {path}") if ext == ".pt": return _to_numpy(torch.load(path, map_location="cpu")).astype(np.float64).squeeze() raise ValueError(f"Unsupported IRF extension: {ext}") def build_irf_kernel(args, device): irf_path = getattr(args, "irf_path", "") or args.pulse_path if not irf_path: raise ValueError("IRF path is empty. Set --irf_path or --pulse_path.") irf_column = getattr(args, "irf_column", "irf") irf_half_window = int(getattr(args, "irf_half_window", 50)) no_irf_reverse = bool(getattr(args, "no_irf_reverse", False)) irf = _load_irf_series(irf_path, irf_column) if irf.ndim != 1: irf = irf.reshape(-1) if irf.size == 0: raise ValueError(f"Loaded empty IRF from: {irf_path}") peak_idx = int(np.argmax(irf)) if irf_half_window > 0: lo = max(0, peak_idx - irf_half_window) hi = min(len(irf), peak_idx + irf_half_window + 1) irf = irf[lo:hi] irf = irf / (irf.sum() + 1e-8) if not no_irf_reverse: irf = irf[::-1].copy() laser = torch.tensor(irf, dtype=torch.float32, device=device) return torch_laser_kernel(laser, device=device) @torch.no_grad() def eval(): args = load_eval_args() print("version =", args.version) device = args.device scale_int = float(args.scale_int) if scale_int <= 0: raise ValueError(f"scale_int must be > 0, got {scale_int}") print(f"Using fixed intensity scale from config: {scale_int}") ckpt_dir = args.checkpoint_dir outpath = os.path.join(args.checkpoint_dir, "results_revise") os.makedirs(outpath, exist_ok=True) transforms_path = os.path.join(args.test_folder_path, f"transforms_{args.split}.json") positions = read_json(transforms_path) frames = positions.get("frames", []) print(f"Using transforms: {transforms_path} (split={args.split}, frames={len(frames)})") if args.split == "test": train_tf_path = os.path.join(args.test_folder_path, "transforms_train.json") if os.path.isfile(train_tf_path): train_positions = read_json(train_tf_path) train_frames = train_positions.get("frames", []) test_ids = {_frame_token(f) for f in frames} train_ids = {_frame_token(f) for f in train_frames} overlap = sorted(test_ids.intersection(train_ids)) if overlap: print( f"[WARN] test/train overlap detected: {len(overlap)} shared frame ids. " f"Examples: {overlap[:10]}" ) else: print("Train/test overlap check: no shared frame ids.") else: print(f"Train overlap check skipped: not found {train_tf_path}") used_views = [] for idx, f in enumerate(frames): raw = str(f.get("file_path", f.get("filepath", ""))) used_views.append( { "index": idx, "frame_file_path": raw, "frame_name": os.path.basename(raw), "frame_stem": _frame_token(f), } ) used_views_json_path = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_used_views.json") used_views_csv_path = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_used_views.csv") used_views_txt_path = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_used_views.txt") with open(used_views_json_path, "w", encoding="utf-8") as f: json.dump( { "split": args.split, "transforms_path": transforms_path, "num_frames": len(used_views), "views": used_views, }, f, indent=2, ) _save_metrics_csv(used_views_csv_path, used_views) with open(used_views_txt_path, "w", encoding="utf-8") as f: for v in used_views: f.write(f"{v['index']}\t{v['frame_file_path']}\n") print(f"Saved used-view list: {used_views_json_path}") ckpt_path_rf = os.path.join(ckpt_dir, f"radiance_field_{args.step:04d}.pth") ckpt_path_oc = os.path.join(ckpt_dir, f"occupancy_grid_{args.step:04d}.pth") aabb = torch.tensor(args.aabb, dtype=torch.float32, device=device) img_h = int(getattr(args, "img_height_test", None) or args.img_shape_test) img_w = int(getattr(args, "img_width_test", None) or args.img_shape_test) img_shape = (img_h, img_w) if args.version == "simulated": from loaders.loader_synthetic import SubjectLoaderTransient as SubjectLoader test_dataset_kwargs = { "img_shape": img_shape, "have_images": True, "n_bins": args.n_bins, "color_bkgd_aug": "black", "rfilter_sigma": args.rfilter_sigma, } else: from loaders.loader_captured_ours import LearnRays, SubjectLoaderTransientRealOurs as SubjectLoader params = np.load(args.intrinsics, allow_pickle=True)[()] shift = _to_numpy(params["shift"]) rays = _to_numpy(params["rays"]) source_img_shape = (int(rays.shape[0]), int(rays.shape[1])) args.laser_kernel = build_irf_kernel(args, device=device) measurement_root = getattr(args, "measurement_root", "").strip() or None invalid_mask_path = getattr(args, "invalid_mask_path", "").strip() or None data_exts = tuple( e.strip() for e in getattr(args, "data_exts", ".npz,.txt,.pt,.h5,.hdf5").split(",") if e.strip() ) if getattr(args, "bin_width_s_loader", None) is not None: bin_width_s_loader = float(args.bin_width_s_loader) else: bin_width_s_loader = float(args.exposure_time) / 299792458.0 test_dataset_kwargs = { "img_shape": img_shape, "have_images": True, "n_bins": args.n_bins, "color_bkgd_aug": "black", "rfilter_sigma": args.rfilter_sigma, "shift": shift, "measurement_root": measurement_root, "data_exts": data_exts, "bin_width_s": bin_width_s_loader, "source_img_shape": source_img_shape, "invalid_mask_path": invalid_mask_path, "invalid_mask_invalid_gt": float(getattr(args, "invalid_mask_invalid_gt", 10.0)), } render_step_size = (((aabb[3:] - aabb[:3]).max() * math.sqrt(3)) / args.render_n_samples).item() occupancy_grid = OccGridEstimator( roi_aabb=aabb, resolution=args.grid_resolution, levels=args.grid_nlvl, ).to(device) radiance_field = NGPRadianceField( use_viewdirs=True, aabb=aabb, unbounded=False, radiance_activation=torch.exp, args=args, ).to(device) ckpt = torch.load(ckpt_path_rf, map_location=device) radiance_field.load_state_dict(ckpt) ckpt = torch.load(ckpt_path_oc, map_location=device) occupancy_grid.load_state_dict(ckpt) radiance_field.eval() occupancy_grid.eval() test_dataset = SubjectLoader( subject_id=f"{args.scene}", root_fp=args.test_folder_path, split=args.split, num_rays=None, **test_dataset_kwargs, testing=True, sample_as_per_distribution=args.sample_as_per_distribution, ) if args.version == "captured": test_dataset.K = LearnRays(rays, device=device, img_shape=img_shape).to(device) test_dataset.rep = 1 test_dataset.camtoworlds = test_dataset.camtoworlds.to(device) test_dataset.K = test_dataset.K.to(device) if args.version == "captured": eval_dataset_scale = float(_to_numpy(test_dataset.max).reshape(-1)[0]) if eval_dataset_scale <= 0: eval_dataset_scale = 1.0 else: eval_dataset_scale = 1.0 lpips_model = lpips.LPIPS(net="vgg").eval().cpu() per_image_metrics = [] for i in range(len(test_dataset)): frame_info = positions["frames"][i] frame_key = frame_info.get("file_path", frame_info.get("filepath", str(i))) frame_file_path = str(frame_key) frame_name = os.path.basename(frame_file_path) try: ind = int(str(frame_key).split("_")[-1]) except Exception: ind = i print(f"test image {ind} | file={frame_file_path}") pred_hist = np.zeros((img_h, img_w, args.n_bins, 3), dtype=np.float32) pred_depth = np.zeros((img_h, img_w), dtype=np.float32) pred_depth_viz = np.zeros((img_h, img_w), dtype=np.float32) weights_sum = np.zeros((img_h, img_w), dtype=np.float32) gt_hist = None valid_mask = None for _ in tqdm.tqdm(range(args.rep_number)): data = test_dataset[i] pixels = data["pixels"].detach().cpu().numpy().reshape(img_h, img_w, args.n_bins, 3) if gt_hist is None: gt_hist = pixels.astype(np.float32) if "valid_mask" in data: valid_mask = data["valid_mask"].detach().cpu().numpy().reshape(img_h, img_w).astype(bool) rays = data["rays"] sample_weights = data["weights"].detach().cpu().numpy().reshape(img_h, img_w) out = render_transient( radiance_field, occupancy_grid, rays, near_plane=args.near_plane, far_plane=args.far_plane, render_step_size=render_step_size, cone_angle=args.cone_angle, alpha_thre=args.alpha_thre, use_normals=False, args=args, ) pred_depth += ( out["depths"] * data["weights"][:, None] ).reshape(img_h, img_w).detach().cpu().numpy() pred_depth_viz += ( out["depths"] * data["weights"][:, None] * (out["opacities"] > 0) ).reshape(img_h, img_w).detach().cpu().numpy() pred_hist += ( out["colors"] * data["weights"][:, None] ).reshape(img_h, img_w, args.n_bins, 3).detach().cpu().numpy() weights_sum += sample_weights del out weights_sum = np.clip(weights_sum, 1e-8, None) pred_hist /= weights_sum[..., None, None] pred_depth /= weights_sum pred_depth_viz /= weights_sum if valid_mask is None: valid_mask = np.ones((img_h, img_w), dtype=bool) gt_hist_1 = gt_hist[..., 0].astype(np.float32) pred_hist_1 = pred_hist[..., 0].astype(np.float32) gt_intensity = _extract_intensity_from_hist(gt_hist) pred_intensity = _extract_intensity_from_hist(pred_hist) if args.version == "simulated": gt_depth = get_gt_depth(frame_info, test_dataset.camtoworlds[i].cpu().numpy(), args.test_folder_path) else: gt_depth = np.argmax(gt_hist_1, axis=-1).astype(np.float32) * float(args.exposure_time) / 2.0 # Keep captured depth definition consistent with histogram peak depth. pred_depth = np.argmax(pred_hist_1, axis=-1).astype(np.float32) * float(args.exposure_time) / 2.0 signal_mask = gt_intensity > 0 if args.version == "captured" and float(getattr(args, "meas_peak_min", 100.0)) > 0: peak_thre_norm = float(args.meas_peak_min) / float(eval_dataset_scale) meas_peak_mask = np.max(gt_hist_1, axis=-1) >= peak_thre_norm else: meas_peak_mask = np.ones_like(signal_mask, dtype=bool) metric_mask = valid_mask & signal_mask & meas_peak_mask print( f"mask ratio: valid={valid_mask.mean():.4f}, " f"peak={meas_peak_mask.mean():.4f}, metric={metric_mask.mean():.4f}" ) depth_mask = metric_mask & np.isfinite(gt_depth) & np.isfinite(pred_depth) if np.any(depth_mask): depth_l1 = float(np.mean(np.abs(gt_depth[depth_mask] - pred_depth[depth_mask]))) else: depth_l1 = float("nan") gt_intensity_01 = np.clip(gt_intensity / scale_int, 0.0, 1.0) pred_intensity_01 = np.clip(pred_intensity / scale_int, 0.0, 1.0) gt_hist_01 = np.clip(gt_hist_1 / scale_int, 0.0, 1.0) pred_hist_01 = np.clip(pred_hist_1 / scale_int, 0.0, 1.0) gt_intensity_gamma = _to_gamma_domain(gt_intensity_01) pred_intensity_gamma = _to_gamma_domain(pred_intensity_01) gt_intensity_eval = gt_intensity_gamma.copy() pred_intensity_eval = pred_intensity_gamma.copy() gt_intensity_eval[~metric_mask] = 0.0 pred_intensity_eval[~metric_mask] = 0.0 intensity_ssim = float( structural_similarity(gt_intensity_eval, pred_intensity_eval, data_range=1.0) ) gt_lpips = _to_lpips_input(gt_intensity_eval) pred_lpips = _to_lpips_input(pred_intensity_eval) intensity_lpips = float(lpips_model(gt_lpips, pred_lpips).detach().cpu().item()) waveform_psnr = _safe_psnr(gt_hist_01, pred_hist_01, mask=metric_mask) prefix = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_test{ind}") np.save(prefix + "_hist_gt.npy", gt_hist_1.astype(np.float32)) np.save(prefix + "_hist_pred.npy", pred_hist_1.astype(np.float32)) np.save(prefix + "_depth_gt.npy", gt_depth.astype(np.float32)) np.save(prefix + "_depth_pred.npy", pred_depth.astype(np.float32)) np.save(prefix + "_intensity_gt.npy", gt_intensity.astype(np.float32)) np.save(prefix + "_intensity_pred.npy", pred_intensity.astype(np.float32)) np.save(prefix + "_valid_mask.npy", metric_mask.astype(np.uint8)) np.save(prefix + "_meas_peak_mask.npy", meas_peak_mask.astype(np.uint8)) torch.save(torch.from_numpy(pred_hist_1.astype(np.float32)), prefix + "_conv_pred.pt") gt_intensity_vis = _normalize_for_vis(gt_intensity, metric_mask) ** (1.0 / 2.2) pred_intensity_vis = _normalize_for_vis(pred_intensity, metric_mask) ** (1.0 / 2.2) imageio.imwrite(prefix + "_intensity_gt.png", (gt_intensity_vis * 255.0).astype(np.uint8)) imageio.imwrite(prefix + "_intensity_pred.png", (pred_intensity_vis * 255.0).astype(np.uint8)) depth_for_viz = gt_depth[depth_mask] if np.any(depth_mask) else gt_depth[np.isfinite(gt_depth)] if depth_for_viz.size > 0: vmin = float(np.percentile(depth_for_viz, 1.0)) vmax = float(np.percentile(depth_for_viz, 99.0)) if vmax <= vmin: vmax = vmin + 1e-6 else: vmin, vmax = 0.0, 1.0 plt.imsave(prefix + "_depth_gt.png", gt_depth, cmap="inferno", vmin=vmin, vmax=vmax) plt.imsave(prefix + "_depth_pred.png", pred_depth, cmap="inferno", vmin=vmin, vmax=vmax) plt.imsave(prefix + "_depth_pred_viz.png", pred_depth_viz, cmap="inferno", vmin=vmin, vmax=vmax) metrics_row = { "index": i, "frame_id": ind, "frame_file_path": frame_file_path, "frame_name": frame_name, "intensity_ssim": intensity_ssim, "intensity_lpips": intensity_lpips, "depth_l1": depth_l1, "waveform_psnr": waveform_psnr, } per_image_metrics.append(metrics_row) print( f"SSIM={intensity_ssim:.6f} LPIPS={intensity_lpips:.6f} " f"DepthL1={depth_l1:.6f} WavePSNR={waveform_psnr:.4f}" ) print("-----") def _nanmean(key): values = np.array([row[key] for row in per_image_metrics], dtype=np.float64) return float(np.nanmean(values)) summary = { "scene": args.scene, "num_views": int(args.num_views), "step": int(args.step), "num_images": len(per_image_metrics), "avg_intensity_ssim": _nanmean("intensity_ssim"), "avg_intensity_lpips": _nanmean("intensity_lpips"), "avg_depth_l1": _nanmean("depth_l1"), "avg_waveform_psnr": _nanmean("waveform_psnr"), } print(json.dumps(summary, indent=2)) csv_path = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_metrics_per_image.csv") json_rows_path = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_metrics_per_image.json") json_summary_path = os.path.join(outpath, f"{args.scene}_{args.num_views}_{args.step}_metrics_summary.json") _save_metrics_csv(csv_path, per_image_metrics) with open(json_rows_path, "w", encoding="utf-8") as f: json.dump(per_image_metrics, f, indent=2) with open(json_summary_path, "w", encoding="utf-8") as f: json.dump(summary, f, indent=2) if __name__ == "__main__": eval()