| import math |
| import os |
|
|
| import configargparse |
| import numpy as np |
| import pandas as pd |
| import scipy.io as sio |
| import torch |
| import torch.multiprocessing as mp |
| import tqdm |
| from nerfacc.estimators.occ_grid import OccGridEstimator |
| from torch.utils.tensorboard import SummaryWriter |
|
|
| from misc.summary import write_summary_histogram |
| from misc.transient_volrend import torch_laser_kernel |
| from radiance_fields.ngp import NGPRadianceField |
| from utils import ( |
| load_args, |
| make_save_folder, |
| make_save_folder_final, |
| render_transient, |
| set_random_seed, |
| ) |
|
|
| if mp.get_start_method(allow_none=True) is None: |
| mp.set_start_method("spawn") |
|
|
|
|
| def load_args_ours(): |
| parser = configargparse.ArgumentParser() |
| parser.add_argument( |
| "--irf_path", |
| type=str, |
| default="", |
| help="Path to IRF file. Supports .csv/.npy/.mat/.pt. If empty, fallback to --pulse_path.", |
| ) |
| parser.add_argument( |
| "--irf_column", |
| type=str, |
| default="irf", |
| help="CSV column name for IRF values.", |
| ) |
| parser.add_argument( |
| "--irf_half_window", |
| type=int, |
| default=50, |
| help="Half window size for cropping around IRF peak. Set <=0 to disable crop.", |
| ) |
| parser.add_argument( |
| "--no_irf_reverse", |
| action="store_true", |
| help="Disable reverse before Conv1d kernel creation.", |
| ) |
| parser.add_argument( |
| "--measurement_root", |
| type=str, |
| default="", |
| help="Optional root directory of measurement files (.npz/.txt/.pt/.h5).", |
| ) |
| parser.add_argument( |
| "--data_exts", |
| type=str, |
| default=".npz,.txt,.pt,.h5,.hdf5", |
| help="Comma-separated measurement extensions lookup order.", |
| ) |
| parser.add_argument( |
| "--bin_width_s_loader", |
| type=float, |
| default=None, |
| help="Bin width in seconds for shift resampling. If empty, derived from exposure_time / c.", |
| ) |
| parser.add_argument( |
| "--img_height", |
| type=int, |
| default=None, |
| help="Training image height. If empty, use --img_shape.", |
| ) |
| parser.add_argument( |
| "--img_width", |
| type=int, |
| default=None, |
| help="Training image width. If empty, use --img_shape.", |
| ) |
| parser.add_argument( |
| "--img_height_test", |
| type=int, |
| default=None, |
| help="Test image height. If empty, use --img_shape_test.", |
| ) |
| parser.add_argument( |
| "--img_width_test", |
| type=int, |
| default=None, |
| help="Test image width. If empty, use --img_shape_test.", |
| ) |
| parser.add_argument( |
| "--meas_peak_min", |
| type=float, |
| default=100.0, |
| help=( |
| "Minimum raw histogram peak per pixel to keep it in photometric loss. " |
| "<=0 disables this mask. Threshold is interpreted in pre-normalization measurement scale." |
| ), |
| ) |
| parser.add_argument( |
| "--invalid_mask_path", |
| type=str, |
| default="", |
| help=( |
| "Path to offset map used to build valid-pixel mask. " |
| "Pixels with offset > invalid_mask_invalid_gt are excluded from training/eval." |
| ), |
| ) |
| parser.add_argument( |
| "--invalid_mask_invalid_gt", |
| type=float, |
| default=10.0, |
| help="Offset threshold for invalid pixels in invalid_mask_path.", |
| ) |
| return load_args(eval=True, parser=parser) |
|
|
|
|
| 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 _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 = args.irf_path if args.irf_path else args.pulse_path |
| if not irf_path: |
| raise ValueError("IRF path is empty. Set --irf_path or --pulse_path.") |
|
|
| irf = _load_irf_series(irf_path, args.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 args.irf_half_window and args.irf_half_window > 0: |
| lo = max(0, peak_idx - int(args.irf_half_window)) |
| hi = min(len(irf), peak_idx + int(args.irf_half_window) + 1) |
| irf = irf[lo:hi] |
|
|
| irf = irf / (irf.sum() + 1e-8) |
| if not args.no_irf_reverse: |
| irf = irf[::-1].copy() |
|
|
| laser = torch.tensor(irf, dtype=torch.float32, device=device) |
| return torch_laser_kernel(laser, device=device) |
|
|
|
|
| def run(): |
| args = load_args_ours() |
| device = torch.device(args.device) |
| args.device = str(device) |
| if device.type == "cuda": |
| if not torch.cuda.is_available(): |
| raise RuntimeError(f"CUDA device requested but CUDA is unavailable: {device}") |
| torch.cuda.set_device(device) |
| torch.cuda.empty_cache() |
| set_random_seed(args.seed) |
|
|
| train_h = int(args.img_height) if args.img_height is not None else int(args.img_shape) |
| train_w = int(args.img_width) if args.img_width is not None else int(args.img_shape) |
| test_h = int(args.img_height_test) if args.img_height_test is not None else int(args.img_shape_test) |
| test_w = int(args.img_width_test) if args.img_width_test is not None else int(args.img_shape_test) |
| img_shape = (train_h, train_w) |
| img_shape_test = (test_h, test_w) |
|
|
| aabb = torch.tensor(args.aabb, dtype=torch.float32, device=device) |
| train_dataset_kwargs = {} |
| test_dataset_kwargs = {} |
|
|
| rfilter_sigma = args.rfilter_sigma |
| max_steps = args.max_steps |
| sample_as_per_distribution = args.sample_as_per_distribution |
| target_sample_batch_size = 1 << 16 |
|
|
| if args.version == "simulated": |
| from loaders.loader_synthetic import SubjectLoaderTransient as SubjectLoader |
|
|
| test_dataset_kwargs = { |
| "img_shape": img_shape_test, |
| "have_images": True, |
| "n_bins": args.n_bins, |
| "color_bkgd_aug": "black", |
| "rfilter_sigma": rfilter_sigma, |
| "sample_as_per_distribution": sample_as_per_distribution, |
| } |
| train_dataset_kwargs = { |
| "img_shape": img_shape, |
| "n_bins": args.n_bins, |
| "color_bkgd_aug": "black", |
| "rfilter_sigma": rfilter_sigma, |
| "sample_as_per_distribution": sample_as_per_distribution, |
| } |
|
|
| train_dataset = SubjectLoader( |
| root_fp=args.data_root_fp, |
| subject_id=args.exp_name, |
| split="train", |
| num_rays=target_sample_batch_size // args.render_n_samples, |
| **train_dataset_kwargs, |
| num_views=args.num_views, |
| ) |
| train_dataset.camtoworlds = train_dataset.camtoworlds.to(device) |
| train_dataset.K = train_dataset.K.to(device) |
|
|
| test_dataset = SubjectLoader( |
| root_fp=args.data_root_fp, |
| subject_id=args.exp_name, |
| split="test", |
| num_rays=None, |
| **test_dataset_kwargs, |
| ) |
| if test_dataset_kwargs["have_images"]: |
| test_dataset.images = test_dataset.images.to(device) |
| test_dataset.camtoworlds = test_dataset.camtoworlds.to(device) |
| test_dataset.K = test_dataset.K.to(device) |
| 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])) |
|
|
| measurement_root = args.measurement_root.strip() or None |
| invalid_mask_path = args.invalid_mask_path.strip() or None |
| data_exts = tuple(e.strip() for e in args.data_exts.split(",") if e.strip()) |
| if args.bin_width_s_loader 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_test, |
| "have_images": True, |
| "n_bins": args.n_bins, |
| "color_bkgd_aug": "black", |
| "rfilter_sigma": rfilter_sigma, |
| "sample_as_per_distribution": sample_as_per_distribution, |
| "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(args.invalid_mask_invalid_gt), |
| } |
| train_dataset_kwargs = { |
| "img_shape": img_shape, |
| "n_bins": args.n_bins, |
| "color_bkgd_aug": "black", |
| "rfilter_sigma": rfilter_sigma, |
| "sample_as_per_distribution": sample_as_per_distribution, |
| "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(args.invalid_mask_invalid_gt), |
| } |
|
|
| train_dataset = SubjectLoader( |
| root_fp=args.data_root_fp, |
| subject_id=args.exp_name, |
| split="train", |
| num_rays=target_sample_batch_size // args.render_n_samples, |
| **train_dataset_kwargs, |
| ) |
| train_dataset.camtoworlds = train_dataset.camtoworlds.to(device) |
| train_dataset.K = LearnRays(rays, device=device, img_shape=img_shape).to(device) |
|
|
| test_dataset = SubjectLoader( |
| root_fp=args.data_root_fp, |
| subject_id=args.exp_name, |
| split="test", |
| num_rays=None, |
| **test_dataset_kwargs, |
| ) |
| if test_dataset_kwargs["have_images"]: |
| test_dataset.images = test_dataset.images.to(device) |
| test_dataset.camtoworlds = test_dataset.camtoworlds.to(device) |
| test_dataset.K = LearnRays(rays, device=device, img_shape=img_shape_test).to(device) |
|
|
| args.laser_kernel = build_irf_kernel(args, device=device) |
| train_dataset_scale = float(_to_numpy(train_dataset.max).reshape(-1)[0]) |
| if train_dataset_scale <= 0: |
| train_dataset_scale = 1.0 |
|
|
| scene_aabb = torch.tensor(args.aabb, dtype=torch.float32, device=device) |
| render_step_size = ((scene_aabb[3:] - scene_aabb[:3]).max() * math.sqrt(3) / args.render_n_samples).item() |
|
|
| grad_scaler = torch.cuda.amp.GradScaler(2**10) |
| radiance_field = NGPRadianceField( |
| use_viewdirs=True, |
| aabb=args.aabb, |
| unbounded=False, |
| radiance_activation=torch.exp, |
| args=args, |
| ).to(device) |
|
|
| optimizer = torch.optim.Adam(radiance_field.parameters(), lr=args.lr, eps=1e-15) |
| scheduler = torch.optim.lr_scheduler.MultiStepLR( |
| optimizer, |
| milestones=[max_steps // 2, max_steps * 3 // 4, max_steps * 9 // 10], |
| gamma=0.33, |
| ) |
| occupancy_grid = OccGridEstimator( |
| roi_aabb=aabb, |
| resolution=args.grid_resolution, |
| levels=args.grid_nlvl, |
| ).to(device) |
|
|
| if args.final: |
| writer, step, outpath = make_save_folder_final( |
| args, |
| optimizer, |
| scheduler, |
| radiance_field, |
| occupancy_grid, |
| ) |
| args.outpath = outpath |
| else: |
| outpath = make_save_folder(args) |
| args.outpath = outpath |
| writer = SummaryWriter(log_dir=outpath) |
| step = 0 |
|
|
| |
| pbar = tqdm.tqdm(total=args.max_steps, initial=min(step, args.max_steps)) |
| zero_sample_streak = 0 |
| while step < max_steps: |
| pbar.update(1) |
|
|
| if args.version == "simulated" and step % 1000 == 0: |
| if train_dataset.rep < 30: |
| train_dataset.rep += 2 |
|
|
| radiance_field.train() |
|
|
| i = torch.randint(0, len(train_dataset), (1,)).item() |
| data = train_dataset[i] |
| rays = data["rays"] |
| num_base_rays = int(rays.origins.shape[0] / train_dataset.rep) |
| pixs = torch.reshape( |
| data["pixels"][:num_base_rays], |
| (-1, args.n_bins, 3), |
| ) |
| data_valid_mask = data.get("valid_mask") |
| if data_valid_mask is not None: |
| data_valid_mask = data_valid_mask.to(device=device, dtype=torch.bool).reshape(-1) |
| if data_valid_mask.numel() < num_base_rays: |
| raise ValueError( |
| f"valid_mask has too few elements: {data_valid_mask.numel()} < base rays {num_base_rays}" |
| ) |
| data_valid_mask = data_valid_mask[:num_base_rays] |
| else: |
| data_valid_mask = torch.ones(pixs.shape[0], dtype=torch.bool, device=device) |
| |
| if args.version == "captured" and float(args.meas_peak_min) > 0: |
| peak_thre_norm = float(args.meas_peak_min) / float(train_dataset_scale) |
| meas_peak = torch.amax(pixs[..., 0], dim=-1) |
| meas_valid_mask = meas_peak >= peak_thre_norm |
| else: |
| meas_valid_mask = torch.ones(pixs.shape[0], dtype=torch.bool, device=pixs.device) |
|
|
| def occ_eval_fn(x): |
| density = radiance_field.query_density(x) |
| density = torch.nan_to_num(density, nan=0.0, posinf=0.0, neginf=0.0) |
| return density.squeeze(-1) * render_step_size |
|
|
| base_occ_thre = float(args.occ_thre) |
| if args.version == "captured": |
| warmup_steps = int(args.thold_warmup) if int(args.thold_warmup) > 0 else 10000 |
| occ_thre = min(base_occ_thre, 1e-6) if step < warmup_steps else base_occ_thre |
| else: |
| occ_thre = base_occ_thre |
|
|
| try: |
| occupancy_grid.update_every_n_steps(step=step, occ_eval_fn=occ_eval_fn, occ_thre=occ_thre) |
| except RuntimeError as ex: |
| if "invalid configuration argument" in str(ex).lower(): |
| raise RuntimeError( |
| "CUDA invalid configuration argument during occupancy update. " |
| "This is often an async CUDA error from an earlier kernel. " |
| "Rerun with CUDA_LAUNCH_BLOCKING=1 to get the first failing op." |
| ) from ex |
| raise |
|
|
| 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, |
| ) |
|
|
| rgb, acc, n_rendering_samples, comp_weights = [ |
| out[key] for key in ["colors", "opacities", "n_rendering_samples", "comp_weights"] |
| ] |
| del out |
|
|
| if n_rendering_samples == 0: |
| |
| zero_sample_streak += 1 |
| if zero_sample_streak % 100 == 0: |
| print( |
| f"[WARN] n_rendering_samples==0 streak={zero_sample_streak} " |
| f"at step={step}. Try lowering occ_thre (current={occ_thre})." |
| ) |
| step += 1 |
| continue |
| zero_sample_streak = 0 |
|
|
| train_dataset.update_num_rays(args.num_rays_per_batch) |
|
|
| alive_ray_mask = acc.squeeze(-1) > 0 |
| alive_ray_mask = alive_ray_mask.reshape(train_dataset.rep, -1) |
| alive_ray_mask = alive_ray_mask.sum(0).bool() |
| supervised_mask = alive_ray_mask & meas_valid_mask & data_valid_mask |
|
|
| rgba = torch.reshape(rgb, (-1, args.n_bins, 3)) * data["weights"][:, None, None] |
| carve_mask = pixs.sum(-1).repeat(train_dataset.rep, 1) < 1e-7 |
| valid_mask_flat = data_valid_mask.repeat(train_dataset.rep)[:, None] |
| carve_mask = carve_mask & valid_mask_flat.expand(-1, args.n_bins) |
| carve_vals = comp_weights[carve_mask] |
| if carve_vals.numel() > 0: |
| comp_weights = carve_vals.mean() |
| else: |
| comp_weights = torch.tensor(0.0, device=device, dtype=rgba.dtype) |
| rgb = torch.zeros((int(rgba.shape[0] / train_dataset.rep), args.n_bins, 3), device=device) |
| index = ( |
| torch.arange(int(rgba.shape[0] / train_dataset.rep), device=device) |
| .repeat(train_dataset.rep)[:, None, None] |
| .expand(-1, args.n_bins, 3) |
| ) |
| rgb.scatter_add_(0, index.type(torch.int64), rgba) |
|
|
| pixs = torch.log(pixs + 1) |
| rgb = torch.log(rgb + 1) |
| if supervised_mask.any(): |
| photometric_loss = torch.nn.functional.l1_loss(rgb[supervised_mask], pixs[supervised_mask]) |
| else: |
| photometric_loss = torch.tensor(0.0, device=device) |
| loss = photometric_loss + comp_weights * args.space_carving |
|
|
| optimizer.zero_grad() |
| grad_scaler.scale(loss).backward() |
| optimizer.step() |
| scheduler.step() |
|
|
| writer.add_scalar("Loss/train", loss.detach().cpu().numpy(), step) |
| writer.add_scalar("Loss/photometric", photometric_loss.detach().cpu().numpy(), step) |
| writer.add_scalar("Mask/supervised_ratio", supervised_mask.float().mean().detach().cpu().numpy(), step) |
|
|
| if not step % args.steps_til_checkpoint: |
| path = os.path.join(outpath, "radiance_field_{:04d}.pth".format(step)) |
| torch.save(radiance_field.state_dict(), path) |
| path = os.path.join(outpath, "occupancy_grid_{:04d}.pth".format(step)) |
| torch.save(occupancy_grid.state_dict(), path) |
| path = os.path.join(outpath, "optimizer_{:04d}.pth".format(step)) |
| torch.save(optimizer.state_dict(), path) |
| path = os.path.join(outpath, "scheduler_{:04d}.pth".format(step)) |
| torch.save(scheduler.state_dict(), path) |
| torch.save({"step": step, "rays_per_pixel": train_dataset.rep}, os.path.join(outpath, "variables.pth")) |
|
|
| if test_dataset_kwargs["have_images"]: |
| write_summary_histogram( |
| radiance_field, |
| occupancy_grid, |
| writer, |
| test_dataset, |
| step, |
| render_step_size, |
| args, |
| ) |
|
|
| step += 1 |
|
|
|
|
| if __name__ == "__main__": |
| run() |
|
|
