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