Remove redundant transientnerf code folder

codes/reconstruction/transientnerf/configs/test/captured/artbuilding3_five_views_quantitative.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "artbuilding3_five_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "results/artbuilding3_five_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/poses/five_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-25.379819,-15.216244,-2.908998,29.218790,32.190764,16.977430]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/artbuilding3_ten_views_quantitative.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "artbuilding3_ten_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "results/artbuilding3_ten_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/poses/ten_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-25.379819,-15.216244,-2.908998,29.218790,32.190764,16.977430]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/balldesk_quantitative_fiveviews.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "balldesk_fiveviews"
-step = 300000
-rep_number = 30
-split = "test"
-checkpoint_dir = "./results/ours_balldesk_five_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/five_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-20.685711,-15.981851,-1.508756,19.605109,8.297641,5.438520]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/balldesk_quantitative_tenviews.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "balldesk_tenviews"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "./results/ours_balldesk"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/ten_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-20.685711,-15.981851,-1.508756,19.605109,8.297641,5.438520]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/balldesk_quantitative_threeviews.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "balldesk_threeviews"
-step = 170000
-rep_number = 30
-split = "test"
-checkpoint_dir = "./results/ours_balldesk_three_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/three_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-20.685711,-15.981851,-1.508756,19.605109,8.297641,5.438520]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/three_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/designbuilding1_five_views_quantitative.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "designbuilding1_five_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "./results/designbuilding1_five_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/poses/five_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-30.723363,-32.531209,-1.819858,30.377352,12.024207,9.260004]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/designbuilding1_quantitative_tenviews.ini

@@ -1,47 +0,0 @@
-# eval job
-scene = "designbuilding1_ten_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "./results/designbuilding1_ten_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/poses/ten_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-30.723363,-32.531209,-1.819858,30.377352,12.024207,9.260004]"
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/parking_five_views_quantitative.ini

@@ -1,48 +0,0 @@
-# eval job
-scene = "parking_five_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "results/parking_five_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/poses/five_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-30.503840,-28.637896,-2.067505,30.827200,12.873783,5.960705]"
-near_plane = 0.100000
-far_plane = 30.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-meas_peak_min = 20
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/parking_ten_views_quantitative.ini

@@ -1,48 +0,0 @@
-# eval job
-scene = "parking_ten_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "results/parking_ten_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/poses/ten_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-30.503840,-28.637896,-2.067505,30.827200,12.873783,5.960705]"
-near_plane = 0.100000
-far_plane = 30.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-meas_peak_min = 20
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/physics_building2_ten_views_quantitative.ini

@@ -1,48 +0,0 @@
-# eval job
-scene = "physics_building2_ten_views"
-step = 290000
-rep_number = 30
-split = "test"
-checkpoint_dir = "results/physics_building2_ten_views"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/poses/ten_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-30.008253,-20.426221,-1.811843,20.122535,20.849413,10.086755]"
-near_plane = 0.100000
-far_plane = 38.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-meas_peak_min = 10
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/test/captured/physics_building2_ten_views_quantitative1.ini

@@ -1,48 +0,0 @@
-# eval job
-scene = "physics_building2_ten_views"
-step = 100000
-rep_number = 30
-split = "test"
-checkpoint_dir = "results/physics_building2_ten_views0"
-test_folder_path = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/poses/ten_views"
-
-# model / rendering
-version = captured
-n_bins = 672
-aabb = "[-30.008253,-20.426221,-1.811843,20.122535,20.849413,10.086755]"
-near_plane = 0.100000
-far_plane = 38.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-render_n_samples = 1024
-rfilter_sigma = 0.15
-sample_as_per_distribution = False
-grid_resolution = 128
-grid_nlvl = 1
-meas_peak_min = 10
-
-# timing / sensor
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-
-# data
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-meas_peak_min = 100
-
-# image size
-img_height_test = 192
-img_width_test = 256
-img_shape_test = 256
-
-# misc
-num_views = 10
-device = "cuda:0"
-seed = 42

codes/reconstruction/transientnerf/configs/train/captured/artbuilding3_five_views.ini

@@ -1,50 +0,0 @@
-exp_name = "artbuilding3_five_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-25.379819,-15.216244,-2.908998,29.218790,32.190764,16.977430]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/artbuilding3_ten_views.ini

@@ -1,50 +0,0 @@
-exp_name = "artbuilding3_ten_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-25.379819,-15.216244,-2.908998,29.218790,32.190764,16.977430]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/artbuilding3/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/designbuilding1_five_views.ini

@@ -1,50 +0,0 @@
-exp_name = "designbuilding1_five_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-30.723363,-32.531209,-1.819858,30.377352,12.024207,9.260004]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/designbuilding1_tenviews.ini

@@ -1,50 +0,0 @@
-exp_name = "designbuilding1_ten_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-30.723363,-32.531209,-1.819858,30.377352,12.024207,9.260004]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/designbuilding1/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/material_building_five_views.ini

@@ -1,51 +0,0 @@
-exp_name = "material_building_five_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-14.996998,-4.556170,-3.767088,54.273853,33.048301,29.515029]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/material_building/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/material_building/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-meas_peak_min = 20
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 55.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/material_building_ten_views.ini

@@ -1,51 +0,0 @@
-exp_name = "material_building_ten_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-14.996998,-4.556170,-3.767088,54.273853,33.048301,29.515029]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/material_building/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/material_building/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-meas_peak_min = 20
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 55.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/parking_five_views.ini

@@ -1,51 +0,0 @@
-exp_name = "parking_five_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-30.503840,-28.637896,-2.067505,30.827200,12.873783,5.960705]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-meas_peak_min = 20
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 30.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/parking_ten_views.ini

@@ -1,51 +0,0 @@
-exp_name = "parking_ten_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-30.503840,-28.637896,-2.067505,30.827200,12.873783,5.960705]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/parking/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-meas_peak_min = 20
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 30.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/physics_building2_ten_views.ini

@@ -1,51 +0,0 @@
-exp_name = "physics_building2_ten_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-30.008253,-20.426221,-1.811843,20.122535,20.849413,10.086755]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/360/physics_building2/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-meas_peak_min = 10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 38.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/tfnerf_balldesk_fiveviews.ini

@@ -1,50 +0,0 @@
-exp_name = "ours_balldesk_five_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-20.685711,-15.981851,-1.508756,19.605109,8.297641,5.438520]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/five_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/tfnerf_balldesk_tenviews.ini

@@ -1,50 +0,0 @@
-exp_name = "ours_balldesk"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-20.685711,-15.981851,-1.508756,19.605109,8.297641,5.438520]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/ten_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/configs/train/captured/tfnerf_balldesk_threeviews.ini

@@ -1,50 +0,0 @@
-exp_name = "ours_balldesk_three_views"
-test_chunk_size = 256
-num_rays_per_batch = 512
-starting_rays_per_pixel = 1
-tfilter_sigma = 3
-rfilter_sigma = 0.15
-space_carving = 0.0
-lr = 0.0001
-num_views = 10
-
-n_bins = 672
-aabb = "[-20.685711,-15.981851,-1.508756,19.605109,8.297641,5.438520]"
-version = "captured"
-data_root_fp = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/poses/three_views"
-measurement_root = "/work/sdim-lemons/wzt/data/spad_3d/balldesk/sp"
-data_exts = ".npz,.txt,.pt,.h5,.hdf5"
-irf_path = "/work/sdim-lemons/wzt/data/transient_nets/IRF_global.csv"
-irf_column = "irf"
-irf_half_window = 50
-intrinsics = "/work/sdim-lemons/wzt/data/transient_nets/intrinsics.npy"
-invalid_mask_path = "/work/sdim-lemons/wzt/data/transient_nets/offset.txt"
-invalid_mask_invalid_gt = 10.0
-exposure_time = 0.224844343500
-bin_width_s_loader = 7.500000000000e-10
-
-thold_warmup = 80000
-max_steps = 300001
-img_height = 192
-img_width = 256
-img_height_test = 192
-img_width_test = 256
-img_shape = 256
-img_shape_test = 256
-near_plane = 0.100000
-far_plane = 28.000000
-alpha_thre = 0
-occ_thre = 0.0000001
-sample_as_per_distribution = False
-render_n_samples = 1024
-exp = True
-final = True
-steps_til_checkpoint = 10000
-grid_resolution = 128
-grid_nlvl = 1
-outpath = "./results"
-pixels_to_plot = ["(40, 60)", "(60, 100)", "(80, 60)"]
-img_scale = 100
-seed = 42
-device = "cuda:0"
-

codes/reconstruction/transientnerf/eval.py

@@ -1,556 +0,0 @@
-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()

codes/reconstruction/transientnerf/loaders/README.md

@@ -1,57 +0,0 @@
-1. The captured scenes include: carving, boots, baskets, cinema, chef. 
-The simulated scenes include lego, chair, ficus, hotdog, bench. 
-These have different structures and loaders. 
-
-In the root of the dataset folder you can also find the `intrinsics.npy` which is the set of captured rays and parameters used in training and `pulse_low_flux.mat` which is the calibrated laser pulse.
-
-
-2. Training transform files.
-
-For the *captured* scenes the training transforms are all named `transforms_train.json` and can be found under `<scene_name>/final_cams/<num_views>/transforms_train.json`. 
-
-For the *simulated* scenes the training transforms are all named `transforms_train_v{i}.json` where `i` is the number of views (2, 3, 5). and can be found under `<scene_name>/transforms_train_v{i}.json`. 
-
-
-3. Test transform files.
-
-For the *captured* scenes the test transforms can be found under `<scene_name>/final_cams/test_jsons/transforms_test.json`. 
-
-For the *simulated* scenes the test transforms can be found under `<scene_name>/transforms_test_final.json`. 
-
-
-4. Downloading.
-
-- You can download the data yourself either through the Dropbox download button, or by right-clicking a folder and selecting copy link address, then
-```
-wget "copied link" 
-```
-will start a download of the folder. 
-
-5. (!!!) Using the dataset.
-
-To use the dataset alongside its transforms please look at the loader in `loaders/loader_captured.py` in the [GitHub repository](https://github.com/anaghmalik/TransientNeRF). Most importantly to use the temporal *captured* data, you will have to resample the transient using the shift given in the `intrinsics.npy` file:
-
-```
-img_shape = (512, 512)
-exposure_time= 299792458*4e-12
-n_bins = 1500
-
-x = (torch.arange(img_shape[0], device="cpu")-img_shape[0]//2+0.5)/(img_shape[0]//2-0.5)
-y = (torch.arange(img_shape[0], device="cpu")-img_shape[0]//2+0.5)/(img_shape[0]//2-0.5)
-z = torch.arange(n_bins*2, device="cpu").float()
-X, Y, Z = torch.meshgrid(x, y, z, indexing="xy")
-Z = Z*exposure_time/2
-Z = Z - shift[0]
-Z = Z*2/exposure_time
-Z = (Z-n_bins*2//2+0.5)/(n_bins*2//2-0.5)
-grid = torch.stack((Z, X, Y), dim=-1)[None, ...]
-del X
-del Y
-del Z
-
-rgb = torch.Tensor(rgb)[..., :3000].float().cpu()
-rgb = torch.nn.functional.grid_sample(rgb[None, None, ...], grid, align_corners=True).squeeze().cpu()
-
-```
-
-where `shift` is the value from the `intrinsics.npy` file and `rgb` is the original loaded transient. 

codes/reconstruction/transientnerf/loaders/loader_captured.py

@@ -1,532 +0,0 @@
-import collections
-import json
-import os
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-import scipy
-from mat73 import loadmat
-from .utils import Rays
-from tqdm import tqdm
-import sys
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from misc.dataset_utils import read_h5
-
-
-def _load_renderings(root_fp: str, subject_id: str, split: str, have_images=True, img_shape=(256, 256)):
-    """Load images from disk."""
-    if not root_fp.startswith("/"):
-        # allow relative path. e.g., "./data/nerf_synthetic/"
-        root_fp = os.path.join(
-            os.path.dirname(os.path.abspath(__file__)),
-            "..",
-            "..",
-            root_fp,
-        )
-
-    data_dir = root_fp
-    with open(
-            os.path.join(data_dir, "transforms_{}.json".format(split)), "r"
-    ) as fp:
-        meta = json.load(fp)
-    images = []
-    camtoworlds = []
-
-    if have_images:
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            number = int(frame["file_path"].split("_")[-1])
-            fname = os.path.join(data_dir, f"{number:03d}" + ".png")
-
-            # fname = os.path.join(data_dir, frame["file_path"] + ".png")
-            rgba = imageio.imread(fname)
-            camtoworlds.append(frame["transform_matrix"])
-            images.append(rgba)
-
-        images = np.stack(images, axis=0)
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = images.shape[1:3]
-    else:
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            camtoworlds.append(frame["transform_matrix"])
-
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = img_shape
-
-    camera_angle_x = float(meta["camera_angle_x"])
-    focal = 0.5 * w / np.tan(0.5 * camera_angle_x)
-
-    return images, camtoworlds, focal
-
-
-def _parse_shift_for_grid(shift, img_shape):
-    h, w = int(img_shape[0]), int(img_shape[1])
-    arr = np.asarray(shift, dtype=np.float32)
-    if arr.ndim == 0:
-        return float(arr.item()), None
-
-    arr = arr.squeeze()
-    if arr.ndim == 0 or arr.size == 1:
-        return float(arr.reshape(-1)[0]), None
-
-    if arr.ndim == 1 and arr.size == h * w:
-        return 0.0, torch.from_numpy(arr.reshape(h, w))
-    if arr.ndim == 2 and arr.shape == (h, w):
-        return 0.0, torch.from_numpy(arr)
-
-    # Fallback to legacy behavior: use first value only.
-    return float(arr.reshape(-1)[0]), None
-
-
-
-def _load_renderings_transient_real(root_fp: str, subject_id: str, split: str, have_images=True, img_shape=(256, 256), n_bins=4096, shift=0, bin_width_s=4e-12):
-    """Load images from disk."""
-
-    data_dir = root_fp
-    with open(
-            os.path.join(data_dir, "transforms_{}.json".format(split)), "r"
-    ) as fp:
-        meta = json.load(fp)
-
-    images = []
-    camtoworlds = []
-
-    exposure_time = 299792458 * float(bin_width_s)
-    shift_scalar, shift_map = _parse_shift_for_grid(shift, img_shape)
-
-    x = (torch.arange(img_shape[0], device="cpu")-img_shape[0]//2+0.5)/(img_shape[0]//2-0.5)
-    y = (torch.arange(img_shape[0], device="cpu")-img_shape[0]//2+0.5)/(img_shape[0]//2-0.5)
-    z = torch.arange(n_bins*2, device="cpu").float()
-    X, Y, Z = torch.meshgrid(x, y, z, indexing="xy")
-    Z = Z*exposure_time/2
-    if shift_map is not None:
-        Z = Z - shift_map[..., None]
-    else:
-        Z = Z - float(shift_scalar)
-    Z = Z*2/exposure_time
-    Z = (Z-n_bins*2//2+0.5)/(n_bins*2//2-0.5)
-    grid = torch.stack((Z, X, Y), dim=-1)[None, ...]
-    del X
-    del Y
-    del Z
-
-
-    if have_images:
-        tqdm.write('Loading data')
-        for i in tqdm(range(len(meta["frames"]))):
-            frame = meta["frames"][i]
-            number = int(frame["file_path"].split("_")[-1])
-
-            fname = os.path.join(os.path.join(data_dir, "../.."), f"transient{number:03d}.pt")
-            rgba = torch.load(fname).to_dense()
-            rgba = torch.Tensor(rgba)[..., :3000].float().cpu()
-            # if img_shape[0]==256:
-            #     rgba = (rgba[::2, ::2] + rgba[::2, 1::2] +  rgba[1::2, ::2]+ rgba[1::2, 1::2] )/4
-            
-            rgba = torch.nn.functional.grid_sample(rgba[None, None, ...], grid, align_corners=True).squeeze().cpu()
-            rgba = (rgba[..., 1::2]+ rgba[..., ::2] )/2
-
-            camtoworlds.append(frame["transform_matrix"])
-            rgba = torch.clip(rgba, 0, None)
-            rgba = rgba[..., None].repeat(1, 1, 1, 3)
-            images.append(rgba)
-
-
-
-        images = torch.stack(images, axis=0)
-        max = torch.max(images)
-        images /= torch.max(images)
-
-        if split == "test":
-            quotient = images.shape[1]//img_shape[0]
-            times_downsample = int(np.log2(quotient))
-        
-            for i in range(times_downsample):
-                images = (images[:, 1::2, ::2] + images[:, ::2, ::2] + images[:, 1::2, 1::2] + images[:, ::2, 1::2])/4
-
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = images.shape[1:3]
-    else:
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            camtoworlds.append(frame["transform_matrix"])
-
-        camtoworlds = np.stack(camtoworlds, axis=0)
-        max = 1
-        h, w = img_shape
-    
-
-    return images, camtoworlds, max
-
-
-class SubjectLoaderTransientReal(torch.utils.data.Dataset):
-    """Single subject data loader for training and evaluation."""
-
-    SPLITS = ["train", "val", "trainval", "test"]
-    SUBJECT_IDS = [
-        "chair",
-        "drums",
-        "ficus",
-        "hotdog",
-        "lego",
-        "materials",
-        "mic",
-        "ship",
-    ]
-
-    # WIDTH, HEIGHT = 64, 64
-    NEAR, FAR = 0, 6
-    OPENGL_CAMERA = True
-
-    def __init__(
-            self,
-            subject_id: str,
-            root_fp: str,
-            split: str,
-            color_bkgd_aug: str = "black",
-            num_rays: int = None,
-            near: float = None,
-            far: float = None,
-            batch_over_images: bool = True,
-            have_images=True,
-            img_shape=(256, 256),
-            n_bins=10000, 
-            rfilter_sigma=0.15,
-            sample_as_per_distribution = True,
-            shift = 0.3, 
-            testing =False
-    ):
-        super().__init__()
-        #assert split in self.SPLITS, "%s" % split
-        # assert subject_id in self.SUBJECT_IDS, "%s" % subject_id
-        assert color_bkgd_aug in ["white", "black", "random"]
-        self.sample_as_per_distribution = sample_as_per_distribution
-        self.rfilter_sigma = rfilter_sigma
-        self.HEIGHT, self.WIDTH = img_shape
-        self.split = split
-        self.testing = testing
-        self.num_rays = num_rays
-        self.near = self.NEAR if near is None else near
-        self.far = self.FAR if far is None else far
-        self.training = (num_rays is not None) and (
-                split in ["train", "trainval"]
-        )
-        self.shift = shift
-        self.testing = testing
-        self.rep = 1
-        self.color_bkgd_aug = color_bkgd_aug
-        self.batch_over_images = batch_over_images
-        self.have_images = have_images
-        self.n_bins = n_bins
-        shift = shift
-
-        if split == "trainval":
-            _images_train, _camtoworlds_train, _focal_train = _load_renderings_transient_real(
-                root_fp, subject_id, "train", n_bins=self.n_bins, shift=shift
-            )
-            _images_val, _camtoworlds_val, _focal_val = _load_renderings_transient_real(
-                root_fp, subject_id, "val", n_bins=self.n_bins, shift=shift
-            )
-            self.images = np.concatenate([_images_train, _images_val])
-            self.camtoworlds = np.concatenate(
-                [_camtoworlds_train, _camtoworlds_val]
-            )
-            self.focal = _focal_train
-            self.images = torch.from_numpy(self.images).to(torch.float32)
-
-            # ste for transient
-            self.images = torch.reshape(self.images, (-1, self.HEIGHT, self.WIDTH, self.n_bins*3))
-
-
-        elif have_images:
-            self.images, self.camtoworlds, self.focal = _load_renderings_transient_real(
-                root_fp, subject_id, split, n_bins=self.n_bins, shift=shift, img_shape=img_shape
-            )
-            self.images =self.images.to(torch.float32)
-            assert self.images.shape[1:3] == (self.HEIGHT, self.WIDTH)
-        else:
-            _, self.camtoworlds, self.focal = _load_renderings(
-                root_fp, subject_id, split, have_images=have_images, img_shape=img_shape
-            )
-        
-        self.max = self.focal
-
-        self.camtoworlds = torch.from_numpy(self.camtoworlds).to(torch.float32)
-        self.camtoworlds[:, :3, 3] = self.camtoworlds[:, :3, 3]
-        # self.K = LearnRays(params["rays"], img_shape=(self.WIDTH, self.HEIGHT))
-
-
-
-    def __len__(self):
-        return len(self.camtoworlds)
-
-    # @torch.no_grad()
-    def __getitem__(self, index):
-        data = self.fetch_data(index)
-        data = self.preprocess(data)
-        return data
-
-    def preprocess(self, data):
-        """Process the fetched / cached data with randomness."""
-        rgba, rays = data["rgba"], data["rays"]
-        # pixels, alpha = torch.split(rgba, [3, 1], dim=-1)
-
-        if rgba is not None:
-            pixels = rgba.to(self.camtoworlds.device)
-        else:
-            pixels = rgba
-        
-
-        if self.color_bkgd_aug == "random":
-            color_bkgd = torch.rand(3, device=self.camtoworlds.device)
-        elif self.color_bkgd_aug == "white":
-            color_bkgd = torch.ones(3, device=self.camtoworlds.device)
-        elif self.color_bkgd_aug == "black":
-            color_bkgd = torch.zeros(3, device=self.camtoworlds.device)
-
-        # pixels = pixels * alpha + color_bkgd * (1.0 - alpha)
-        return {
-            "pixels": pixels,  # [n_rays, 3] or [h, w, 3]
-            "rays": rays,  # [n_rays,] or [h, w]
-            "color_bkgd": color_bkgd,  # [3,]
-            **{k: v for k, v in data.items() if k not in ["rgba", "rays"]},
-        }
-
-
-    def update_num_rays(self, num_rays):
-        self.num_rays = num_rays
-
-    def fetch_data(self, index, rep=None, num_rays=None):
-        """Fetch the data (it maybe cached for multiple batches)."""
-        if num_rays==None:
-            num_rays = self.num_rays
-        if rep==None:
-            rep = self.rep
-        
-
-
-        if self.training:
-            if self.batch_over_images:
-                image_id = torch.randint(
-                    0,
-                    len(self.images),
-                    size=(num_rays,),
-                    device=self.images.device,
-                )
-            else:
-                image_id = [index]
-            x = torch.randint(
-                0, self.WIDTH, size=(num_rays,), device="cpu"
-            )
-            y = torch.randint(
-                0, self.HEIGHT, size=(num_rays,), device="cpu"
-            )
-            x = x.repeat(rep)
-            y = y.repeat(rep)
-            image_id = image_id.repeat(rep)
-
-
-            rgba = self.images[image_id, y, x]  # (num_rays, 4)
-
-        elif self.testing:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device="cpu"),
-                torch.arange(self.HEIGHT, device="cpu"),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-            x = x.repeat(rep)
-            y = y.repeat(rep)
-            # image_id = image_id.repeat(rep)
-            if self.have_images:
-                rgba = self.images[image_id, y, x]  # (num_rays, 4)
-            else:
-                rgba = None 
-        elif self.have_images:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device=self.camtoworlds.device),
-                torch.arange(self.HEIGHT, device=self.camtoworlds.device),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-            rgba = self.images[image_id, y, x]  # (num_rays, 4)
-        else:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device=self.camtoworlds.device),
-                torch.arange(self.HEIGHT, device=self.camtoworlds.device),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-
-        # generate rays
-        
-        scale = self.rfilter_sigma
-        c2w = self.camtoworlds[image_id]
-
-        bounds_max = [4*scale]*x.shape[0]
-        loc = 0
-        if self.training:
-            s_x, s_y, weights = spatial_filter(x, y, sigma=scale, rep = self.rep, prob_dithering=self.sample_as_per_distribution)
-            s_x = (torch.clip(x + torch.from_numpy(s_x), 0, self.WIDTH-1).to(self.camtoworlds.device)).to(torch.float32)
-            s_y = (torch.clip(y + torch.from_numpy(s_y), 0, self.HEIGHT-1).to(self.camtoworlds.device)).to(torch.float32)
-            weights = torch.Tensor(weights).to(self.camtoworlds.device)
-
-        elif self.testing:
-            s_x, s_y, weights = spatial_filter(x, y, sigma=scale, rep = self.rep, prob_dithering=self.sample_as_per_distribution)
-            s_x = (torch.clip(x + torch.from_numpy(s_x), 0, self.WIDTH-1).to(self.camtoworlds.device)).to(torch.float32)
-            s_y = (torch.clip(y + torch.from_numpy(s_y), 0, self.HEIGHT-1).to(self.camtoworlds.device)).to(torch.float32)
-            weights = torch.Tensor(weights).to(self.camtoworlds.device)
-        else: 
-            s_x = x
-            s_y = y
-
-
-
-        camera_dirs = self.K(s_x, s_y)
-
-        directions = (camera_dirs[:, None, :] * c2w[:, :3, :3]).sum(dim=-1)
-        origins = torch.broadcast_to(c2w[:, :3, -1], directions.shape)
-        viewdirs = directions / torch.linalg.norm(
-            directions, dim=-1, keepdims=True
-        )
-
-        if self.training:
-            origins = torch.reshape(origins, (-1, 3))
-            viewdirs = torch.reshape(viewdirs, (-1, 3))
-            # here
-            rgba = torch.reshape(rgba, (-1,self.n_bins*3))
-        elif self.testing:
-            origins = torch.reshape(origins, (-1, 3))
-            viewdirs = torch.reshape(viewdirs, (-1, 3))
-            # here
-            if self.have_images:
-                rgba = torch.reshape(rgba, (-1,self.n_bins*3))
-
-        elif self.have_images:
-            origins = torch.reshape(origins, (self.HEIGHT, self.WIDTH, 3))
-            viewdirs = torch.reshape(viewdirs, (self.HEIGHT, self.WIDTH, 3))
-            rgba = torch.reshape(rgba, (self.HEIGHT, self.WIDTH, self.n_bins * 3))
-        else:
-            origins = torch.reshape(origins, (self.HEIGHT, self.WIDTH, 3))
-            viewdirs = torch.reshape(viewdirs, (self.HEIGHT, self.WIDTH, 3))
-            rgba = None
-
-        rays = Rays(origins=origins, viewdirs=viewdirs)
-        if self.training or self.testing:
-            return {
-            "rgba": rgba,  # [h, w, 4] or [num_rays, 4]
-            "rays": rays,  # [h, w, 3] or [num_rays, 3]
-            "weights":weights
-        }
-
-        return {
-            "rgba": rgba,  # [h, w, 4] or [num_rays, 4]
-            "rays": rays,  # [h, w, 3] or [num_rays, 3]
-        }
-
-
-
-
-
-class LearnRays(torch.nn.Module):
-    def __init__(self, rays, device ="cuda:0", img_shape = (256, 256)):
-        """
-        :param num_cams:
-        :param learn_R:  True/False
-        :param learn_t:  True/False
-        :param init_c2w: (N, 4, 4) torch tensor
-        """
-        super(LearnRays, self).__init__()
-        self.device = device
-        self.init_c2w = None
-        self.img_shape = img_shape
-
-        x = np.arange(32, 480)
-        X, Y = np.meshgrid(x, x)
-
-        tar_x = np.arange(0, 512)
-        tar_X, tar_Y = np.meshgrid(tar_x, tar_x)
-        # rays = rays.detach().cpu().numpy()
-
-        ray_x = scipy.interpolate.interpn((x, x), rays[32:-32, 32:-32, 0].transpose(1, 0), np.stack([tar_X, tar_Y], axis=-1).squeeze().flatten(), bounds_error = False, fill_value=None).reshape(512, 512)
-        ray_y = scipy.interpolate.interpn((x, x), rays[32:-32, 32:-32, 1].transpose(1, 0), np.stack([tar_X, tar_Y], axis=-1).squeeze().flatten(), bounds_error = False, fill_value=None).reshape(512, 512)
-        ray_z = scipy.interpolate.interpn((x, x), rays[32:-32, 32:-32, 2].transpose(1, 0), np.stack([tar_X, tar_Y], axis=-1).squeeze().flatten(), bounds_error = False, fill_value=None).reshape(512, 512)
-
-        rays = torch.from_numpy(np.stack([ray_x, ray_y, ray_z], axis=-1)).to(self.device)
-
-        quotient = rays.shape[1]//img_shape[0]
-        times_downsample = int(np.log2(quotient))
-    
-        for i in range(times_downsample):
-            rays = (rays[1::2, ::2] + rays[::2, ::2] + rays[1::2, 1::2] + rays[::2, 1::2])/4
-
-        rays = rays/torch.linalg.norm(rays, dim=-1, keepdims=True)
-        self.rays = rays
-        # self.rays = torch.nn.Parameter(rays, requires_grad=learn_rays)    
-
-    def forward(self, x0, y0):
-        """input coord = (n, 2)
-        rays = (512, 512, 3)
-        """
-        rays = self.rays
-        x1, y1 = torch.floor(x0.float()), torch.floor(y0.float())
-        x2, y2 = x1+1, y1+1
-        """
-        Perform bilinear interpolation to estimate the value of the function f(x, y)
-        at the continuous point (x0, y0), given that f is known at integer values of x, y.
-        """
-        # if (y1>self.img_shape[0]-1).any() or (x1>self.img_shape[0]-1).any():
-        #     print("hello")
-        x1, y1 = torch.clip(x1, 0, self.img_shape[0]-1), torch.clip(y1, 0, self.img_shape[0]-1)
-
-        # x2, y2 = torch.clip(x2, 0, self.img_shape[0]-1), torch.clip(y2, 0, self.img_shape[0]-1)
-
-        # Compute the weights for the interpolation
-        wx1 = ((x2 - x0) / (x2 - x1 + 1e-8))[:, None]
-        wx2 = ((x0 - x1) / (x2 - x1 + 1e-8))[:, None]
-        wy1 = ((y2 - y0) / (y2 - y1 + 1e-8))[:, None]
-        wy2 = ((y0 - y1) / (y2 - y1 + 1e-8))[:, None]
-
-        x1, y1, x2, y2 = x1.long(), y1.long(), x2.long(), y2.long()
-        x2, y2 = torch.clip(x2, 0, self.img_shape[0] - 1), torch.clip(y2, 0, self.img_shape[0] - 1)
-
-        # Compute the interpolated value of f(x, y) at (x0, y0)
-        f_interp = wx1 * wy1 * rays[y1, x1] + \
-                wx1 * wy2 * rays[y2, x1] + \
-                wx2 * wy1 * rays[y1, x2] + \
-                wx2 * wy2 * rays[y2, x2]
-
-        f_interp = f_interp/torch.linalg.norm(f_interp, dim=-1, keepdims=True) 
-        return f_interp.float()
-
-
-def spatial_filter(x, y, sigma, rep, prob_dithering=True):
-    pdf_fn = lambda x: np.exp(-x/(2*sigma**2)) - np.exp(-16)
-    if prob_dithering:
-        bounds_max = [4*sigma]*x.shape[0]
-        loc = 0
-        s_x = scipy.stats.truncnorm.rvs((-np.array(bounds_max)-loc)/sigma, (np.array(bounds_max)-loc)/sigma, loc=loc, scale=sigma)
-        s_y = scipy.stats.truncnorm.rvs((-np.array(bounds_max)-loc)/sigma, (np.array(bounds_max)-loc)/sigma, loc=loc, scale=sigma)
-        weights = np.ones_like(s_x)*1/rep
-    
-    else:
-        s_x = np.random.uniform(low=-4*sigma, high=4*sigma, size=(rep, x.shape[0]//rep))
-        s_y = np.random.uniform(low=-4*sigma, high=4*sigma, size=(rep, x.shape[0]//rep))
-        dists = (s_x**2 + s_y**2)
-        weights = pdf_fn(dists)
-        weights = weights/weights.sum(0)[None, :]
-        s_x = s_x.flatten()
-        s_y = s_y.flatten()
-        weights = weights.flatten()
-    
-    return s_x, s_y, weights

codes/reconstruction/transientnerf/loaders/loader_captured_ours.py

@@ -1,680 +0,0 @@
-import json
-import os
-from typing import Sequence, Tuple
-
-# import h5py
-import numpy as np
-import scipy
-import torch
-import torch.nn.functional as F
-from tqdm import tqdm
-
-from .utils import Rays
-
-
-C = 299792458.0
-
-
-def _normalize_index(idx: torch.Tensor, size: int) -> torch.Tensor:
-    if size <= 1:
-        return torch.zeros_like(idx)
-    return 2.0 * idx / float(size - 1) - 1.0
-
-
-def _load_numpy_coo_npz(npz_path: str) -> np.ndarray:
-    pack = np.load(npz_path, allow_pickle=False)
-    try:
-        if "format" not in pack:
-            raise ValueError("missing 'format' key in npz")
-        fmt = str(np.asarray(pack["format"]).item())
-        if fmt != "coo_numpy":
-            raise ValueError(f"unsupported npz format tag: {fmt}")
-
-        shape = tuple(np.asarray(pack["shape"], dtype=np.int64).tolist())
-        row = np.asarray(pack["row"], dtype=np.int64)
-        col = np.asarray(pack["col"], dtype=np.int64)
-        data = np.asarray(pack["data"])
-
-        dense = np.zeros(shape, dtype=data.dtype)
-        np.add.at(dense, (row, col), data)
-        return dense
-    finally:
-        pack.close()
-
-
-def _load_histogram_2d(path: str, dtype=np.float32) -> np.ndarray:
-    ext = os.path.splitext(path)[1].lower()
-    if ext == ".txt":
-        arr = np.loadtxt(path, dtype=dtype)
-    elif ext == ".npz":
-        try:
-            from scipy import sparse  # type: ignore
-
-            arr = sparse.load_npz(path).toarray()
-        except Exception:
-            arr = _load_numpy_coo_npz(path)
-            if dtype is not None:
-                arr = np.asarray(arr, dtype=dtype)
-    else:
-        raise ValueError(f"unsupported histogram extension for 2D loader: {ext}")
-
-    arr = np.asarray(arr, dtype=dtype)
-    if arr.ndim == 1:
-        arr = arr.reshape(1, -1)
-    return arr
-
-
-def _reshape_histogram_to_hwt(arr: np.ndarray, hw: Tuple[int, int]) -> torch.Tensor:
-    h, w = int(hw[0]), int(hw[1])
-    if arr.ndim == 3:
-        if arr.shape[0] == h and arr.shape[1] == w:
-            out = arr
-        elif arr.shape[0] == w and arr.shape[1] == h:
-            out = arr.transpose(1, 0, 2)
-        else:
-            raise ValueError(f"3D histogram shape {arr.shape} incompatible with target ({h}, {w}, T)")
-        return torch.from_numpy(np.asarray(out, dtype=np.float32))
-
-    if arr.ndim != 2:
-        raise ValueError(f"expected 2D/3D histogram array, got shape={arr.shape}")
-
-    if arr.shape[0] == h * w:
-        out = arr.reshape(h, w, arr.shape[1])
-    elif arr.shape[1] == h * w:
-        out = arr.T.reshape(h, w, arr.shape[0])
-    else:
-        raise ValueError(
-            f"2D histogram shape {arr.shape} does not match H*W={h*w}; "
-            "expected [H*W, bins] or [bins, H*W]."
-        )
-    return torch.from_numpy(np.asarray(out, dtype=np.float32))
-
-
-def _load_valid_mask_from_offset(
-    offset_path: str,
-    source_hw: Tuple[int, int],
-    target_hw: Tuple[int, int],
-    invalid_gt: float = 10.0,
-) -> torch.Tensor:
-    ext = os.path.splitext(offset_path)[1].lower()
-    if ext == ".npy":
-        arr = np.load(offset_path).astype(np.float32)
-    else:
-        arr = np.loadtxt(offset_path, dtype=np.float32)
-    arr = np.asarray(arr, dtype=np.float32).squeeze()
-
-    src_h, src_w = int(source_hw[0]), int(source_hw[1])
-    if arr.ndim == 1:
-        if arr.size != src_h * src_w:
-            raise ValueError(
-                f"offset map length {arr.size} does not match source H*W={src_h*src_w}"
-            )
-        arr = arr.reshape(src_h, src_w)
-    elif arr.ndim == 2:
-        if arr.shape == (src_h, src_w):
-            pass
-        elif arr.shape == (src_w, src_h):
-            arr = arr.T
-        elif arr.size == src_h * src_w:
-            arr = arr.reshape(src_h, src_w)
-        else:
-            raise ValueError(
-                f"offset map shape {arr.shape} incompatible with source shape ({src_h}, {src_w})"
-            )
-    else:
-        raise ValueError(f"offset map must be 1D/2D, got shape={arr.shape}")
-
-    valid = (arr <= float(invalid_gt)).astype(np.float32)
-    valid_t = torch.from_numpy(valid)[None, None, ...]
-
-    dst_h, dst_w = int(target_hw[0]), int(target_hw[1])
-    if (src_h, src_w) != (dst_h, dst_w):
-        valid_t = F.interpolate(
-            valid_t,
-            size=(dst_h, dst_w),
-            mode="nearest",
-        )
-    return valid_t.squeeze(0).squeeze(0) > 0.5
-
-
-def _load_measurement_histogram(path: str, hw: Tuple[int, int]) -> torch.Tensor:
-    ext = os.path.splitext(path)[1].lower()
-    if ext in (".txt", ".npz"):
-        arr = _load_histogram_2d(path, dtype=np.float32)
-        hist = _reshape_histogram_to_hwt(arr, hw)
-    elif ext == ".pt":
-        raw = torch.load(path, map_location="cpu")
-        if not isinstance(raw, torch.Tensor):
-            raise ValueError(f".pt file must contain a tensor: {path}")
-        hist = raw.to_dense() if raw.is_sparse else raw
-        hist = hist.to(torch.float32).cpu()
-        if hist.ndim == 2:
-            hist = _reshape_histogram_to_hwt(hist.numpy(), hw)
-        elif hist.ndim == 3:
-            pass
-        else:
-            raise ValueError(f"unsupported tensor shape in {path}: {tuple(hist.shape)}")
-    # elif ext in (".h5", ".hdf5"):
-    #     with h5py.File(path, "r") as f:
-    #         if "data" not in f:
-    #             raise ValueError(f"h5 file missing key 'data': {path}")
-    #         arr = np.asarray(f["data"])
-    #     hist = _reshape_histogram_to_hwt(arr, hw)
-    else:
-        raise ValueError(f"unsupported measurement extension: {ext}")
-
-    if hist.ndim == 4 and hist.shape[-1] == 1:
-        hist = hist[..., 0]
-    if hist.ndim == 4 and hist.shape[-1] == 3:
-        hist = hist[..., 0]
-    if hist.ndim != 3:
-        raise ValueError(f"expected histogram shape [H,W,T], got {tuple(hist.shape)} from {path}")
-    return hist
-
-
-def _parse_shift_for_grid(shift, hw: Tuple[int, int]):
-    h, w = int(hw[0]), int(hw[1])
-    arr = np.asarray(shift, dtype=np.float32)
-    if arr.ndim == 0:
-        return float(arr.item()), None
-
-    arr = arr.squeeze()
-    if arr.ndim == 0 or arr.size == 1:
-        return float(arr.reshape(-1)[0]), None
-
-    if arr.ndim == 1 and arr.size == h * w:
-        return 0.0, torch.from_numpy(arr.reshape(h, w))
-
-    if arr.ndim == 2:
-        shift_map = torch.from_numpy(arr.astype(np.float32))
-        if tuple(shift_map.shape) != (h, w):
-            shift_map = F.interpolate(
-                shift_map[None, None, ...],
-                size=(h, w),
-                mode="bilinear",
-                align_corners=True,
-            ).squeeze(0).squeeze(0)
-        return 0.0, shift_map
-
-    return float(arr.reshape(-1)[0]), None
-
-
-def _build_shift_grid(
-    hw: Tuple[int, int],
-    n_bins: int,
-    shift,
-    bin_width_s: float,
-    device: str = "cpu",
-) -> torch.Tensor:
-    h, w = int(hw[0]), int(hw[1])
-    exposure_time = C * float(bin_width_s)
-    shift_scalar, shift_map = _parse_shift_for_grid(shift, hw)
-
-    z = torch.arange(n_bins, device=device, dtype=torch.float32)[:, None, None]
-    z = z * exposure_time / 2.0
-    if shift_map is not None:
-        z = z - shift_map.to(device)[None, ...]
-    else:
-        z = z - float(shift_scalar)
-    z = z * 2.0 / exposure_time
-    z = _normalize_index(z, n_bins)
-
-    x = _normalize_index(torch.arange(w, device=device, dtype=torch.float32), w)
-    y = _normalize_index(torch.arange(h, device=device, dtype=torch.float32), h)
-
-    x = x[None, None, :].expand(n_bins, h, w)
-    y = y[None, :, None].expand(n_bins, h, w)
-    z = z.expand(n_bins, h, w)
-
-    # grid_sample 5D grid order is (x, y, z) for input shaped [N,C,D,H,W].
-    grid = torch.stack((x, y, z), dim=-1)[None, ...]
-    return grid
-
-
-def _apply_shift(hist: torch.Tensor, shift, bin_width_s: float) -> torch.Tensor:
-    h, w, t = hist.shape
-    grid = _build_shift_grid((h, w), t, shift, bin_width_s, device=hist.device)
-    # [H, W, T] -> [N=1, C=1, D=T, H, W]
-    hist_dhw = hist.permute(2, 0, 1)[None, None, ...]
-    shifted = F.grid_sample(hist_dhw, grid, align_corners=True)
-    # back to [H, W, T]
-    return shifted.squeeze(0).squeeze(0).permute(1, 2, 0)
-
-
-def _resize_hist_spatial(hist: torch.Tensor, target_hw: Tuple[int, int]) -> torch.Tensor:
-    target_h, target_w = int(target_hw[0]), int(target_hw[1])
-    h, w, _ = hist.shape
-    if (h, w) == (target_h, target_w):
-        return hist
-    # [H,W,T] -> [1,T,H,W] for spatial resize only.
-    hist_chw = hist.permute(2, 0, 1)[None, ...]
-    resized = F.interpolate(hist_chw, size=(target_h, target_w), mode="area")
-    return resized.squeeze(0).permute(1, 2, 0)
-
-
-def _resolve_measurement_path(
-    data_dir: str,
-    split: str,
-    frame_file_path: str,
-    measurement_root: str = None,
-    data_exts: Sequence[str] = (".npz", ".txt", ".pt", ".h5", ".hdf5"),
-) -> str:
-    raw = str(frame_file_path)
-    if os.path.isabs(raw) and os.path.isfile(raw):
-        return raw
-
-    rel = raw.replace("\\", "/").lstrip("./")
-    base = os.path.basename(rel)
-    stem, ext = os.path.splitext(base)
-    rel_stem = os.path.splitext(rel)[0]
-
-    roots = []
-    if measurement_root:
-        roots.extend([measurement_root, os.path.join(measurement_root, split)])
-    roots.extend([data_dir, os.path.join(data_dir, split)])
-
-    seen_roots = set()
-    unique_roots = []
-    for r in roots:
-        rr = os.path.normpath(r)
-        if rr not in seen_roots:
-            unique_roots.append(rr)
-            seen_roots.add(rr)
-
-    # Prefer exact path if extension already exists.
-    if ext:
-        for root in unique_roots:
-            for rel_name in (rel, base):
-                cand = os.path.normpath(os.path.join(root, rel_name))
-                if os.path.isfile(cand):
-                    return cand
-
-    # Then resolve by stem and supported extensions.
-    for root in unique_roots:
-        for data_ext in data_exts:
-            for rel_name in (rel_stem + data_ext, stem + data_ext):
-                cand = os.path.normpath(os.path.join(root, rel_name))
-                if os.path.isfile(cand):
-                    return cand
-
-    raise FileNotFoundError(
-        f"Cannot resolve measurement file for frame '{frame_file_path}'. "
-        f"Searched roots={unique_roots}, exts={tuple(data_exts)}."
-    )
-
-
-def _load_renderings_transient_real_ours(
-    root_fp: str,
-    split: str,
-    have_images=True,
-    img_shape=(256, 256),
-    source_img_shape=None,
-    n_bins=4096,
-    shift=0,
-    bin_width_s=4e-12,
-    measurement_root=None,
-    data_exts=(".npz", ".txt", ".pt", ".h5", ".hdf5"),
-):
-    data_dir = root_fp
-    with open(os.path.join(data_dir, f"transforms_{split}.json"), "r", encoding="utf-8") as fp:
-        meta = json.load(fp)
-
-    images = []
-    camtoworlds = []
-
-    if have_images:
-        tqdm.write("Loading data")
-        reshape_hw = tuple(source_img_shape) if source_img_shape is not None else tuple(img_shape)
-        for i in tqdm(range(len(meta["frames"]))):
-            frame = meta["frames"][i]
-            file_key = frame.get("file_path", frame.get("filepath"))
-            if file_key is None:
-                raise KeyError("Each frame in transforms json must contain 'file_path' or 'filepath'.")
-            measurement_path = _resolve_measurement_path(
-                data_dir=data_dir,
-                split=split,
-                frame_file_path=file_key,
-                measurement_root=measurement_root,
-                data_exts=data_exts,
-            )
-
-            hist = _load_measurement_histogram(measurement_path, reshape_hw).to(torch.float32).cpu()
-            hist = torch.clip(hist, min=0.0)
-            hist = _apply_shift(hist, shift=shift, bin_width_s=bin_width_s)
-
-            if hist.shape[-1] != int(n_bins):
-                raise ValueError(
-                    f"Histogram bin count mismatch for '{measurement_path}': "
-                    f"loaded {hist.shape[-1]} vs config n_bins={n_bins}. "
-                    "This pipeline does not truncate or adjacent-bin average."
-                )
-
-            hist = _resize_hist_spatial(hist, img_shape)
-            hist_rgb = hist[..., None].repeat(1, 1, 1, 3)
-
-            camtoworlds.append(frame["transform_matrix"])
-            images.append(hist_rgb)
-
-        images = torch.stack(images, axis=0)
-        max_value = torch.max(images).clamp_min(1e-8)
-        images = images / max_value
-        camtoworlds = np.stack(camtoworlds, axis=0)
-    else:
-        for frame in meta["frames"]:
-            camtoworlds.append(frame["transform_matrix"])
-        camtoworlds = np.stack(camtoworlds, axis=0)
-        max_value = torch.tensor(1.0)
-
-    return images, camtoworlds, max_value
-
-
-class SubjectLoaderTransientRealOurs(torch.utils.data.Dataset):
-    """Captured-data loader for custom txt/npz/pt histograms without bin truncation/averaging."""
-
-    SPLITS = ["train", "val", "trainval", "test"]
-    NEAR, FAR = 0, 6
-    OPENGL_CAMERA = True
-
-    def __init__(
-        self,
-        subject_id: str,
-        root_fp: str,
-        split: str,
-        color_bkgd_aug: str = "black",
-        num_rays: int = None,
-        near: float = None,
-        far: float = None,
-        batch_over_images: bool = True,
-        have_images=True,
-        img_shape=(256, 256),
-        source_img_shape=None,
-        n_bins=10000,
-        rfilter_sigma=0.15,
-        sample_as_per_distribution=True,
-        shift=0.0,
-        testing=False,
-        bin_width_s=4e-12,
-        measurement_root=None,
-        data_exts=(".npz", ".txt", ".pt", ".h5", ".hdf5"),
-        invalid_mask_path=None,
-        invalid_mask_invalid_gt=10.0,
-    ):
-        super().__init__()
-        assert color_bkgd_aug in ["white", "black", "random"]
-        self.sample_as_per_distribution = sample_as_per_distribution
-        self.rfilter_sigma = rfilter_sigma
-        self.HEIGHT, self.WIDTH = int(img_shape[0]), int(img_shape[1])
-        self.split = split
-        self.testing = testing
-        self.num_rays = num_rays
-        self.near = self.NEAR if near is None else near
-        self.far = self.FAR if far is None else far
-        self.training = (num_rays is not None) and (split in ["train", "trainval"])
-        self.shift = shift
-        self.rep = 1
-        self.color_bkgd_aug = color_bkgd_aug
-        self.batch_over_images = batch_over_images
-        self.have_images = have_images
-        self.n_bins = int(n_bins)
-        self.bin_width_s = float(bin_width_s)
-        self.measurement_root = measurement_root
-        self.data_exts = tuple(data_exts)
-        self.source_img_shape = tuple(source_img_shape) if source_img_shape is not None else None
-        self.invalid_mask_path = invalid_mask_path
-        self.invalid_mask_invalid_gt = float(invalid_mask_invalid_gt)
-
-        if have_images:
-            self.images, self.camtoworlds, self.max = _load_renderings_transient_real_ours(
-                root_fp=root_fp,
-                split=split,
-                n_bins=self.n_bins,
-                shift=shift,
-                img_shape=(self.HEIGHT, self.WIDTH),
-                source_img_shape=self.source_img_shape,
-                bin_width_s=self.bin_width_s,
-                measurement_root=self.measurement_root,
-                data_exts=self.data_exts,
-            )
-            self.images = self.images.to(torch.float32)
-            assert self.images.shape[1:3] == (self.HEIGHT, self.WIDTH)
-        else:
-            raise ValueError("have_images=False is not supported in SubjectLoaderTransientRealOurs.")
-
-        self.camtoworlds = torch.from_numpy(self.camtoworlds).to(torch.float32)
-        if self.invalid_mask_path:
-            source_hw = (
-                tuple(self.source_img_shape)
-                if self.source_img_shape is not None
-                else (self.HEIGHT, self.WIDTH)
-            )
-            self.valid_mask = _load_valid_mask_from_offset(
-                self.invalid_mask_path,
-                source_hw=source_hw,
-                target_hw=(self.HEIGHT, self.WIDTH),
-                invalid_gt=self.invalid_mask_invalid_gt,
-            ).to(torch.bool)
-        else:
-            self.valid_mask = torch.ones((self.HEIGHT, self.WIDTH), dtype=torch.bool)
-
-    def __len__(self):
-        return len(self.camtoworlds)
-
-    def __getitem__(self, index):
-        data = self.fetch_data(index)
-        data = self.preprocess(data)
-        return data
-
-    def preprocess(self, data):
-        rgba, rays = data["rgba"], data["rays"]
-
-        if rgba is not None:
-            pixels = rgba.to(self.camtoworlds.device)
-        else:
-            pixels = rgba
-
-        if self.color_bkgd_aug == "random":
-            color_bkgd = torch.rand(3, device=self.camtoworlds.device)
-        elif self.color_bkgd_aug == "white":
-            color_bkgd = torch.ones(3, device=self.camtoworlds.device)
-        else:
-            color_bkgd = torch.zeros(3, device=self.camtoworlds.device)
-
-        return {
-            "pixels": pixels,
-            "rays": rays,
-            "color_bkgd": color_bkgd,
-            **{k: v for k, v in data.items() if k not in ["rgba", "rays"]},
-        }
-
-    def update_num_rays(self, num_rays):
-        self.num_rays = num_rays
-
-    def fetch_data(self, index, rep=None, num_rays=None):
-        if num_rays is None:
-            num_rays = self.num_rays
-        if rep is None:
-            rep = self.rep
-
-        if self.training:
-            if self.batch_over_images:
-                image_id = torch.randint(
-                    0,
-                    len(self.images),
-                    size=(num_rays,),
-                    device=self.images.device,
-                )
-            else:
-                image_id = [index]
-            x = torch.randint(0, self.WIDTH, size=(num_rays,), device="cpu")
-            y = torch.randint(0, self.HEIGHT, size=(num_rays,), device="cpu")
-            x = x.repeat(rep)
-            y = y.repeat(rep)
-            image_id = image_id.repeat(rep)
-            rgba = self.images[image_id, y, x]
-        elif self.testing:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device="cpu"),
-                torch.arange(self.HEIGHT, device="cpu"),
-                indexing="xy",
-            )
-            x = x.flatten().repeat(rep)
-            y = y.flatten().repeat(rep)
-            rgba = self.images[image_id, y, x] if self.have_images else None
-        else:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device=self.camtoworlds.device),
-                torch.arange(self.HEIGHT, device=self.camtoworlds.device),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-            rgba = self.images[image_id, y, x] if self.have_images else None
-
-        x_cpu_long = x.detach().cpu().long()
-        y_cpu_long = y.detach().cpu().long()
-        valid_mask = self.valid_mask[y_cpu_long, x_cpu_long]
-
-        c2w = self.camtoworlds[image_id]
-        scale = self.rfilter_sigma
-
-        if self.training or self.testing:
-            s_x, s_y, weights = spatial_filter(
-                x,
-                y,
-                sigma=scale,
-                rep=self.rep,
-                prob_dithering=self.sample_as_per_distribution,
-            )
-            s_x = torch.clip(x + torch.from_numpy(s_x), 0, self.WIDTH - 1).to(self.camtoworlds.device).to(torch.float32)
-            s_y = torch.clip(y + torch.from_numpy(s_y), 0, self.HEIGHT - 1).to(self.camtoworlds.device).to(torch.float32)
-            weights = torch.tensor(weights, device=self.camtoworlds.device, dtype=torch.float32)
-        else:
-            s_x = x
-            s_y = y
-            weights = None
-
-        camera_dirs = self.K(s_x, s_y)
-
-        directions = (camera_dirs[:, None, :] * c2w[:, :3, :3]).sum(dim=-1)
-        origins = torch.broadcast_to(c2w[:, :3, -1], directions.shape)
-        viewdirs = directions / torch.linalg.norm(directions, dim=-1, keepdims=True)
-
-        if self.training:
-            origins = torch.reshape(origins, (-1, 3))
-            viewdirs = torch.reshape(viewdirs, (-1, 3))
-            rgba = torch.reshape(rgba, (-1, self.n_bins * 3))
-            valid_mask = torch.reshape(valid_mask, (-1,))
-        elif self.testing:
-            origins = torch.reshape(origins, (-1, 3))
-            viewdirs = torch.reshape(viewdirs, (-1, 3))
-            if self.have_images:
-                rgba = torch.reshape(rgba, (-1, self.n_bins * 3))
-            valid_mask = torch.reshape(valid_mask, (-1,))
-        elif self.have_images:
-            origins = torch.reshape(origins, (self.HEIGHT, self.WIDTH, 3))
-            viewdirs = torch.reshape(viewdirs, (self.HEIGHT, self.WIDTH, 3))
-            rgba = torch.reshape(rgba, (self.HEIGHT, self.WIDTH, self.n_bins * 3))
-            valid_mask = torch.reshape(valid_mask, (self.HEIGHT, self.WIDTH))
-        else:
-            origins = torch.reshape(origins, (self.HEIGHT, self.WIDTH, 3))
-            viewdirs = torch.reshape(viewdirs, (self.HEIGHT, self.WIDTH, 3))
-            rgba = None
-            valid_mask = torch.reshape(valid_mask, (self.HEIGHT, self.WIDTH))
-
-        rays = Rays(origins=origins, viewdirs=viewdirs)
-        if self.training or self.testing:
-            return {"rgba": rgba, "rays": rays, "weights": weights, "valid_mask": valid_mask}
-        return {"rgba": rgba, "rays": rays, "valid_mask": valid_mask}
-
-
-class LearnRays(torch.nn.Module):
-    """Interpolation-based ray lookup from per-pixel ray table (H,W,3)."""
-
-    def __init__(self, rays, device="cuda:0", img_shape=(256, 256)):
-        super().__init__()
-        self.device = device
-        self.img_shape = (int(img_shape[0]), int(img_shape[1]))
-        self.height = self.img_shape[0]
-        self.width = self.img_shape[1]
-
-        rays = np.asarray(rays, dtype=np.float32)
-        if rays.ndim != 3 or rays.shape[-1] != 3:
-            raise ValueError(f"rays must be [H,W,3], got shape={rays.shape}")
-
-        rays_t = torch.from_numpy(rays).to(self.device)
-        if tuple(rays_t.shape[:2]) != self.img_shape:
-            rays_t = F.interpolate(
-                rays_t.permute(2, 0, 1)[None, ...],
-                size=self.img_shape,
-                mode="bilinear",
-                align_corners=True,
-            ).squeeze(0).permute(1, 2, 0)
-
-        rays_t = rays_t / torch.linalg.norm(rays_t, dim=-1, keepdims=True).clamp_min(1e-8)
-        self.rays = rays_t
-
-    def forward(self, x0, y0):
-        rays = self.rays
-        x0 = x0.to(rays.device).float()
-        y0 = y0.to(rays.device).float()
-
-        x1 = torch.floor(x0)
-        y1 = torch.floor(y0)
-        x2 = x1 + 1
-        y2 = y1 + 1
-
-        x1 = torch.clip(x1, 0, self.width - 1)
-        y1 = torch.clip(y1, 0, self.height - 1)
-        x2 = torch.clip(x2, 0, self.width - 1)
-        y2 = torch.clip(y2, 0, self.height - 1)
-
-        wx2 = ((x0 - x1) / (x2 - x1 + 1e-8))[:, None]
-        wx1 = 1.0 - wx2
-        wy2 = ((y0 - y1) / (y2 - y1 + 1e-8))[:, None]
-        wy1 = 1.0 - wy2
-
-        x1 = x1.long()
-        y1 = y1.long()
-        x2 = x2.long()
-        y2 = y2.long()
-
-        out = (
-            wx1 * wy1 * rays[y1, x1]
-            + wx1 * wy2 * rays[y2, x1]
-            + wx2 * wy1 * rays[y1, x2]
-            + wx2 * wy2 * rays[y2, x2]
-        )
-        out = out / torch.linalg.norm(out, dim=-1, keepdims=True).clamp_min(1e-8)
-        return out.float()
-
-
-def spatial_filter(x, y, sigma, rep, prob_dithering=True):
-    pdf_fn = lambda z: np.exp(-z / (2 * sigma**2)) - np.exp(-16)
-    if prob_dithering:
-        bounds_max = [4 * sigma] * x.shape[0]
-        loc = 0
-        s_x = scipy.stats.truncnorm.rvs(
-            (-np.array(bounds_max) - loc) / sigma,
-            (np.array(bounds_max) - loc) / sigma,
-            loc=loc,
-            scale=sigma,
-        )
-        s_y = scipy.stats.truncnorm.rvs(
-            (-np.array(bounds_max) - loc) / sigma,
-            (np.array(bounds_max) - loc) / sigma,
-            loc=loc,
-            scale=sigma,
-        )
-        weights = np.ones_like(s_x) * 1 / rep
-    else:
-        s_x = np.random.uniform(low=-4 * sigma, high=4 * sigma, size=(rep, x.shape[0] // rep))
-        s_y = np.random.uniform(low=-4 * sigma, high=4 * sigma, size=(rep, x.shape[0] // rep))
-        dists = s_x**2 + s_y**2
-        weights = pdf_fn(dists)
-        weights = weights / weights.sum(0)[None, :]
-        s_x = s_x.flatten()
-        s_y = s_y.flatten()
-        weights = weights.flatten()
-    return s_x, s_y, weights

codes/reconstruction/transientnerf/loaders/loader_synthetic.py

@@ -1,453 +0,0 @@
-import collections
-import json
-import os
-
-import imageio.v2 as imageio
-import numpy as np
-import torch
-import torch.nn.functional as F
-import scipy
-import zipfile
-from .utils import Rays
-import sys
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from misc.dataset_utils import read_h5
-from tqdm import tqdm
-
-def _load_renderings(root_fp: str, subject_id: str, split: str, have_images=True, img_shape=(256, 256)):
-    """Load images from disk."""
-    # if not root_fp.startswith("/"):
-    #     # allow relative path. e.g., "./data/nerf_synthetic/"
-    #     root_fp = os.path.join(
-    #         os.path.dirname(os.path.abspath(__file__)),
-    #         "..",
-    #         "..",
-    #         root_fp,
-    #     )
-
-    data_dir = root_fp
-    with open(
-            os.path.join(data_dir, "transforms_{}.json".format(split)), "r"
-    ) as fp:
-        meta = json.load(fp)
-    images = []
-    camtoworlds = []
-
-    if have_images:
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            number = int(frame["file_path"].split("_")[-1])
-            fname = os.path.join(data_dir, f"{number:03d}" + ".png")
-
-            # fname = os.path.join(data_dir, frame["file_path"] + ".png")
-            rgba = imageio.imread(fname)
-            camtoworlds.append(frame["transform_matrix"])
-            images.append(rgba)
-
-        images = np.stack(images, axis=0)
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = images.shape[1:3]
-    else:
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            camtoworlds.append(frame["transform_matrix"])
-
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = img_shape
-
-    camera_angle_x = float(meta["camera_angle_x"])
-    focal = 0.5 * w / np.tan(0.5 * camera_angle_x)
-
-    return images, camtoworlds, focal
-
-
-def _load_renderings_transient(root_fp: str, subject_id: str, split: str, num_views= None, have_images=True, img_shape=(256, 256), gamma=False):
-    """Load images from disk."""
-    # if not root_fp.startswith("/"):
-    #     # allow relative path. e.g., "./data/nerf_synthetic/"
-    #     root_fp = os.path.join(
-    #         os.path.dirname(os.path.abspath(__file__)),
-    #         "..",
-    #         "..",
-    #         root_fp,
-    #     )
-
-    data_dir = root_fp
-    if split == "train": tname = f"train_v{num_views}"
-    else: tname = split
-
-    with open(
-            os.path.join(data_dir, "transforms_{}.json".format(tname)), "r"
-    ) as fp:
-        meta = json.load(fp)
-    images = []
-    camtoworlds = []
-
-    if have_images:
-        for i in tqdm(range(len(meta["frames"]))):
-            frame = meta["frames"][i]
-            number = int(frame["file_path"].split("_")[-1])
-
-            try:
-                files_dir = os.path.join(data_dir, split)
-                fname = os.path.join(files_dir, f"{split}_{number:03d}" + ".h5")
-                rgba = read_h5(fname)
-            except:     
-                try:
-                    files_dir = os.path.join(data_dir, "test")
-                    fname = os.path.join(files_dir, f"test_{number:03d}" + ".h5")
-                    rgba = read_h5(fname)
-                except:         
-                    try:
-                        files_dir = os.path.join(data_dir, "test")
-                        fname = os.path.join(files_dir, f"test_{number:03d}" + ".h5")
-                        archive = zipfile.ZipFile(f"{fname}.zip")
-                        file = archive.open(f"test_{number:03d}" + ".h5")
-                        rgba = read_h5(file)
-                        file.close()
-                    except:
-                        pass
-
-
-
-            rgba = rgba[..., :3]
-
-            if gamma:
-                print("using gamma")
-                rgba_sum = rgba.sum(-2)
-                rgba_sum_normalized = rgba_sum/rgba_sum.max()
-                rgba_sum_norm_gamma = rgba_sum_normalized**(1/2.2)
-                rgba = (rgba*rgba_sum_norm_gamma[..., None, :])/(rgba_sum[..., None, :]+1e-10)
-
-            camtoworlds.append(frame["transform_matrix"])
-            rgba = torch.clip(torch.Tensor(rgba), 0, None)
-            images.append(torch.Tensor(rgba))
-
-
-        images = torch.stack(images, axis=0)
-
-        if split == "test":
-            quotient = images.shape[1]//img_shape[0]
-            times_downsample = int(np.log2(quotient))
-        
-            for i in range(times_downsample):
-                images = (images[:, 1::2, ::2] + images[:, ::2, ::2] + images[:, 1::2, 1::2] + images[:, ::2, 1::2])/4
-
-
-        if not gamma:
-            #np.save(os.path.join(data_dir, "max.npy"), torch.max(images).numpy())
-            max = torch.max(images)
-            images /= torch.max(images)
-
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = images.shape[1:3]
-    else:
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            camtoworlds.append(frame["transform_matrix"])
-
-        camtoworlds = np.stack(camtoworlds, axis=0)
-
-        h, w = img_shape
-
-    camera_angle_x = float(meta["camera_angle_x"])
-    focal = 0.5 * w / np.tan(0.5 * camera_angle_x)
-
-    return images, camtoworlds, focal, max
-
-
-
-class SubjectLoaderTransient(torch.utils.data.Dataset):
-    """Single subject data loader for training and evaluation."""
-
-    SPLITS = ["train", "val", "trainval", "test"]
-
-    # WIDTH, HEIGHT = 64, 64
-    NEAR, FAR = 0, 6
-    OPENGL_CAMERA = True
-
-    def __init__(
-            self,
-            subject_id: str,
-            root_fp: str,
-            split: str,
-            color_bkgd_aug: str = "black",
-            num_rays: int = None,
-            near: float = None,
-            far: float = None,
-            batch_over_images: bool = True,
-            have_images=True,
-            img_shape=(256, 256),
-            n_bins=10000, 
-            testing=False, 
-            rfilter_sigma=0.3, 
-            scene=None, 
-            sample_as_per_distribution = True, 
-            gamma=False,
-            num_views = None
-    ):
-        super().__init__()
-        self.testing = testing 
-        # assert split in self.SPLITS, "%s" % split
-        assert color_bkgd_aug in ["white", "black", "random"]
-        self.sample_as_per_distribution = sample_as_per_distribution
-
-        self.HEIGHT, self.WIDTH = img_shape
-        self.split = split
-        self.num_rays = num_rays
-        self.near = self.NEAR if near is None else near
-        self.far = self.FAR if far is None else far
-        self.training = (num_rays is not None) and (
-                split in ["train", "trainval"]
-        )
-        self.rep = 0
-        self.color_bkgd_aug = color_bkgd_aug
-        self.batch_over_images = batch_over_images
-        self.have_images = have_images
-        self.rfilter_sigma = rfilter_sigma
-        self.n_bins = n_bins
-        if split == "trainval":
-            _images_train, _camtoworlds_train, _focal_train = _load_renderings_transient(
-                root_fp, subject_id, "train", gamma=gamma
-            )
-            _images_val, _camtoworlds_val, _focal_val = _load_renderings_transient(
-                root_fp, subject_id, "val", gamma=gamma
-            )
-            self.images = np.concatenate([_images_train, _images_val])
-            self.camtoworlds = np.concatenate(
-                [_camtoworlds_train, _camtoworlds_val]
-            )
-            self.focal = _focal_train
-            self.images = torch.from_numpy(self.images).to(torch.float32)
-
-            # ste for transient
-            self.images = torch.reshape(self.images, (-1, self.HEIGHT, self.WIDTH, self.n_bins*3))
-            # assert self.images.shape[1:3] == (self.HEIGHT, self.WIDTH)
-
-        elif have_images:
-            self.images, self.camtoworlds, self.focal, self.max = _load_renderings_transient(
-                root_fp, subject_id, split, gamma=gamma, img_shape=img_shape, num_views=num_views
-            )
-            self.images = self.images.to(torch.float32)
-            assert self.images.shape[1:3] == (self.HEIGHT, self.WIDTH)
-        else:
-            _, self.camtoworlds, self.focal = _load_renderings(
-                root_fp, subject_id, split, have_images=have_images, img_shape=img_shape, num_views=num_views
-            )
-
-        self.camtoworlds = torch.from_numpy(self.camtoworlds).to(torch.float32)
-        self.K = torch.tensor(
-            [
-                [self.focal, 0, self.WIDTH / 2.0],
-                [0, self.focal, self.HEIGHT / 2.0],
-                [0, 0, 1],
-            ],
-            dtype=torch.float32,
-        )  # (3, 3)
-
-    def __len__(self):
-        return len(self.camtoworlds)
-
-    @torch.no_grad()
-    def __getitem__(self, index):
-        data = self.fetch_data(index)
-        data = self.preprocess(data)
-        return data
-
-    def preprocess(self, data):
-        """Process the fetched / cached data with randomness."""
-        rgba, rays = data["rgba"], data["rays"]
-        # pixels, alpha = torch.split(rgba, [3, 1], dim=-1)
-        if rgba is not None:
-            pixels = rgba.to(self.camtoworlds.device)
-        else:
-            pixels = rgba
-
-        if self.color_bkgd_aug == "random":
-            color_bkgd = torch.rand(3, device=self.camtoworlds.device)
-        elif self.color_bkgd_aug == "white":
-            color_bkgd = torch.ones(3, device=self.camtoworlds.device)
-        elif self.color_bkgd_aug == "black":
-            color_bkgd = torch.zeros(3, device=self.camtoworlds.device)
-
-        # pixels = pixels * alpha + color_bkgd * (1.0 - alpha)
-        return {
-            "pixels": pixels,  # [n_rays, 3] or [h, w, 3]
-            "rays": rays,  # [n_rays,] or [h, w]
-            "color_bkgd": color_bkgd,  # [3,]
-            **{k: v for k, v in data.items() if k not in ["rgba", "rays"]},
-        }
-
-    def update_num_rays(self, num_rays):
-        self.num_rays = num_rays
-
-    def fetch_data(self, index, rep=None, num_rays=None):
-        """Fetch the data (it maybe cached for multiple batches)."""
-        if num_rays==None:
-            num_rays = self.num_rays
-        if rep==None:
-            rep = self.rep
-
-        if self.training:
-            if self.batch_over_images:
-                image_id = torch.randint(
-                    0,
-                    len(self.images),
-                    size=(num_rays,),
-                    device=self.images.device,
-                )
-            else:
-                image_id = [index]
-            x = torch.randint(
-                0, self.WIDTH, size=(num_rays,), device=self.images.device
-            )
-            y = torch.randint(
-                0, self.HEIGHT, size=(num_rays,), device=self.images.device
-            )
-            x = x.repeat(rep)
-            y = y.repeat(rep)
-            image_id = image_id.repeat(rep)
-
-
-            rgba = self.images[image_id, y, x]  # (num_rays, 4)
-
-        elif self.testing:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device="cpu"),
-                torch.arange(self.HEIGHT, device="cpu"),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-            x = x.repeat(rep)
-            y = y.repeat(rep)
-            # image_id = image_id.repeat(rep)
-            try:
-                rgba = self.images[image_id, y, x]  # (num_rays, 4)
-            except: rgba=None
-
-        elif self.have_images:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device=self.camtoworlds.device),
-                torch.arange(self.HEIGHT, device=self.camtoworlds.device),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-            rgba = self.images[image_id, y, x]  # (num_rays, 4)
-        else:
-            image_id = [index]
-            x, y = torch.meshgrid(
-                torch.arange(self.WIDTH, device=self.camtoworlds.device),
-                torch.arange(self.HEIGHT, device=self.camtoworlds.device),
-                indexing="xy",
-            )
-            x = x.flatten()
-            y = y.flatten()
-
-        # generate rays
-        
-        scale = self.rfilter_sigma
-        c2w = self.camtoworlds[image_id]  # (num_rays, 3, 4)
-        bounds_max = [4*scale]*x.shape[0]
-        loc = 0
-        if self.training:
-            s_x, s_y, weights = spatial_filter(x, y, sigma=scale, rep = self.rep, prob_dithering=self.sample_as_per_distribution)
-            s_x = (torch.clip(x + torch.from_numpy(s_x), 0, self.WIDTH).to(self.camtoworlds.device)).to(torch.float32)
-            s_y = (torch.clip(y + torch.from_numpy(s_y), 0, self.HEIGHT).to(self.camtoworlds.device)).to(torch.float32)
-            weights = torch.Tensor(weights).to(self.camtoworlds.device)
-            #s_x = x.to(self.camtoworlds.device).to(torch.float32)
-            #s_y = y.to(self.camtoworlds.device).to(torch.float32)
-
-        elif self.testing:
-            s_x, s_y, weights = spatial_filter(x, y, sigma=scale, rep = self.rep, prob_dithering=self.sample_as_per_distribution, normalize=False)
-            s_x = (torch.clip(x + torch.from_numpy(s_x), 0, self.WIDTH).to(self.camtoworlds.device)).to(torch.float32)
-            s_y = (torch.clip(y + torch.from_numpy(s_y), 0, self.HEIGHT).to(self.camtoworlds.device)).to(torch.float32)
-            weights = torch.Tensor(weights).to(self.camtoworlds.device)
-            #s_x = x.to(self.camtoworlds.device).to(torch.float32)
-            #s_y = y.to(self.camtoworlds.device).to(torch.float32)
-        else: 
-            s_x = x
-            s_y = y
-
-        camera_dirs = F.pad(
-            torch.stack(
-                [
-                    (s_x - self.K[0, 2] + 0.5) / self.K[0, 0],
-                    (s_y - self.K[1, 2] + 0.5)
-                    / self.K[1, 1]
-                    * (-1.0 if self.OPENGL_CAMERA else 1.0),
-                ],
-                dim=-1,
-            ),
-            (0, 1),
-            value=(-1.0 if self.OPENGL_CAMERA else 1.0),
-        )  
-
-        directions = (camera_dirs[:, None, :] * c2w[:, :3, :3]).sum(dim=-1)
-        origins = torch.broadcast_to(c2w[:, :3, -1], directions.shape)
-        viewdirs = directions / torch.linalg.norm(
-            directions, dim=-1, keepdims=True
-        )
-
-        if self.training:
-            origins = torch.reshape(origins, (-1, 3))
-            viewdirs = torch.reshape(viewdirs, (-1, 3))
-            # here
-            rgba = torch.reshape(rgba, (-1,self.n_bins*3))
-        elif self.testing:
-            origins = torch.reshape(origins, (-1, 3))
-            viewdirs = torch.reshape(viewdirs, (-1, 3))
-            # here
-            try: rgba = torch.reshape(rgba, (-1,self.n_bins*3))
-            except: rgba = None
-
-        elif self.have_images:
-            origins = torch.reshape(origins, (self.HEIGHT, self.WIDTH, 3))
-            viewdirs = torch.reshape(viewdirs, (self.HEIGHT, self.WIDTH, 3))
-            rgba = torch.reshape(rgba, (self.HEIGHT, self.WIDTH, self.n_bins * 3))
-        else:
-            origins = torch.reshape(origins, (self.HEIGHT, self.WIDTH, 3))
-            viewdirs = torch.reshape(viewdirs, (self.HEIGHT, self.WIDTH, 3))
-            rgba = None
-
-        rays = Rays(origins=origins, viewdirs=viewdirs)
-        if self.training or self.testing:
-            return {
-            "rgba": rgba,  # [h, w, 4] or [num_rays, 4]
-            "rays": rays,  # [h, w, 3] or [num_rays, 3]
-            "weights":weights
-        }
-
-        return {
-            "rgba": rgba,  # [h, w, 4] or [num_rays, 4]
-            "rays": rays,  # [h, w, 3] or [num_rays, 3]
-        }
-
-
-def spatial_filter(x, y, sigma, rep, prob_dithering=True, normalize=True):
-    pdf_fn = lambda x: np.exp(-x/(2*sigma**2)) - np.exp(-16)
-    if prob_dithering:
-        bounds_max = [4*sigma]*x.shape[0]
-        loc = 0
-        s_x = scipy.stats.truncnorm.rvs((-np.array(bounds_max)-loc)/sigma, (np.array(bounds_max)-loc)/sigma, loc=loc, scale=sigma)
-        s_y = scipy.stats.truncnorm.rvs((-np.array(bounds_max)-loc)/sigma, (np.array(bounds_max)-loc)/sigma, loc=loc, scale=sigma)
-        weights = np.ones_like(s_x)*1/rep
-    
-    else:
-        s_x = np.random.uniform(low=-4*sigma, high=4*sigma, size=(rep, x.shape[0]//rep))
-        s_y = np.random.uniform(low=-4*sigma, high=4*sigma, size=(rep, x.shape[0]//rep))
-        dists = (s_x**2 + s_y**2)
-        weights = pdf_fn(dists)
-        if normalize:
-            weights = weights/weights.sum(0)[None, :]
-        s_x = s_x.flatten()
-        s_y = s_y.flatten()
-        weights = weights.flatten()
-    
-    return s_x, s_y, weights

codes/reconstruction/transientnerf/loaders/utils.py

@@ -1,12 +0,0 @@
-"""
-Copyright (c) 2022 Ruilong Li, UC Berkeley.
-"""
-
-import collections
-
-Rays = collections.namedtuple("Rays", ("origins", "viewdirs"))
-
-
-def namedtuple_map(fn, tup):
-    """Apply `fn` to each element of `tup` and cast to `tup`'s namedtuple."""
-    return type(tup)(*(None if x is None else fn(x) for x in tup))

codes/reconstruction/transientnerf/misc/dataset_utils.py

@@ -1,169 +0,0 @@
-import os 
-import mat73 
-import torch 
-import numpy as np 
-import json 
-import h5py 
-
-def read_h5(path):
-    with h5py.File(path, 'r') as f:
-        frames = np.array(f['data'])
-    return frames
-
-def process_captured_data(files_path, savepath):
-    for file in os.listdir(files_path):
-        if file[-3:] == "mat" and (file[:-3]+"pt") not in os.listdir(savepath): 
-            filepath = os.path.join(files_path, file)
-            rgba = mat73.loadmat(filepath)["transient"].transpose(1, 2, 0)[..., :][..., None]
-            rgba = np.flip(np.flip(rgba, 0), 1)
-            for i in range(3):
-                rgba = (rgba[1::2, ::2] + rgba[::2, ::2] + rgba[1::2, 1::2] + rgba[::2, 1::2])/4
-            torch.save(rgba, os.path.join(savepath, file[:-3]+"pt"))
-
-def bundle_rays(pathToH5s, outputPath, trainJsonPath):
-    with open(trainJsonPath, "r") as fp:
-        meta = json.load(fp)
-        train_fnames = []
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            fname = frame["filepath"][:-2]+"h5"
-            train_fnames.append(fname)
-
-    frames = read_h5(os.path.join(pathToH5s, train_fnames[0]))
-    w = frames.shape[0]
-    h = frames.shape[1]
-    bins = frames.shape[2]
-    
-    x = np.linspace(0, h-1, h)
-    y = np.linspace(0, w-1, w)   
-    X, Y = np.meshgrid(x, y)
-
-    if len(frames.shape) == 4:
-        channels = 3
-    else:
-        channels = 1
-    num_train_files = len(train_fnames)
-    
-    data_array = np.zeros((w*h*num_train_files, bins, channels), dtype=np.float32)
-    x_array = np.zeros(w*h*num_train_files)
-    y_array = np.zeros(w*h*num_train_files)
-    file_prefix_array = np.zeros(w*h*num_train_files)
-
-    for ind, file in enumerate(train_fnames):
-        print("Opening: " + file)
-        frames = read_h5(os.path.join(pathToH5s, file))
-        frames = frames.reshape(-1, frames.shape[2], frames.shape[3])
-        
-        data_array[ind*w*h:(ind+1)*w*h] = frames[..., :3]
-        x_array[ind*w*h:(ind+1)*w*h] = X.flatten()
-        y_array[ind*w*h:(ind+1)*w*h] = Y.flatten()
-        file_prefix_array[ind*w*h:(ind+1)*w*h] = ind
-    
-    p = np.random.permutation(data_array.shape[0])
-    data_array = data_array[p]
-    x_array = x_array[p]
-    y_array = y_array[p]
-    file_prefix_array = file_prefix_array[p]
-
-
-    print("Outputting to files")
-    file = h5py.File(os.path.join(outputPath, "samples.h5"), 'w')
-    dataset = file.create_dataset(
-    "dataset", data_array.shape, dtype='f', data=data_array
-    )
-    file.close()
-
-    file = h5py.File(os.path.join(outputPath, "x.h5"), 'w')
-    dataset = file.create_dataset(
-        "dataset", x_array.shape, dtype='f', data=x_array
-    )
-    file.close()
-
-    file = h5py.File(os.path.join(outputPath, "y.h5"), 'w')
-    dataset = file.create_dataset(
-        "dataset", y_array.shape, dtype='f', data=y_array
-    )
-    file.close()
-    file = h5py.File(os.path.join(outputPath, "file_indices.h5"), 'w')
-    dataset = file.create_dataset(
-        "dataset", file_prefix_array.shape, dtype='f', data=file_prefix_array
-    )
-    file.close()
-
-
-def bundle_rays_cap(pathToH5s, outputPath, trainJsonPath):
-    with open(trainJsonPath, "r") as fp:
-        meta = json.load(fp)
-        train_fnames = []
-        for i in range(len(meta["frames"])):
-            frame = meta["frames"][i]
-            fname = frame["filepath"][:-2].split("/")[-1]+"mat"
-            train_fnames.append(fname)
-
-    # frames = read_h5_dataset(os.path.join(pathToH5s, train_fnames[0]))
-    frames = mat73.loadmat(os.path.join(pathToH5s, train_fnames[0]))["transient"].transpose(1, 2, 0)
-    w = frames.shape[0]
-    h = frames.shape[1]
-    # bins = frames.shape[2]
-    bins = 3000
-    
-    x = np.linspace(0, h-1, h)
-    y = np.linspace(0, w-1, w)   
-    X, Y = np.meshgrid(x, y)
-
-    # if len(frames.shape) == 4:
-    #     channels = 3
-    # else:
-    channels = 1
-    num_train_files = len(train_fnames)
-    
-    data_array = np.zeros((w*h*num_train_files, bins, channels), dtype=np.float32)
-    x_array = np.zeros(w*h*num_train_files)
-    y_array = np.zeros(w*h*num_train_files)
-    file_prefix_array = np.zeros(w*h*num_train_files)
-
-    for ind, file in enumerate(train_fnames):
-        print("Opening: " + file)
-        # frames = read_h5_dataset(os.path.join(pathToH5s, file))
-        frames = mat73.loadmat(os.path.join(pathToH5s, file))["transient"].transpose(1, 2, 0)
-        frames = frames.reshape(-1, frames.shape[2])
-        
-        data_array[ind*w*h:(ind+1)*w*h] = frames[..., :bins, None]
-        # del frames
-        x_array[ind*w*h:(ind+1)*w*h] = X.flatten()
-        y_array[ind*w*h:(ind+1)*w*h] = Y.flatten()
-        file_prefix_array[ind*w*h:(ind+1)*w*h] = ind
-    
-    p = np.random.permutation(data_array.shape[0])
-    data_array = data_array[p]
-    x_array = x_array[p]
-    y_array = y_array[p]
-    file_prefix_array = file_prefix_array[p]
-
-
-    print("Outputting to files")
-    file = h5py.File(os.path.join(outputPath, "samples.h5"), 'w')
-    dataset = file.create_dataset(
-    "dataset", data_array.shape, dtype='f', data=data_array
-    )
-    file.close()
-
-    file = h5py.File(os.path.join(outputPath, "x.h5"), 'w')
-    dataset = file.create_dataset(
-        "dataset", x_array.shape, dtype='f', data=x_array
-    )
-    file.close()
-
-    file = h5py.File(os.path.join(outputPath, "y.h5"), 'w')
-    dataset = file.create_dataset(
-        "dataset", y_array.shape, dtype='f', data=y_array
-    )
-    file.close()
-    file = h5py.File(os.path.join(outputPath, "file_indices.h5"), 'w')
-    dataset = file.create_dataset(
-        "dataset", file_prefix_array.shape, dtype='f', data=file_prefix_array
-    )
-    file.close()
-    
-if __name__=="__main__":
-    pass

codes/reconstruction/transientnerf/misc/download_dataset.py

@@ -1,67 +0,0 @@
-import subprocess
-import configargparse
-import os 
-
-def download_dataset(scenes):
-    link_dict = {
-        "bench":"https://www.dropbox.com/scl/fo/a7c6ej2zj5julibmi0oe7/AOzgkS7_PkMNzg4ybZBTTZ8?rlkey=jjkqqz6ifi2ib3g01yf03j12h&st=v02sztb4&dl=0", 
-        "lego":"https://www.dropbox.com/scl/fo/xrvnu5i7cwg6ng4iveerd/APXNbHRR2IJqP6q384ZrsTY?rlkey=qag95l1xn3hgebxqcqb4grdbw&st=1xjm5ob9&dl=0",
-        "chair":"https://www.dropbox.com/scl/fo/rw1kx28apf2nj9nmmankn/AAXBD63yuU-TcaKJRh2WlUQ?rlkey=58tb99g1d41ml4asqxdp5lrxg&st=og6clu8k&dl=0",
-        "ficus":"https://www.dropbox.com/scl/fo/ash43k5stxykgu82y0rty/AJM0R8PdduoE4BMl31BI7xY?rlkey=ad1uacytq2mr5e0hc4tpmm7xp&st=uwm356c4&dl=0", 
-        "hotdog":"https://www.dropbox.com/scl/fo/lrbe9b8tsmpu6m3e25s7q/ANANvfFhEdoib9rHv5QmPwo?rlkey=bea0k5zi6ahgts88mlpvs4mta&st=8itg14zh&dl=0", 
-        "boots":"https://www.dropbox.com/scl/fo/cx5tl37qjytcv8v652q00/ADOzXV5AbW0_y_wpptIk8PY?rlkey=ne75mf8kc3hg6wg7coak74ww5&st=hklnyi76&dl=0", 
-        "carving":"https://www.dropbox.com/scl/fo/962tg8nqtx42m7lasqo7s/AIAl3BFPt7U1xD8eanwZnP8?rlkey=qm3r7d52dnvroac8lwsbq93pb&st=58hvm91y&dl=0", 
-        "baskets":"https://www.dropbox.com/scl/fo/jxvcp63h0z7u0hptk2b0f/AOvcyi2RB0R-999nzQZtwvk?rlkey=ce229qfku8brdfznzl62fi792&st=yf4aii6e&dl=0", 
-        "chef":"https://www.dropbox.com/scl/fo/15mcemsypabotbsr07gf0/AIdsXG0GHVp_FLf7i95Orr4?rlkey=abugupv7fo1gtjue73h0jm8uf&st=omb14j7c&dl=0",
-        "cinema":"https://www.dropbox.com/scl/fo/hdytz9zw73jq2f3hxp44b/ACQvEjYApQ6hDfhpf2vvoSw?rlkey=caeizu4zklzziyzt3wlcb4pgg&st=nherw66u&dl=0",
-        "food":"https://www.dropbox.com/scl/fo/brg2po03txm7nftnljhyb/AFfgHP1517nCEfY1oVGhfYo?rlkey=znxzp37wao2y9bydq8ceapimr&st=8kfsaiob&dl=0", 
-        "intrinsics.npy":"https://www.dropbox.com/scl/fi/s4whgdajo5jy5wmdtlhwf/intrinsics.npy?rlkey=s247t4pvtubn726dzpnwmnlrv&st=0hnobsb9&dl=0", 
-        "pulse_low_flux.mat":"https://www.dropbox.com/scl/fi/x63omsjecjijpg5q5dpiw/pulse_low_flux.mat?rlkey=1dm9d8jrdrogtw2xbgg2x8x17&st=4gll02on&dl=0", 
-    }
-    os.makedirs("dataset", exist_ok = True)
-    for file in ["pulse_low_flux.mat", "intrinsics.npy"]:
-        command = f'wget "{link_dict[file]}" -O ./dataset/{file}'
-        subprocess.run(command, shell=True)
-        
-
-    for folder in scenes:
-        os.makedirs(f"dataset/{folder}", exist_ok = True)
-
-        command = f'wget "{link_dict[folder]}" -O dataset/{folder}.zip'
-        subprocess.run(command, shell=True)
-        
-        command = f"unzip dataset/{folder}.zip -d dataset/{folder}"
-        subprocess.run(command, shell=True)
-
-        command = f"rm dataset/{folder}.zip"
-        subprocess.run(command, shell=True)
-    
-
-
-
-if __name__=="__main__":
-    parser = configargparse.ArgumentParser()
-    parser.add_argument('--scenes', nargs='+', help='list of files to download')
-    args = parser.parse_args()
-    
-    final_scenes = []
-    all_scenes = ["cinema", "carving", "boots", "food", "chef", "baskets", "lego", "chair", "ficus", "hotdog", "bench"]
-    
-    if "all" in args.scenes:
-        final_scenes = all_scenes.copy()
-    
-    if "captured" in args.scenes:
-        scenes = ["cinema", "carving", "boots", "food", "chef", "baskets"]
-    if "simulated" in args.scenes:
-        scenes = ["lego", "chair", "ficus", "hotdog", "bench"]
-        
-    for scene in all_scenes:
-        if scene in args.scenes:
-            final_scenes += [scene]
-    # final_scenes += ["pulse", "intrinsics"]
-
-    final_scenes = list(set(final_scenes))
-    download_dataset(final_scenes)
-
-
-

codes/reconstruction/transientnerf/misc/eval_utils.py

@@ -1,224 +0,0 @@
-import numpy as np 
-import imageio 
-import json 
-import torch 
-import sys 
-import os
-import configargparse
-import ast
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from loaders.utils import Rays
-from utils import str2bool, load_args
-
-def calc_psnr(img1, img2):
-    # Calculate the mean squared error
-    mse = np.mean((img1 - img2) ** 2)
-    # Calculate the maximum possible pixel value (for data scaled between 0 and 1)
-    max_pixel = 1.0
-    # Calculate the PSNR
-    psnr_value = 20 * np.log10(max_pixel / np.sqrt(mse))
-    return psnr_value
-
-def get_rays(img_shape, c2w, K, device):
-    OPENGL_CAMERA = True
-    x, y = torch.meshgrid(
-                torch.arange(img_shape, device=device),
-                torch.arange(img_shape, device=device),
-                indexing="xy",
-    )
-    x = x.flatten()
-    y = y.flatten()
-    
-    c2w = c2w.repeat(img_shape**2, 1, 1)
-    camera_dirs = torch.nn.functional.pad(
-            torch.stack(
-                [
-                    (x - K[0, 2] + 0.5) / K[0, 0],
-                    (y - K[1, 2] + 0.5)
-                    / K[1, 1]
-                    * (-1.0 if OPENGL_CAMERA else 1.0),
-                ],
-                dim=-1,
-            ),
-            (0, 1),
-            value=(-1.0 if OPENGL_CAMERA else 1.0),
-        )  # [num_rays, 3]
-
-        # [n_cams, height, width, 3]
-    directions = (camera_dirs[:, None, :] * c2w[:, :3, :3]).sum(dim=-1)
-    origins = torch.broadcast_to(c2w[:, :3, -1], directions.shape)
-    viewdirs = directions / torch.linalg.norm(
-        directions, dim=-1, keepdims=True
-    )
-    origins = torch.reshape(origins, (img_shape, img_shape, 3))
-    viewdirs = torch.reshape(viewdirs, (img_shape, img_shape, 3))
-
-    
-    rays = Rays(origins=origins, viewdirs=viewdirs)
-
-    return rays 
-
-
-def read_json(json_path):
-    f = open(json_path)
-    positions = json.load(f)
-    f.close()
-    return positions
-
-def generate_video(images, output_path, fps):
-    # Determine the width and height of the images
-    writer = imageio.get_writer(output_path, fps=fps)
-    for image in images:
-        writer.append_data(image)
-    writer.close()
-
-def calc_iou(rgb, gt_tran):
-    intersection = np.minimum(rgb, gt_tran)
-    union = np.maximum(rgb, gt_tran)
-    iou = np.sum(intersection) / np.sum(union)
-    return iou
-
-def load_eval_args():
-    parser = configargparse.ArgumentParser()
-    parser.add('-tc', '--test_config', 
-        is_config_file=True, 
-        default="./configs/test/captured/cinema_quantitative.ini", 
-        help='Path to config file.'
-    )
-    parser.add_argument(
-        "--scene",
-        type=str,
-        default="cinema",
-        # choices=[
-        #     # nerf transient
-        #     "lego",
-        #     "chair",
-        #     "drums",
-        #     "ficus",
-        #     "hotdog",
-        #     "bench",
-        #     "boar",
-        #     "benches"
-        # ],
-        help="scene to evaluate the models on",
-    )
-    parser.add_argument(
-        "--rep_number",
-        type=int,
-        default=30,
-    )
-    parser.add_argument(
-        "--step",
-        type=int,
-        default=290000,
-    )
-    parser.add_argument(
-        "--split",
-        type=str,
-        default="test",
-    )
-    parser.add_argument(
-        "--test_folder_path",
-        type=str,
-        default="test2",
-    )
-    parser.add_argument(
-        "--checkpoint_dir",
-        type=str,
-        default="/scratch/ondemand28/anagh/tnerf_release/multiview_transient/results/cinema_two_views_04-18_02:10:32",
-    )
-    parser.add_argument(
-        "--data_folder_path",
-        type=str,
-        default="./data",
-    )
-    parser.add_argument(
-        "--irf_path",
-        type=str,
-        default="",
-        help="Path to IRF file (.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 around IRF peak. Set <=0 to disable cropping.",
-    )
-    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 measurement root for captured-ours loader.",
-    )
-    parser.add_argument(
-        "--data_exts",
-        type=str,
-        default=".npz,.txt,.pt,.h5,.hdf5",
-        help="Comma-separated measurement extension lookup order.",
-    )
-    parser.add_argument(
-        "--bin_width_s_loader",
-        type=float,
-        default=None,
-        help="Optional bin width in seconds for shift resampling.",
-    )
-    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(
-        "--invalid_mask_path",
-        type=str,
-        default="",
-        help="Optional offset map path for valid-pixel mask.",
-    )
-    parser.add_argument(
-        "--invalid_mask_invalid_gt",
-        type=float,
-        default=10.0,
-        help="Offset threshold: pixels with offset > threshold are invalid.",
-    )
-    parser.add_argument(
-        "--meas_peak_min",
-        type=float,
-        default=100.0,
-        help=(
-            "Minimum raw histogram peak per pixel to keep it in evaluation metrics. "
-            "<=0 disables this mask."
-        ),
-    )
-    parser.add_argument(
-        "--scale_int",
-        type=float,
-        default=1.0,
-        help="Fixed scale for intensity normalisation (replaces per-image dynamic max).",
-    )
-    args = load_args(eval=True, parser=parser)
-    return args
-
-num2words = {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 
-             6: 'six', 7: 'seven', 8: 'eight', 9: 'nine', 10: 'ten', 
-             11: 'eleven', 12: 'twelve', 13: 'thirteen', 14: 'fourteen', 
-             15: 'fifteen', 16: 'sixteen', 17: 'seventeen', 18: 'eighteen', 19: 'nineteen'}
-
-if __name__=="__main__":
-    pass

codes/reconstruction/transientnerf/misc/summary.py

@@ -1,147 +0,0 @@
-import imgviz
-import numpy as np
-from utils import render_transient
-import matplotlib.pyplot as plt
-import torchvision
-import torch
-import os 
-
-
-def _atomic_torch_save(obj, path):
-    folder = os.path.dirname(path) or "."
-    os.makedirs(folder, exist_ok=True)
-    tmp_path = os.path.join(folder, "." + os.path.basename(path) + ".tmp")
-    torch.save(obj, tmp_path)
-    os.replace(tmp_path, path)
-
-
-@torch.no_grad()
-def write_summary_histogram(radiance_field, occupancy_grid, writer, test_dataset, step, render_step_size, args):
-    img_scale = args.img_scale
-    radiance_field.eval()
-    occupancy_grid.eval()
-    rgb_images = []
-    depth_images = [] 
-    gt_imgs = []
-    accs = []
-
-    pixels_to_plot = args.pixels_to_plot
-    plotting_transients = []
-    plotting_transients_depth = []
-
-    plotting_transients_gt = []
-    mse_list = []
-
-    test_list = list(range(len(test_dataset)))
-    # if args.version == "simulated":
-    #     color_channels = 3
-    # else:
-    #     color_channels = 1
-    # n_output_dim = args.n_bins*(color_channels)
-    with torch.no_grad():
-
-        # sample transients from network
-        for ind, i in enumerate(test_list):
-            data = test_dataset[i]
-            render_bkgd = data["color_bkgd"]
-            rays = data["rays"]
-            pixels = data["pixels"]
-            pixels = pixels.reshape(rays.origins.shape[0], rays.origins.shape[1], -1, 3)
-            valid_mask = data.get("valid_mask", None)
-            if valid_mask is not None:
-                valid_mask = valid_mask.to(torch.bool).cpu()
-                if valid_mask.ndim == 1:
-                    valid_mask = valid_mask.reshape(rays.origins.shape[0], rays.origins.shape[1])
-
-
-            # # rendering
-            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, depth = [out[key] for key in ['colors', 'opacities', 'n_rendering_samples', "comp_weights", "depths"]]
-            del out
-
-            rgb = rgb.reshape(rays.origins.shape[0], rays.origins.shape[1], -1, 3)
-
-            _atomic_torch_save(rgb, os.path.join(args.outpath, f"test_{ind}_conv.pt"))
-            _atomic_torch_save(depth, os.path.join(args.outpath, f"test_{ind}_depth.pt"))
-
-            # if color_channels ==1:
-            #     gt_imgs.append(torch.clip(pixels.sum(-2).cpu().repeat(1, 1, 3).permute(2, 0, 1)/img_scale, 0, 1)**(1/2.2))
-            #     rgb_images.append(torch.clip(rgb.sum(-2).cpu().repeat(1, 1, 3).permute(2, 0, 1)/img_scale, 0, 1)**(1/2.2))
-            # else:
-            gt_img = torch.clip(pixels.sum(-2).cpu().permute(2, 0, 1)/img_scale, 0, 1)**(1/2.2)
-            rgb_img = torch.clip(rgb.sum(-2).cpu().permute(2, 0, 1)/img_scale, 0, 1)**(1/2.2)
-            if valid_mask is not None:
-                valid3 = valid_mask[None, ...].expand_as(gt_img)
-                gt_imgs.append(gt_img * valid3.to(gt_img.dtype))
-                rgb_images.append(rgb_img * valid3.to(rgb_img.dtype))
-                if valid3.any():
-                    mse_list.append(((gt_img - rgb_img) ** 2)[valid3].mean())
-                else:
-                    mse_list.append(torch.tensor(float("nan")))
-            else:
-                gt_imgs.append(gt_img)
-                rgb_images.append(rgb_img)
-                mse_list.append(torch.mean((gt_img - rgb_img) ** 2))
-            accs.append(acc.repeat(1, 1, 3).permute(2, 0, 1).cpu())
-            dp = imgviz.depth2rgb(depth.cpu().squeeze().numpy(), colormap="inferno")
-            depth_images.append(torch.from_numpy(dp).permute(2, 0, 1))
-
-            if ind == 0:
-                for pixel in pixels_to_plot:
-                    plotting_transients.append(rgb[pixel[0], pixel[1], :, 0])
-                    plotting_transients_gt.append(pixels[pixel[0], pixel[1], :, 0])
-                    plotting_transients_depth.append(depth[pixel[0], pixel[1]])
-
-
-        images = torchvision.utils.make_grid(torch.stack(gt_imgs + rgb_images + depth_images + accs), nrow=len(test_list), normalize=False)
-        mse = torch.stack(mse_list)
-        valid_mse = torch.isfinite(mse)
-        if valid_mse.any():
-            psnr = -10.0 * torch.log10(torch.clamp(mse[valid_mse], min=1e-12))
-            print(f"image psnr (masked): {psnr.mean():.2f}\n")
-            writer.add_scalar("Metric/psnr_masked", psnr.mean().item(), step)
-        else:
-            print("image psnr (masked): nan (no valid pixels)\n")
-        writer.add_image('rgbdn', images, step)
-
-        figure = plt.figure(figsize=((len(pixels_to_plot)+1), 4), dpi=250)
-
-        # plot the predicted intensity
-        plt.subplot(2, (len(pixels_to_plot)+1)//2, 1)
-        plt.imshow(gt_imgs[0].permute(1, 2, 0))
-        for i, pixel in enumerate(pixels_to_plot):
-            plt.plot(pixel[1], pixel[0], '.', markersize=10, color='red')
-            plt.text(pixel[1], pixel[0], str(i), color="yellow", fontsize=10)
-        plt.gca().set_aspect(1.0/plt.gca().get_data_ratio(), adjustable='box')
-        plt.title('gt intensity')
-
-        for i, pixel in enumerate(pixels_to_plot):
-            # plot transients
-            plt.subplot(2, (len(pixels_to_plot)+1)//2, i+2)
-            plt.plot(np.arange(args.n_bins), plotting_transients[i].detach().cpu(), label='pred', linewidth=0.5)
-            plt.plot(np.arange(args.n_bins), plotting_transients_gt[i].detach().cpu(), label='gt', linewidth=0.5)
-            plt.axvline(x = (plotting_transients_depth[i]/args.exposure_time).detach().cpu().numpy(), color = 'y')
-            plt.title(f"pixel {i}")
-            plt.ylabel('intensity')
-            plt.legend(borderpad=0, labelspacing=0)
-            plt.gca().set_aspect(1.0 / plt.gca().get_data_ratio(), adjustable='box')
-        
-        plt.tight_layout()
-        writer.add_figure("transient_plots", figure, step)
-
-
-    radiance_field.train()
-    occupancy_grid.train()
-    

codes/reconstruction/transientnerf/misc/transient_volrend.py

@@ -1,620 +0,0 @@
-from typing import Callable, Dict, Optional, Tuple
-import torch
-from torch import Tensor
-from nerfacc.pack import pack_info
-from nerfacc.scan import exclusive_prod, exclusive_sum
-from torch_scatter import scatter_max
-import math 
-
-
-def rendering_transient_single_path(
-    # ray marching results
-    t_starts: Tensor,
-    t_ends: Tensor,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    # radiance field
-    rgb_sigma_fn: Optional[Callable] = None,
-    # rendering options
-    render_bkgd: Optional[Tensor] = None,
-    args = None
-):
-
-    # Query sigma and color with gradients
-    data = rgb_sigma_fn(t_starts, t_ends, ray_indices.long())
-    rgbs, sigmas = data
-    dists = (t_starts + t_ends)/2
-    
-    if args.exp:
-        rgbs = torch.exp(rgbs)-1
-
-
-    # Rendering: compute weights and ray indices.
-    weights_non_squared, transmittance, alphas = render_weight_from_density(
-            t_starts,
-            t_ends,
-            sigmas,
-            ray_indices=ray_indices,
-            n_rays=n_rays
-    )
-    
-    # modelling squared transmittance 
-    # alphas = 1 - torch.exp(-sigmas * (t_ends - t_starts))
-    weights = (weights_non_squared ** 2 / (alphas.squeeze() + 1e-9))
-    # Some iterations can have no alive samples after occupancy sampling.
-    # Return zero buffers directly to avoid downstream shape edge-cases.
-    if t_starts.numel() == 0:
-        device = weights.device
-        dtype = weights.dtype
-        colors = torch.zeros((n_rays, args.n_bins, 3), device=device, dtype=dtype)
-        opacities = torch.zeros((n_rays, 1), device=device, dtype=dtype)
-        depths = torch.zeros((n_rays, 1), device=device, dtype=dtype)
-        depths_variance = torch.zeros((n_rays, 1), device=device, dtype=dtype)
-        comp_weights = torch.zeros((n_rays, args.n_bins), device=device, dtype=dtype)
-        return colors, opacities, depths, depths_variance, comp_weights, rgbs
-    weights_non_squared = weights_non_squared.reshape(-1)
-    weights = weights.reshape(-1)
-    ray_indices = ray_indices.reshape(-1).long()
-    t_starts = t_starts.reshape(-1)
-    t_ends = t_ends.reshape(-1)
-    dists = dists.reshape(-1)
-    rgbs = rgbs.reshape(-1, rgbs.shape[-1])
-
-    # Safety guard for occasional invalid indices from upstream CUDA kernels.
-    valid = (ray_indices >= 0) & (ray_indices < int(n_rays))
-    if not torch.all(valid):
-        weights_non_squared = weights_non_squared[valid]
-        weights = weights[valid]
-        ray_indices = ray_indices[valid]
-        t_starts = t_starts[valid]
-        t_ends = t_ends[valid]
-        dists = dists[valid]
-        rgbs = rgbs[valid]
-        if ray_indices.numel() == 0:
-            device = weights.device
-            dtype = weights.dtype
-            colors = torch.zeros((n_rays, args.n_bins, 3), device=device, dtype=dtype)
-            opacities = torch.zeros((n_rays, 1), device=device, dtype=dtype)
-            depths = torch.zeros((n_rays, 1), device=device, dtype=dtype)
-            depths_variance = torch.zeros((n_rays, 1), device=device, dtype=dtype)
-            comp_weights = torch.zeros((n_rays, args.n_bins), device=device, dtype=dtype)
-            return colors, opacities, depths, depths_variance, comp_weights, rgbs
-
-    # r**2 fall off 
-    src = weights[:, None] * rgbs
-    src = src/(dists[:, None].detach()**2 + 1e-10)
-
-    if args.version == "simulated":
-        # this code bins the output samples into a tensor of size [n_rays, n_bins, 3]
-        tfilter_sigma = args.tfilter_sigma
-        bin_mapping, dist_weights = mapping_dist_to_bin_mitsuba(dists, args.n_bins, args.exposure_time, c=1, sigma=tfilter_sigma)
-        src = (dist_weights[..., None] * src[:, None, :]).flatten(0, 1)
-        colors = torch.zeros((n_rays * args.n_bins, 3), device=weights.device)
-        index = ((torch.repeat_interleave(ray_indices, 8*tfilter_sigma) * args.n_bins) + bin_mapping.flatten().long())[:, None].expand(-1, 3).long()
-        colors.scatter_add_(0, index, src)
-        colors = colors.view(n_rays, args.n_bins, 3)
-        bin_numbers_floor, bin_numbers_ceil, alpha = mapping_dist_to_bin(dists, args.n_bins, args.exposure_time)
-        index_f = ((ray_indices * args.n_bins) + bin_numbers_floor.long())[:, None].expand(-1, 3).long()
-        index = index_f
-    
-    
-    if args.version == "captured":
-        bin_numbers_floor, bin_numbers_ceil, _ = mapping_dist_to_bin(dists, args.n_bins, args.exposure_time)    
-        colors = torch.zeros((n_rays * args.n_bins, 3), device=weights.device)    
-        index = ((ray_indices * args.n_bins) + bin_numbers_floor.long())[:, None].expand(-1, 3).long()   
-        colors.scatter_add_(0, index, src)    
-        colors = colors.view(n_rays, args.n_bins, 3)
-        colors = convolve_colour(colors, args.laser_kernel, n_bins=args.n_bins)
-
-
-
-    # do the same for the sigmas
-    comp_weights = torch.zeros((n_rays * args.n_bins, 1), device=weights.device)
-    comp_weights.scatter_add_(0, index[:, [0]], weights_non_squared[:, None])
-    comp_weights = comp_weights.reshape(n_rays, args.n_bins)
-
-
-    opacities = accumulate_along_rays(
-        weights, values=None, ray_indices=ray_indices, n_rays=n_rays
-    )
-
-    
-    out, argmax = scatter_max(weights_non_squared, ray_indices, out=torch.zeros(n_rays, device=ray_indices.device))
-
-    if t_starts.shape[0]!=0:
-        argmax[argmax==weights.shape[0]] = weights.shape[0]-1
-        depths = (t_starts+t_ends)[argmax]/2
-    else:
-        depths = out[:, None]
-
-    to_accum_var = ((t_ends + t_starts) / 2 - depths.reshape(-1)[ray_indices]) ** 2
-    depths_variance = accumulate_along_rays(
-        weights_non_squared.reshape(-1),
-        ray_indices=ray_indices,
-        values=to_accum_var.reshape(-1, 1),
-        n_rays=n_rays,
-    )
-    depths_variance = depths_variance/(opacities+1e-10)
-
-
-    return colors, opacities, depths, depths_variance, comp_weights, rgbs
-
-
-def mapping_dist_to_bin_mitsuba(dists, n_bins, exposure_time, c=1, sigma=5):
-    times = 2 * dists / c
-    ratio = times / exposure_time
-    ranges = torch.arange(0, 8 * sigma, device=dists.device)[None, :].repeat(ratio.shape[0], 1)
-    bin_mapping = (torch.ceil(ratio-4*sigma))[:, None]+ranges
-    ranges = bin_mapping - ratio[:, None]
-    dist_weights = torch.exp(-ranges**2/(2*sigma**2))-math.exp(-8)
-
-    dist_weights[(bin_mapping<0) ] = 0
-    dist_weights[(bin_mapping>n_bins) ] = 0
-
-    bin_mapping = torch.clip(bin_mapping, 0, n_bins-1)
-    dist_weights = (dist_weights.T/(dist_weights.sum(-1)[: None]+1e-10)).T
-    return bin_mapping, dist_weights
-
-
-def mapping_dist_to_bin(dists, n_bins, exposure_time, c=1):
-    times = 2 * dists / c
-    #  (torch.randn(times.shape[0])*7).to("cuda")
-    ratio = times / exposure_time
-    alpha = (torch.ceil(ratio) - ratio) / (torch.ceil(ratio) - torch.floor(ratio) + 1e-10)
-
-    bin_numbers_floor = torch.floor(ratio)
-    bin_numbers_ceil = torch.ceil(ratio)
-    # if torch.max(bin_numbers)>bin_length:
-    #     print("hello")
-    bin_numbers_floor = torch.clip(bin_numbers_floor, 0, n_bins - 1)
-    bin_numbers_ceil = torch.clip(bin_numbers_ceil, 0, n_bins - 1)
-
-    return bin_numbers_floor, bin_numbers_ceil, alpha
-
-
-def render_transmittance_from_alpha(
-    alphas: Tensor,
-    packed_info: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    prefix_trans: Optional[Tensor] = None,
-) -> Tensor:
-    """Compute transmittance :math:`T_i` from alpha :math:`\\alpha_i`.
-
-    .. math::
-        T_i = \\prod_{j=1}^{i-1}(1-\\alpha_j)
-
-    This function supports both batched and flattened input tensor. For flattened input tensor, either
-    (`packed_info`) or (`ray_indices` and `n_rays`) should be provided.
-
-    Args:
-        alphas: The opacity values of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        packed_info: A tensor of shape (n_rays, 2) that specifies the start and count
-            of each chunk in the flattened samples, with in total n_rays chunks.
-            Useful for flattened input.
-        ray_indices: Ray indices of the flattened samples. LongTensor with shape (all_samples).
-        n_rays: Number of rays. Only useful when `ray_indices` is provided.
-        prefix_trans: The pre-computed transmittance of the samples. Tensor with shape (all_samples,).
-
-    Returns:
-        The rendering transmittance with the same shape as `alphas`.
-
-    Examples:
-
-    .. code-block:: python
-
-        >>> alphas = torch.tensor([0.4, 0.8, 0.1, 0.8, 0.1, 0.0, 0.9], device="cuda")
-        >>> ray_indices = torch.tensor([0, 0, 0, 1, 1, 2, 2], device="cuda")
-        >>> transmittance = render_transmittance_from_alpha(alphas, ray_indices=ray_indices)
-        tensor([1.0, 0.6, 0.12, 1.0, 0.2, 1.0, 1.0])
-    """
-    if ray_indices is not None and packed_info is None:
-        packed_info = pack_info(ray_indices, n_rays)
-
-    trans = exclusive_prod(1 - alphas, packed_info)
-    if prefix_trans is not None:
-        trans *= prefix_trans
-    return trans
-
-def convolve_colour(color, kernel, n_bins):
-    color = color.transpose(1, 2).reshape(-1, n_bins)
-    color = kernel(color[:, None, :]).squeeze()
-    color = color.reshape(-1, 3, n_bins).transpose(1, 2)
-    return color
-
-def torch_laser_kernel(laser, device='cuda'):
-    m = torch.nn.Conv1d(1, 1, laser.shape[0], padding=(laser.shape[0] - 1) // 2, padding_mode="zeros", device=device)
-    m.weight.requires_grad = False
-    m.bias.requires_grad = False
-    m.bias *= 0
-    m.weight = torch.nn.Parameter(laser[None, None, ...])
-    return m
-
-def render_transmittance_from_density(
-    t_starts: Tensor,
-    t_ends: Tensor,
-    sigmas: Tensor,
-    packed_info: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    prefix_trans: Optional[Tensor] = None,
-) -> Tuple[Tensor, Tensor]:
-    """Compute transmittance :math:`T_i` from density :math:`\\sigma_i`.
-
-    .. math::
-        T_i = exp(-\\sum_{j=1}^{i-1}\\sigma_j\delta_j)
-    
-    This function supports both batched and flattened input tensor. For flattened input tensor, either
-    (`packed_info`) or (`ray_indices` and `n_rays`) should be provided.
-
-    Args:
-        t_starts: Where the frustum-shape sample starts along a ray. Tensor with \
-            shape (all_samples,) or (n_rays, n_samples).
-        t_ends: Where the frustum-shape sample ends along a ray. Tensor with \
-            shape (all_samples,) or (n_rays, n_samples).
-        sigmas: The density values of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        packed_info: A tensor of shape (n_rays, 2) that specifies the start and count
-            of each chunk in the flattened samples, with in total n_rays chunks.
-            Useful for flattened input.
-        ray_indices: Ray indices of the flattened samples. LongTensor with shape (all_samples).
-        n_rays: Number of rays. Only useful when `ray_indices` is provided.
-        prefix_trans: The pre-computed transmittance of the samples. Tensor with shape (all_samples,).
-
-    Returns:
-        The rendering transmittance and opacities, both with the same shape as `sigmas`.
-
-    Examples:
-    
-    .. code-block:: python
-
-        >>> t_starts = torch.tensor([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], device="cuda")
-        >>> t_ends = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], device="cuda")
-        >>> sigmas = torch.tensor([0.4, 0.8, 0.1, 0.8, 0.1, 0.0, 0.9], device="cuda")
-        >>> ray_indices = torch.tensor([0, 0, 0, 1, 1, 2, 2], device="cuda")
-        >>> transmittance, alphas = render_transmittance_from_density(
-        >>>     t_starts, t_ends, sigmas, ray_indices=ray_indices)
-        transmittance: [1.00, 0.67, 0.30, 1.00, 0.45, 1.00, 1.00]
-        alphas: [0.33, 0.55, 0.095, 0.55, 0.095, 0.00, 0.59]
-
-    """
-    if ray_indices is not None and packed_info is None:
-        packed_info = pack_info(ray_indices, n_rays)
-
-    sigmas_dt = sigmas * (t_ends - t_starts)
-    alphas = 1.0 - torch.exp(-sigmas_dt)
-    trans = torch.exp(-exclusive_sum(sigmas_dt, packed_info))
-    if prefix_trans is not None:
-        trans *= prefix_trans
-    return trans, alphas
-
-
-def render_weight_from_alpha(
-    alphas: Tensor,
-    packed_info: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    prefix_trans: Optional[Tensor] = None,
-) -> Tuple[Tensor, Tensor]:
-    """Compute rendering weights :math:`w_i` from opacity :math:`\\alpha_i`.
-
-    .. math::
-        w_i = T_i\\alpha_i, \\quad\\textrm{where}\\quad T_i = \\prod_{j=1}^{i-1}(1-\\alpha_j)
-
-    This function supports both batched and flattened input tensor. For flattened input tensor, either
-    (`packed_info`) or (`ray_indices` and `n_rays`) should be provided.
-
-    Args:
-        alphas: The opacity values of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        packed_info: A tensor of shape (n_rays, 2) that specifies the start and count
-            of each chunk in the flattened samples, with in total n_rays chunks.
-            Useful for flattened input.
-        ray_indices: Ray indices of the flattened samples. LongTensor with shape (all_samples).
-        n_rays: Number of rays. Only useful when `ray_indices` is provided.
-        prefix_trans: The pre-computed transmittance of the samples. Tensor with shape (all_samples,).
-
-    Returns:
-        The rendering weights and transmittance, both with the same shape as `alphas`.
-
-    Examples:
-
-    .. code-block:: python
-
-        >>> alphas = torch.tensor([0.4, 0.8, 0.1, 0.8, 0.1, 0.0, 0.9], device="cuda")
-        >>> ray_indices = torch.tensor([0, 0, 0, 1, 1, 2, 2], device="cuda")
-        >>> weights, transmittance = render_weight_from_alpha(alphas, ray_indices=ray_indices)
-        weights: [0.4, 0.48, 0.012, 0.8, 0.02, 0.0, 0.9])
-        transmittance: [1.00, 0.60, 0.12, 1.00, 0.20, 1.00, 1.00]
-
-    """
-    trans = render_transmittance_from_alpha(
-        alphas, packed_info, ray_indices, n_rays, prefix_trans
-    )
-    weights = trans * alphas
-    return weights, trans
-
-
-def render_weight_from_density(
-    t_starts: Tensor,
-    t_ends: Tensor,
-    sigmas: Tensor,
-    packed_info: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    prefix_trans: Optional[Tensor] = None,
-) -> Tuple[Tensor, Tensor, Tensor]:
-    """Compute rendering weights :math:`w_i` from density :math:`\\sigma_i` and interval :math:`\\delta_i`.
-
-    .. math::
-        w_i = T_i(1 - exp(-\\sigma_i\delta_i)), \\quad\\textrm{where}\\quad T_i = exp(-\\sum_{j=1}^{i-1}\\sigma_j\delta_j)
-
-    This function supports both batched and flattened input tensor. For flattened input tensor, either
-    (`packed_info`) or (`ray_indices` and `n_rays`) should be provided.
-
-    Args:
-        t_starts: The start time of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        t_ends: The end time of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        sigmas: The density values of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        packed_info: A tensor of shape (n_rays, 2) that specifies the start and count
-            of each chunk in the flattened samples, with in total n_rays chunks.
-            Useful for flattened input.
-        ray_indices: Ray indices of the flattened samples. LongTensor with shape (all_samples).
-        n_rays: Number of rays. Only useful when `ray_indices` is provided.
-        prefix_trans: The pre-computed transmittance of the samples. Tensor with shape (all_samples,).
-
-    Returns:
-        The rendering weights, transmittance and opacities, both with the same shape as `sigmas`.
-
-    Examples:
-
-    .. code-block:: python
-
-        >>> t_starts = torch.tensor([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], device="cuda")
-        >>> t_ends = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], device="cuda")
-        >>> sigmas = torch.tensor([0.4, 0.8, 0.1, 0.8, 0.1, 0.0, 0.9], device="cuda")
-        >>> ray_indices = torch.tensor([0, 0, 0, 1, 1, 2, 2], device="cuda")
-        >>> weights, transmittance, alphas = render_weight_from_density(
-        >>>     t_starts, t_ends, sigmas, ray_indices=ray_indices)
-        weights: [0.33, 0.37, 0.03, 0.55, 0.04, 0.00, 0.59]
-        transmittance: [1.00, 0.67, 0.30, 1.00, 0.45, 1.00, 1.00]
-        alphas: [0.33, 0.55, 0.095, 0.55, 0.095, 0.00, 0.59]
-
-    """
-    trans, alphas = render_transmittance_from_density(
-        t_starts, t_ends, sigmas, packed_info, ray_indices, n_rays, prefix_trans
-    )
-    weights = trans * alphas
-    return weights, trans, alphas
-
-
-@torch.no_grad()
-def render_visibility_from_alpha(
-    alphas: Tensor,
-    packed_info: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    early_stop_eps: float = 1e-4,
-    alpha_thre: float = 0.0,
-    prefix_trans: Optional[Tensor] = None,
-) -> Tensor:
-    """Compute visibility from opacity :math:`\\alpha_i`.
-
-    In this function, we first compute the transmittance from the sample opacity. The
-    transmittance is then used to filter out occluded samples. And opacity is used to
-    filter out transparent samples. The function returns a boolean tensor indicating
-    which samples are visible (`transmittance > early_stop_eps` and `opacity > alpha_thre`).
-
-    This function supports both batched and flattened input tensor. For flattened input tensor, either
-    (`packed_info`) or (`ray_indices` and `n_rays`) should be provided.
-
-    Args:
-        alphas: The opacity values of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        packed_info: A tensor of shape (n_rays, 2) that specifies the start and count
-            of each chunk in the flattened samples, with in total n_rays chunks.
-            Useful for flattened input.
-        ray_indices: Ray indices of the flattened samples. LongTensor with shape (all_samples).
-        n_rays: Number of rays. Only useful when `ray_indices` is provided.
-        early_stop_eps: The early stopping threshold on transmittance.
-        alpha_thre: The threshold on opacity.
-        prefix_trans: The pre-computed transmittance of the samples. Tensor with shape (all_samples,).
-
-    Returns:
-        A boolean tensor indicating which samples are visible. Same shape as `alphas`.
-
-    Examples:
-
-    .. code-block:: python
-
-        >>> alphas = torch.tensor([0.4, 0.8, 0.1, 0.8, 0.1, 0.0, 0.9], device="cuda")
-        >>> ray_indices = torch.tensor([0, 0, 0, 1, 1, 2, 2], device="cuda")
-        >>> transmittance = render_transmittance_from_alpha(alphas, ray_indices=ray_indices)
-        tensor([1.0, 0.6, 0.12, 1.0, 0.2, 1.0, 1.0])
-        >>> visibility = render_visibility_from_alpha(
-        >>>     alphas, ray_indices=ray_indices, early_stop_eps=0.3, alpha_thre=0.2)
-        tensor([True,  True, False,  True, False, False,  True])
-
-    """
-    trans = render_transmittance_from_alpha(
-        alphas, packed_info, ray_indices, n_rays, prefix_trans
-    )
-    vis = trans >= early_stop_eps
-    if alpha_thre > 0:
-        vis = vis & (alphas >= alpha_thre)
-    return vis
-
-
-@torch.no_grad()
-def render_visibility_from_density(
-    t_starts: Tensor,
-    t_ends: Tensor,
-    sigmas: Tensor,
-    packed_info: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-    early_stop_eps: float = 1e-4,
-    alpha_thre: float = 0.0,
-    prefix_trans: Optional[Tensor] = None,
-) -> Tensor:
-    """Compute visibility from density :math:`\\sigma_i` and interval :math:`\\delta_i`.
-
-    In this function, we first compute the transmittance and opacity from the sample density. The
-    transmittance is then used to filter out occluded samples. And opacity is used to
-    filter out transparent samples. The function returns a boolean tensor indicating
-    which samples are visible (`transmittance > early_stop_eps` and `opacity > alpha_thre`).
-
-    This function supports both batched and flattened input tensor. For flattened input tensor, either
-    (`packed_info`) or (`ray_indices` and `n_rays`) should be provided.
-
-    Args:
-        alphas: The opacity values of the samples. Tensor with shape (all_samples,) or (n_rays, n_samples).
-        packed_info: A tensor of shape (n_rays, 2) that specifies the start and count
-            of each chunk in the flattened samples, with in total n_rays chunks.
-            Useful for flattened input.
-        ray_indices: Ray indices of the flattened samples. LongTensor with shape (all_samples).
-        n_rays: Number of rays. Only useful when `ray_indices` is provided.
-        early_stop_eps: The early stopping threshold on transmittance.
-        alpha_thre: The threshold on opacity.
-        prefix_trans: The pre-computed transmittance of the samples. Tensor with shape (all_samples,).
-
-    Returns:
-        A boolean tensor indicating which samples are visible. Same shape as `alphas`.
-
-    Examples:
-
-    .. code-block:: python
-
-        >>> t_starts = torch.tensor([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], device="cuda")
-        >>> t_ends = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], device="cuda")
-        >>> sigmas = torch.tensor([0.4, 0.8, 0.1, 0.8, 0.1, 0.0, 0.9], device="cuda")
-        >>> ray_indices = torch.tensor([0, 0, 0, 1, 1, 2, 2], device="cuda")
-        >>> transmittance, alphas = render_transmittance_from_density(
-        >>>     t_starts, t_ends, sigmas, ray_indices=ray_indices)
-        transmittance: [1.00, 0.67, 0.30, 1.00, 0.45, 1.00, 1.00]
-        alphas: [0.33, 0.55, 0.095, 0.55, 0.095, 0.00, 0.59]
-        >>> visibility = render_visibility_from_density(
-        >>>     t_starts, t_ends, sigmas, ray_indices=ray_indices, early_stop_eps=0.3, alpha_thre=0.2)
-        tensor([True,  True, False,  True, False, False,  True])
-
-    """
-    trans, alphas = render_transmittance_from_density(
-        t_starts, t_ends, sigmas, packed_info, ray_indices, n_rays, prefix_trans
-    )
-    vis = trans >= early_stop_eps
-    if alpha_thre > 0:
-        vis = vis & (alphas >= alpha_thre)
-    return vis
-
-
-def accumulate_along_rays(
-    weights: Tensor,
-    values: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    n_rays: Optional[int] = None,
-) -> Tensor:
-    """Accumulate volumetric values along the ray.
-
-    This function supports both batched inputs and flattened inputs with
-    `ray_indices` and `n_rays` provided.
-
-    Note:
-        This function is differentiable to `weights` and `values`.
-
-    Args:
-        weights: Weights to be accumulated. If `ray_indices` not provided,
-            `weights` must be batched with shape (n_rays, n_samples). Else it
-            must be flattened with shape (all_samples,).
-        values: Values to be accumulated. If `ray_indices` not provided,
-            `values` must be batched with shape (n_rays, n_samples, D). Else it
-            must be flattened with shape (all_samples, D). None means
-            we accumulate weights along rays. Default: None.
-        ray_indices: Ray indices of the samples with shape (all_samples,).
-            If provided, `weights` must be a flattened tensor with shape (all_samples,)
-            and values (if not None) must be a flattened tensor with shape (all_samples, D).
-            Default: None.
-        n_rays: Number of rays. Should be provided together with `ray_indices`. Default: None.
-
-    Returns:
-        Accumulated values with shape (n_rays, D). If `values` is not given we return
-        the accumulated weights, in which case D == 1.
-
-    Examples:
-
-    .. code-block:: python
-
-        # Rendering: accumulate rgbs, opacities, and depths along the rays.
-        colors = accumulate_along_rays(weights, rgbs, ray_indices, n_rays)
-        opacities = accumulate_along_rays(weights, None, ray_indices, n_rays)
-        depths = accumulate_along_rays(
-            weights,
-            (t_starts + t_ends)[:, None] / 2.0,
-            ray_indices,
-            n_rays,
-        )
-        # (n_rays, 3), (n_rays, 1), (n_rays, 1)
-        print(colors.shape, opacities.shape, depths.shape)
-
-    """
-    if values is None:
-        src = weights[..., None]
-    else:
-        assert values.dim() == weights.dim() + 1
-        assert weights.shape == values.shape[:-1]
-        src = weights[..., None] * values
-    if ray_indices is not None:
-        assert n_rays is not None, "n_rays must be provided"
-        assert weights.dim() == 1, "weights must be flattened"
-        outputs = torch.zeros(
-            (n_rays, src.shape[-1]), device=src.device, dtype=src.dtype
-        )
-        outputs.index_add_(0, ray_indices, src)
-    else:
-        outputs = torch.sum(src, dim=-2)
-    return outputs
-
-
-def accumulate_along_rays_(
-    weights: Tensor,
-    values: Optional[Tensor] = None,
-    ray_indices: Optional[Tensor] = None,
-    outputs: Optional[Tensor] = None,
-) -> None:
-    """Accumulate volumetric values along the ray.
-
-    Inplace version of :func:`accumulate_along_rays`.
-    """
-    if weights.shape[0] == 0:
-        return 0
-    if values is None:
-        src = weights[..., None]
-    else:
-        assert values.dim() == weights.dim() + 1
-        assert weights.shape == values.shape[:-1]
-        src = weights[..., None] * values
-    if ray_indices is not None:
-        # assert weights.dim() == 1, "weights must be flattened"
-        # assert (
-        #     outputs.dim() == 2 and outputs.shape[-1] == src.shape[-1]
-        # ), "outputs must be of shape (n_rays, D)"
-        outputs.index_add_(0, ray_indices, src)
-    else:
-        outputs.add_(src.sum(dim=-2))
-
-
-def shift_transient_grid_sample_3d(transient, depth, exposure_time, n_bins):
-    x_dim = transient.shape[0]
-    bins_move = depth/exposure_time
-    if x_dim%2 == 0:
-        x = (torch.arange(x_dim, device=transient.device)-x_dim//2+0.5)/(x_dim//2-0.5)
-    else:
-        x = (torch.arange(x_dim, device=transient.device)-x_dim//2)/(x_dim//2)
-
-    if x_dim == 1:
-        x = torch.zeros_like(x)
-        
-    z = torch.arange(n_bins, device=transient.device).float()
-    X, Z = torch.meshgrid(x, z, indexing="ij")
-    Z = Z - bins_move
-    Z[Z<0] = n_bins+1
-    Z = (Z-n_bins//2+0.5)/(n_bins//2-0.5)
-    grid = torch.stack((Z, X), dim=-1)[None, ...]
-    shifted_transient = torch.nn.functional.grid_sample(transient.permute(2, 0, 1)[None], grid, align_corners=True).squeeze(0).permute(1, 2, 0)
-    return shifted_transient

codes/reconstruction/transientnerf/radiance_fields/mlp.py

@@ -1,395 +0,0 @@
-"""
-Copyright (c) 2022 Ruilong Li, UC Berkeley.
-"""
-
-import functools
-import math
-from typing import Callable, Optional
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class MLP(nn.Module):
-    def __init__(
-        self,
-        input_dim: int,  # The number of input tensor channels.
-        output_dim: int = None,  # The number of output tensor channels.
-        net_depth: int = 8,  # The depth of the MLP.
-        net_width: int = 256,  # The width of the MLP.
-        skip_layer: int = 4,  # The layer to add skip layers to.
-        hidden_init: Callable = nn.init.xavier_uniform_,
-        hidden_activation: Callable = nn.ReLU(),
-        output_enabled: bool = True,
-        output_init: Optional[Callable] = nn.init.xavier_uniform_,
-        output_activation: Optional[Callable] = nn.Identity(),
-        bias_enabled: bool = True,
-        bias_init: Callable = nn.init.zeros_,
-    ):
-        super().__init__()
-        self.input_dim = input_dim
-        self.output_dim = output_dim
-        self.net_depth = net_depth
-        self.net_width = net_width
-        self.skip_layer = skip_layer
-        self.hidden_init = hidden_init
-        self.hidden_activation = hidden_activation
-        self.output_enabled = output_enabled
-        self.output_init = output_init
-        self.output_activation = output_activation
-        self.bias_enabled = bias_enabled
-        self.bias_init = bias_init
-
-        self.hidden_layers = nn.ModuleList()
-        in_features = self.input_dim
-        for i in range(self.net_depth):
-            self.hidden_layers.append(
-                nn.Linear(in_features, self.net_width, bias=bias_enabled)
-            )
-            if (
-                (self.skip_layer is not None)
-                and (i % self.skip_layer == 0)
-                and (i > 0)
-            ):
-                in_features = self.net_width + self.input_dim
-            else:
-                in_features = self.net_width
-        if self.output_enabled:
-            self.output_layer = nn.Linear(
-                in_features, self.output_dim, bias=bias_enabled
-            )
-        else:
-            self.output_dim = in_features
-
-        self.initialize()
-
-    def initialize(self):
-        def init_func_hidden(m):
-            if isinstance(m, nn.Linear):
-                if self.hidden_init is not None:
-                    self.hidden_init(m.weight)
-                if self.bias_enabled and self.bias_init is not None:
-                    self.bias_init(m.bias)
-
-        self.hidden_layers.apply(init_func_hidden)
-        if self.output_enabled:
-
-            def init_func_output(m):
-                if isinstance(m, nn.Linear):
-                    if self.output_init is not None:
-                        self.output_init(m.weight)
-                    if self.bias_enabled and self.bias_init is not None:
-                        self.bias_init(m.bias)
-
-            self.output_layer.apply(init_func_output)
-
-    def forward(self, x):
-        inputs = x
-        for i in range(self.net_depth):
-            x = self.hidden_layers[i](x)
-            x = self.hidden_activation(x)
-            if (
-                (self.skip_layer is not None)
-                and (i % self.skip_layer == 0)
-                and (i > 0)
-            ):
-                x = torch.cat([x, inputs], dim=-1)
-        if self.output_enabled:
-            x = self.output_layer(x)
-            x = self.output_activation(x)
-        return x
-
-
-class DenseLayer(MLP):
-    def __init__(self, input_dim, output_dim, **kwargs):
-        super().__init__(
-            input_dim=input_dim,
-            output_dim=output_dim,
-            net_depth=0,  # no hidden layers
-            **kwargs,
-        )
-
-
-class NerfMLP(nn.Module):
-    def __init__(
-        self,
-        input_dim: int,  # The number of input tensor channels.
-        condition_dim: int,  # The number of condition tensor channels.
-        net_depth: int = 8,  # The depth of the MLP.
-        net_width: int = 256,  # The width of the MLP.
-        skip_layer: int = 4,  # The layer to add skip layers to.
-        net_depth_condition: int = 1,  # The depth of the second part of MLP.
-        net_width_condition: int = 128,  # The width of the second part of MLP.
-    ):
-        super().__init__()
-        self.base = MLP(
-            input_dim=input_dim,
-            net_depth=net_depth,
-            net_width=net_width,
-            skip_layer=skip_layer,
-            output_enabled=False,
-        )
-        hidden_features = self.base.output_dim
-        self.sigma_layer = DenseLayer(hidden_features, 1)
-
-        if condition_dim > 0:
-            self.bottleneck_layer = DenseLayer(hidden_features, net_width)
-            self.rgb_layer = MLP(
-                input_dim=net_width + condition_dim,
-                output_dim=3,
-                net_depth=net_depth_condition,
-                net_width=net_width_condition,
-                skip_layer=None,
-            )
-        else:
-            self.rgb_layer = DenseLayer(hidden_features, 3)
-
-    def query_density(self, x):
-        x = self.base(x)
-        raw_sigma = self.sigma_layer(x)
-        return raw_sigma
-
-    def forward(self, x, condition=None):
-        x = self.base(x)
-        raw_sigma = self.sigma_layer(x)
-        if condition is not None:
-            if condition.shape[:-1] != x.shape[:-1]:
-                num_rays, n_dim = condition.shape
-                condition = condition.view(
-                    [num_rays] + [1] * (x.dim() - condition.dim()) + [n_dim]
-                ).expand(list(x.shape[:-1]) + [n_dim])
-            bottleneck = self.bottleneck_layer(x)
-            x = torch.cat([bottleneck, condition], dim=-1)
-        raw_rgb = self.rgb_layer(x)
-        return raw_rgb, raw_sigma
-
-
-class SinusoidalEncoder(nn.Module):
-    """Sinusoidal Positional Encoder used in Nerf."""
-
-    def __init__(self, x_dim, min_deg, max_deg, use_identity: bool = True):
-        super().__init__()
-        self.x_dim = x_dim
-        self.min_deg = min_deg
-        self.max_deg = max_deg
-        self.use_identity = use_identity
-        self.register_buffer(
-            "scales", torch.tensor([2**i for i in range(min_deg, max_deg)])
-        )
-
-    @property
-    def latent_dim(self) -> int:
-        return (
-            int(self.use_identity) + (self.max_deg - self.min_deg) * 2
-        ) * self.x_dim
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """
-        Args:
-            x: [..., x_dim]
-        Returns:
-            latent: [..., latent_dim]
-        """
-        if self.max_deg == self.min_deg:
-            return x
-        xb = torch.reshape(
-            (x[Ellipsis, None, :] * self.scales[:, None]),
-            list(x.shape[:-1]) + [(self.max_deg - self.min_deg) * self.x_dim],
-        )
-        latent = torch.sin(torch.cat([xb, xb + 0.5 * math.pi], dim=-1))
-        if self.use_identity:
-            latent = torch.cat([x] + [latent], dim=-1)
-        return latent
-
-
-class VanillaNeRFRadianceField(nn.Module):
-    def __init__(
-        self,
-        net_depth: int = 8,  # The depth of the MLP.
-        net_width: int = 256,  # The width of the MLP.
-        skip_layer: int = 4,  # The layer to add skip layers to.
-        net_depth_condition: int = 1,  # The depth of the second part of MLP.
-        net_width_condition: int = 128,  # The width of the second part of MLP.
-    ) -> None:
-        super().__init__()
-        self.posi_encoder = SinusoidalEncoder(3, 0, 10, True)
-        self.view_encoder = SinusoidalEncoder(3, 0, 4, True)
-        self.mlp = NerfMLP(
-            input_dim=self.posi_encoder.latent_dim,
-            condition_dim=self.view_encoder.latent_dim,
-            net_depth=net_depth,
-            net_width=net_width,
-            skip_layer=skip_layer,
-            net_depth_condition=net_depth_condition,
-            net_width_condition=net_width_condition,
-        )
-
-    def query_opacity(self, x, step_size):
-        density = self.query_density(x)
-        # if the density is small enough those two are the same.
-        # opacity = 1.0 - torch.exp(-density * step_size)
-        opacity = density * step_size
-        return opacity
-
-    def query_density(self, x):
-        x = self.posi_encoder(x)
-        sigma = self.mlp.query_density(x)
-        return F.relu(sigma)
-
-    def forward(self, x, condition=None):
-        x = self.posi_encoder(x)
-        if condition is not None:
-            condition = self.view_encoder(condition)
-        rgb, sigma = self.mlp(x, condition=condition)
-        return torch.sigmoid(rgb), F.relu(sigma)
-
-
-class TNeRFRadianceField(nn.Module):
-    def __init__(self) -> None:
-        super().__init__()
-        self.posi_encoder = SinusoidalEncoder(3, 0, 4, True)
-        self.time_encoder = SinusoidalEncoder(1, 0, 4, True)
-        self.warp = MLP(
-            input_dim=self.posi_encoder.latent_dim
-            + self.time_encoder.latent_dim,
-            output_dim=3,
-            net_depth=4,
-            net_width=64,
-            skip_layer=2,
-            output_init=functools.partial(torch.nn.init.uniform_, b=1e-4),
-        )
-        self.nerf = VanillaNeRFRadianceField()
-
-    def query_opacity(self, x, timestamps, step_size):
-        idxs = torch.randint(0, len(timestamps), (x.shape[0],), device=x.device)
-        t = timestamps[idxs]
-        density = self.query_density(x, t)
-        # if the density is small enough those two are the same.
-        # opacity = 1.0 - torch.exp(-density * step_size)
-        opacity = density * step_size
-        return opacity
-
-    def query_density(self, x, t):
-        x = x + self.warp(
-            torch.cat([self.posi_encoder(x), self.time_encoder(t)], dim=-1)
-        )
-        return self.nerf.query_density(x)
-
-    def forward(self, x, t, condition=None):
-        x = x + self.warp(
-            torch.cat([self.posi_encoder(x), self.time_encoder(t)], dim=-1)
-        )
-        return self.nerf(x, condition=condition)
-
-
-class NDRTNeRFRadianceField(nn.Module):
-
-    """Invertble NN from https://arxiv.org/pdf/2206.15258.pdf"""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.time_encoder = SinusoidalEncoder(1, 0, 4, True)
-        self.warp_layers_1 = nn.ModuleList()
-        self.time_layers_1 = nn.ModuleList()
-        self.warp_layers_2 = nn.ModuleList()
-        self.time_layers_2 = nn.ModuleList()
-        self.posi_encoder_1 = SinusoidalEncoder(2, 0, 4, True)
-        self.posi_encoder_2 = SinusoidalEncoder(1, 0, 4, True)
-        for _ in range(3):
-            self.warp_layers_1.append(
-                MLP(
-                    input_dim=self.posi_encoder_1.latent_dim + 64,
-                    output_dim=1,
-                    net_depth=2,
-                    net_width=128,
-                    skip_layer=None,
-                    output_init=functools.partial(
-                        torch.nn.init.uniform_, b=1e-4
-                    ),
-                )
-            )
-            self.warp_layers_2.append(
-                MLP(
-                    input_dim=self.posi_encoder_2.latent_dim + 64,
-                    output_dim=1 + 2,
-                    net_depth=1,
-                    net_width=128,
-                    skip_layer=None,
-                    output_init=functools.partial(
-                        torch.nn.init.uniform_, b=1e-4
-                    ),
-                )
-            )
-            self.time_layers_1.append(
-                DenseLayer(
-                    input_dim=self.time_encoder.latent_dim,
-                    output_dim=64,
-                )
-            )
-            self.time_layers_2.append(
-                DenseLayer(
-                    input_dim=self.time_encoder.latent_dim,
-                    output_dim=64,
-                )
-            )
-
-        self.nerf = VanillaNeRFRadianceField()
-
-    def _warp(self, x, t_enc, i_layer):
-        uv, w = x[:, :2], x[:, 2:]
-        dw = self.warp_layers_1[i_layer](
-            torch.cat(
-                [self.posi_encoder_1(uv), self.time_layers_1[i_layer](t_enc)],
-                dim=-1,
-            )
-        )
-        w = w + dw
-        rt = self.warp_layers_2[i_layer](
-            torch.cat(
-                [self.posi_encoder_2(w), self.time_layers_2[i_layer](t_enc)],
-                dim=-1,
-            )
-        )
-        r = self._euler2rot_2dinv(rt[:, :1])
-        t = rt[:, 1:]
-        uv = torch.bmm(r, (uv - t)[..., None]).squeeze(-1)
-        return torch.cat([uv, w], dim=-1)
-
-    def warp(self, x, t):
-        t_enc = self.time_encoder(t)
-        x = self._warp(x, t_enc, 0)
-        x = x[..., [1, 2, 0]]
-        x = self._warp(x, t_enc, 1)
-        x = x[..., [2, 0, 1]]
-        x = self._warp(x, t_enc, 2)
-        return x
-
-    def query_opacity(self, x, timestamps, step_size):
-        idxs = torch.randint(0, len(timestamps), (x.shape[0],), device=x.device)
-        t = timestamps[idxs]
-        density = self.query_density(x, t)
-        # if the density is small enough those two are the same.
-        # opacity = 1.0 - torch.exp(-density * step_size)
-        opacity = density * step_size
-        return opacity
-
-    def query_density(self, x, t):
-        x = self.warp(x, t)
-        return self.nerf.query_density(x)
-
-    def forward(self, x, t, condition=None):
-        x = self.warp(x, t)
-        return self.nerf(x, condition=condition)
-
-    def _euler2rot_2dinv(self, euler_angle):
-        # (B, 1) -> (B, 2, 2)
-        theta = euler_angle.reshape(-1, 1, 1)
-        rot = torch.cat(
-            (
-                torch.cat((theta.cos(), -theta.sin()), 1),
-                torch.cat((theta.sin(), theta.cos()), 1),
-            ),
-            2,
-        )
-        return rot

codes/reconstruction/transientnerf/radiance_fields/ngp.py

@@ -1,299 +0,0 @@
-"""
-Copyright (c) 2022 Ruilong Li, UC Berkeley.
-"""
-
-from typing import Callable, List, Union
-
-import numpy as np
-import torch
-from torch.autograd import Function
-from torch.cuda.amp import custom_bwd, custom_fwd
-import torch.nn.functional as F
-
-try:
-    import tinycudann as tcnn
-except ImportError as e:
-    print(
-        f"Error: {e}! "
-        "Please install tinycudann by: "
-        "pip install git+https://github.com/NVlabs/tiny-cuda-nn/#subdirectory=bindings/torch"
-    )
-    exit()
-
-
-class _TruncExp(Function):  # pylint: disable=abstract-method
-    # Implementation from torch-ngp:
-    # https://github.com/ashawkey/torch-ngp/blob/93b08a0d4ec1cc6e69d85df7f0acdfb99603b628/activation.py
-    @staticmethod
-    @custom_fwd(cast_inputs=torch.float32)
-    def forward(ctx, x):  # pylint: disable=arguments-differ
-        ctx.save_for_backward(x)
-        return torch.exp(x)
-
-    @staticmethod
-    @custom_bwd
-    def backward(ctx, g):  # pylint: disable=arguments-differ
-        x = ctx.saved_tensors[0]
-        return g * torch.exp(torch.clamp(x, max=15))
-
-
-trunc_exp = _TruncExp.apply
-
-
-def contract_to_unisphere(
-    x: torch.Tensor,
-    aabb: torch.Tensor,
-    ord: Union[str, int] = 2,
-    #  ord: Union[float, int] = float("inf"),
-    eps: float = 1e-6,
-    derivative: bool = False,
-):
-    aabb_min, aabb_max = torch.split(aabb, 3, dim=-1)
-    x = (x - aabb_min) / (aabb_max - aabb_min)
-    x = x * 2 - 1  # aabb is at [-1, 1]
-    mag = torch.linalg.norm(x, ord=ord, dim=-1, keepdim=True)
-    mask = mag.squeeze(-1) > 1
-
-    if derivative:
-        dev = (2 * mag - 1) / mag**2 + 2 * x**2 * (
-            1 / mag**3 - (2 * mag - 1) / mag**4
-        )
-        dev[~mask] = 1.0
-        dev = torch.clamp(dev, min=eps)
-        return dev
-    else:
-        x[mask] = (2 - 1 / mag[mask]) * (x[mask] / mag[mask])
-        x = x / 4 + 0.5  # [-inf, inf] is at [0, 1]
-        return x
-
-
-class NGPRadianceField(torch.nn.Module):
-    """Instance-NGP Radiance Field"""
-
-    def __init__(
-        self,
-        aabb: Union[torch.Tensor, List[float]],
-        num_dim: int = 3,
-        use_viewdirs: bool = True,
-        density_activation: Callable = lambda x: trunc_exp(x - 1),
-        radiance_activation: Callable = lambda x: F.sigmoid(x),
-        unbounded: bool = False,
-        base_resolution: int = 16,
-        max_resolution: int = 4096,
-        geo_feat_dim: int = 15,
-        n_levels: int = 16,
-        log2_hashmap_size: int = 19,
-        args =  None
-    ) -> None:
-        super().__init__()
-        if not isinstance(aabb, torch.Tensor):
-            aabb = torch.tensor(aabb, dtype=torch.float32)
-        self.register_buffer("aabb", aabb)
-        self.num_dim = num_dim
-        self.radiance_activation = radiance_activation
-        self.use_viewdirs = use_viewdirs
-        self.density_activation = density_activation
-        self.unbounded = unbounded
-        self.base_resolution = base_resolution
-        self.max_resolution = max_resolution
-        self.geo_feat_dim = geo_feat_dim
-        self.n_levels = n_levels
-        self.log2_hashmap_size = log2_hashmap_size
-        self.version = args.version        
-        self.radiance_activation = radiance_activation 
-        self.n_output_dim = 3
-                   
-        
-
-
-        per_level_scale = np.exp(
-            (np.log(max_resolution) - np.log(base_resolution)) / (n_levels - 1)
-        ).tolist()
-
-        if self.use_viewdirs:
-            self.direction_encoding = tcnn.Encoding(
-                n_input_dims=num_dim,
-                encoding_config={
-                    "otype": "Composite",
-                    "nested": [
-                        {
-                            "n_dims_to_encode": 3,
-                            "otype": "SphericalHarmonics",
-                            "degree": 4,
-                        },
-                        # {"otype": "Identity", "n_bins": 4, "degree": 4},
-                    ],
-                },
-            )
-
-        self.mlp_base = tcnn.NetworkWithInputEncoding(
-            n_input_dims=num_dim,
-            n_output_dims=1 + self.geo_feat_dim,
-            encoding_config={
-                "otype": "HashGrid",
-                "n_levels": n_levels,
-                "n_features_per_level": 2,
-                "log2_hashmap_size": log2_hashmap_size,
-                "base_resolution": base_resolution,
-                "per_level_scale": per_level_scale,
-            },
-            network_config={
-                "otype": "FullyFusedMLP",
-                "activation": "ReLU",
-                "output_activation": "None",
-                "n_neurons": 64,
-                "n_hidden_layers": 1,
-            },
-        )
-        if self.geo_feat_dim > 0:
-            self.mlp_head = tcnn.Network(
-                n_input_dims=(
-                    (
-                        self.direction_encoding.n_output_dims
-                        if self.use_viewdirs
-                        else 0
-                    )
-                    + self.geo_feat_dim
-                ),
-                n_output_dims=self.n_output_dim,
-                network_config={
-                    "otype": "FullyFusedMLP",
-                    "activation": "ReLU",
-                    "output_activation": "None",
-                    "n_neurons": 64,
-                    "n_hidden_layers": 2,
-                },
-            )
-
-    def query_density(self, x, return_feat: bool = False):
-        if self.unbounded:
-            x = contract_to_unisphere(x, self.aabb)
-        else:
-            aabb_min, aabb_max = torch.split(self.aabb, self.num_dim, dim=-1)
-            x = (x - aabb_min) / (aabb_max - aabb_min)
-        selector = ((x > 0.0) & (x < 1.0)).all(dim=-1)
-        x = (
-            self.mlp_base(x.view(-1, self.num_dim))
-            .view(list(x.shape[:-1]) + [1 + self.geo_feat_dim])
-            .to(x)
-        )
-        density_before_activation, base_mlp_out = torch.split(
-            x, [1, self.geo_feat_dim], dim=-1
-        )
-        density = (
-            self.density_activation(density_before_activation)
-            * selector[..., None]
-        )
-        if return_feat:
-            return density, base_mlp_out
-        else:
-            return density
-
-    def _query_rgb(self, dir, embedding, apply_act: bool = True):
-        # tcnn requires directions in the range [0, 1]
-        if self.use_viewdirs:
-            dir = (dir + 1.0) / 2.0
-            d = self.direction_encoding(dir.reshape(-1, dir.shape[-1]))
-            h = torch.cat([d, embedding.reshape(-1, self.geo_feat_dim)], dim=-1)
-        else:
-            h = embedding.reshape(-1, self.geo_feat_dim)
-        rgb = (
-            self.mlp_head(h)
-            .reshape(list(embedding.shape[:-1]) + [self.n_output_dim])
-            .to(embedding)
-        )
-        if apply_act:
-            rgb = self.radiance_activation(rgb)  
-
-        return rgb
-
-    def forward(
-        self,
-        positions: torch.Tensor,
-        directions: torch.Tensor = None,
-    ):
-        if positions.shape[0] == 0:
-            density = torch.zeros(0, device=positions.device)
-            color = torch.zeros(0, 1200, device=positions.device)
-            return color, density
-
-        if self.use_viewdirs and (directions is not None):
-            assert (
-                positions.shape == directions.shape
-            ), f"{positions.shape} v.s. {directions.shape}"
-            density, embedding = self.query_density(positions, return_feat=True)
-            rgb = self._query_rgb(directions, embedding=embedding)
-        else:
-            density, embedding = self.query_density(positions, return_feat=True)
-            rgb = self._query_rgb(directions, embedding=embedding)
-        return rgb, density  # type: ignore
-
-
-class NGPDensityField(torch.nn.Module):
-    """Instance-NGP Density Field used for resampling"""
-
-    def __init__(
-        self,
-        aabb: Union[torch.Tensor, List[float]],
-        num_dim: int = 3,
-        density_activation: Callable = lambda x: trunc_exp(x - 1),
-        unbounded: bool = False,
-        base_resolution: int = 16,
-        max_resolution: int = 128,
-        n_levels: int = 5,
-        log2_hashmap_size: int = 17,
-    ) -> None:
-        super().__init__()
-        if not isinstance(aabb, torch.Tensor):
-            aabb = torch.tensor(aabb, dtype=torch.float32)
-        self.register_buffer("aabb", aabb)
-        self.num_dim = num_dim
-        self.density_activation = density_activation
-        self.unbounded = unbounded
-        self.base_resolution = base_resolution
-        self.max_resolution = max_resolution
-        self.n_levels = n_levels
-        self.log2_hashmap_size = log2_hashmap_size
-
-        per_level_scale = np.exp(
-            (np.log(max_resolution) - np.log(base_resolution)) / (n_levels - 1)
-        ).tolist()
-
-        self.mlp_base = tcnn.NetworkWithInputEncoding(
-            n_input_dims=num_dim,
-            n_output_dims=1,
-            encoding_config={
-                "otype": "HashGrid",
-                "n_levels": n_levels,
-                "n_features_per_level": 2,
-                "log2_hashmap_size": log2_hashmap_size,
-                "base_resolution": base_resolution,
-                "per_level_scale": per_level_scale,
-            },
-            network_config={
-                "otype": "FullyFusedMLP",
-                "activation": "ReLU",
-                "output_activation": "None",
-                "n_neurons": 64,
-                "n_hidden_layers": 1,
-            },
-        )
-
-    def forward(self, positions: torch.Tensor):
-        if self.unbounded:
-            positions = contract_to_unisphere(positions, self.aabb)
-        else:
-            aabb_min, aabb_max = torch.split(self.aabb, self.num_dim, dim=-1)
-            positions = (positions - aabb_min) / (aabb_max - aabb_min)
-        selector = ((positions > 0.0) & (positions < 1.0)).all(dim=-1)
-        density_before_activation = (
-            self.mlp_base(positions.view(-1, self.num_dim))
-            .view(list(positions.shape[:-1]) + [1])
-            .to(positions)
-        )
-        density = (
-            self.density_activation(density_before_activation)
-            * selector[..., None]
-        )
-        return density
-    

codes/reconstruction/transientnerf/train_ours.py

@@ -1,521 +0,0 @@
-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
-
-    # When resuming (final=True), show progress from resumed step.
-    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)
-        # Use measurement peak (pre-log) to exclude low-signal / out-of-range pixels.
-        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:
-            # Avoid infinite loops where step never advances.
-            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()

codes/reconstruction/transientnerf/utils.py

@@ -1,539 +0,0 @@
-from datetime import datetime
-import random
-from typing import Optional
-import ast
-import configargparse
-import os
-import numpy as np
-import torch
-from loaders.utils import Rays, namedtuple_map
-from nerfacc.estimators.occ_grid import OccGridEstimator
-from nerfacc.grid import ray_aabb_intersect, traverse_grids
-from misc.transient_volrend import ( 
-rendering_transient_single_path)
-
-from torch.utils.tensorboard import SummaryWriter
-import shutil
-
-
-def set_random_seed(seed):
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-
-def render_transient(
-    # scene
-    radiance_field: torch.nn.Module,
-    occupancy_grid: OccGridEstimator,
-    rays: Rays,
-    # rendering options
-    near_plane = 0,
-    far_plane = 2**15,
-    render_step_size: float = 1e-3,
-    cone_angle: float = 0.0,
-    alpha_thre: float = 0.0,
-    # test options
-    # only useful for dnerf
-    chunk = 8192*128, 
-    use_normals = False, 
-    args = None
-):
-    """Render the pixels of an image."""
-    rays_shape = rays.origins.shape
-    if len(rays_shape) == 3:
-        height, width, _ = rays_shape
-        n_rays = height * width
-        rays = namedtuple_map(
-            lambda r: r.reshape([n_rays] + list(r.shape[2:])), rays
-        )
-    else:
-        n_rays, _ = rays_shape
-
-    results = []
-    
-    def rgb_sigma_fn(t_starts, t_ends, ray_indices):
-        t_origins = chunk_rays.origins[ray_indices]
-        t_dirs = chunk_rays.viewdirs[ray_indices]
-        positions = t_origins + t_dirs * (t_starts + t_ends)[:, None] / 2.0
-        rgbs, sigmas = radiance_field(positions, t_dirs)
-        return rgbs, sigmas.squeeze(-1)
-
-    
-    for i in range(0, n_rays, chunk):
-        chunk_rays = namedtuple_map(lambda r: r[i : i + chunk], rays)
-        
-        def sigma_fn(t_starts, t_ends, ray_indices):
-            t_origins = chunk_rays.origins[ray_indices]
-            t_dirs = chunk_rays.viewdirs[ray_indices]
-            positions = t_origins + t_dirs * (t_starts + t_ends)[:, None] / 2.0
-            sigmas = radiance_field.query_density(positions)
-            return sigmas.squeeze(-1)
-        
-        ray_indices, t_starts, t_ends = occupancy_grid.sampling(
-            chunk_rays.origins,
-            chunk_rays.viewdirs,
-            sigma_fn=sigma_fn,
-            near_plane=near_plane,
-            far_plane=far_plane,
-            render_step_size=render_step_size,
-            stratified=radiance_field.training,
-            cone_angle=cone_angle,
-            alpha_thre=alpha_thre,
-        )
-        rgb, opacity, depth, depth_variance, comp_weights, raw_rgbs = rendering_transient_single_path(
-            t_starts=t_starts,
-            t_ends=t_ends,
-            ray_indices=ray_indices,
-            n_rays=n_rays,
-            # radiance field
-            rgb_sigma_fn=rgb_sigma_fn,
-            # rendering options
-            render_bkgd=None,
-            args = args
-        )
-
-        chunk_results_single = [rgb, opacity, depth, depth_variance, comp_weights, raw_rgbs, len(t_starts)]
-        results.append(chunk_results_single)
-
-    colors_single, opacities_single, depths_single, depths_variance, densities, raw_rgbs, n_rendering_samples = [
-        torch.cat(r, dim=0) if isinstance(r[0], torch.Tensor) else r
-        for r in zip(*results)
-    ]
-    
-    normals_loss = 0 
-
-    colors = torch.reshape(colors_single, (-1, args.n_bins, 3))
-
-    return {'colors': colors.view((*rays_shape[:-1], -1)),
-            'opacities': opacities_single.view((*rays_shape[:-1], -1)),
-            'depths': depths_single.view((*rays_shape[:-1], -1)),
-            'depths_variance' : depths_variance.view((*rays_shape[:-1], -1)),
-            'n_rendering_samples': sum(n_rendering_samples),
-            'normals_loss': normals_loss,
-            'comp_weights': comp_weights, 
-            "raw_rgbs":raw_rgbs}
-
-
-def parse_list(arg):
-    try:
-        return ast.literal_eval(arg)
-    except (SyntaxError, ValueError):
-        raise configargparse.ArgumentTypeError(f"Invalid list format: {arg}")
-
-def str2bool(v):
-    if isinstance(v, bool):
-        return v
-    if v.lower() in ('yes', 'true', 't', 'y', '1'):
-        return True
-    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
-        return False
-    else:
-        raise configargparse.ArgumentTypeError('Boolean value expected.')
-
-
-def load_args(eval = False, parser= None):
-    # parser = configargparse.ArgumentParser()
-    if not eval:
-        parser = configargparse.ArgumentParser()
-
-    has_test_config = (
-        eval
-        and parser is not None
-        and hasattr(parser, "_option_string_actions")
-        and "--test_config" in parser._option_string_actions
-    )
-    my_config_default = None if has_test_config else "./configs/train/simulated/bench_two_views.ini"
-    parser.add('-c', '--my-config', 
-        is_config_file=True, 
-        default=my_config_default, 
-        help='Path to config file.'
-    )
-    parser.add_argument(
-        '--exp_name', 
-        type=str, 
-        default='lego_two_views', 
-        help='Experiment name.'
-    )
-    parser.add_argument(
-        "--aabb",
-        nargs='+',
-        type = lambda s: ast.literal_eval(s),
-        default="[-1.5,-1.5,-1.5,1.5,1.5, 1.5]",
-        help="AABB size.",
-    )
-    parser.add_argument(
-        "--test_chunk_size",
-        type=int,
-        default=512,
-        help="Test chunk size..",
-    )
-    parser.add_argument(
-        "--num_rays_per_batch",
-        type=int,
-        default=512,
-        help="Number of rays per batch.",
-    )
-    parser.add_argument(
-        "--starting_rays_per_pixel",
-        type=int,
-        default=1,
-        help="Starting rays per pixels.",
-    )
-    parser.add_argument(
-        "--tfilter_sigma",
-        type=int,
-        default=3,
-        help="Temporal filter standard deviation.",
-    )
-    parser.add_argument(
-        "--space_carving",
-        type=float,
-        default=7*1e-3,
-        help="Space carvig regaularization strength.",
-    )
-    # parser.add_argument(
-    #     "--dataset_scale",
-    #             type=int,
-    #             default=46,
-    #     help="Scale for all transient images.",
-    # )
-    parser.add_argument(
-        "--rfilter_sigma",
-        type=float,
-        default=0.15,
-        help="Spatial filter standard deviation.",
-    )
-    parser.add_argument(
-        "--exposure_time",
-        type=float,
-        default=0.01,
-        help="Exposure length per bin in meters.",
-    )
-    parser.add_argument(
-        "--lr",
-        type=float,
-        default=1e-3,
-        help="Learning rate.",
-    )
-    parser.add_argument(
-        "--steps_til_checkpoint",
-        type=int,
-        default=20000,
-        help="Steps per checkpoint.",
-    )
-    parser.add_argument(
-        "--n_bins",
-        type=int,
-        default=1200,
-        help="Number of bins.",
-    )
-    parser.add_argument(
-        "--img_shape",
-        type=int,
-        default=512,
-        help="Shape of training image.",
-    )
-    parser.add_argument(
-        "--sample_as_per_distribution",
-        action="store_true",
-        help="Sample as per distribution or uniformly.",
-    )
-    parser.add_argument(
-        "--render_n_samples",
-        type=int,
-        default=4096,
-        help="Num samples per ray.",
-    )
-    parser.add_argument(
-        "--exp",
-        type=str2bool,
-        default="true",
-        help="Use double exp.",
-    )
-    parser.add_argument(
-        "--max_steps",
-        type=int,
-        default=300000,
-        help="Max number of steps.",
-    )
-    parser.add_argument(
-        "--near_plane",
-        type=float,
-        default=0.0,
-        help="Near plane value.",
-    )
-    parser.add_argument(
-        "--alpha_thre",
-        type=float,
-        default=0,
-    )
-    parser.add_argument(
-        "--far_plane",
-        type=float,
-        default=float(2**15),
-        help="Far plane value.",
-    )
-    parser.add_argument(
-        "--version",
-        type=str,
-        default="simulated",
-        choices=["captured", "simulated"],
-        help="Dataset being trained, captured or simulated.",
-    )
-    parser.add_argument(
-        "--occ_thre",
-                type=float,
-                default=0.01,
-        help="Occupancy threshold",
-    )
-    parser.add_argument(
-        "--thold_warmup",
-                type=int,
-                default=-1,
-        help="Warmup period for the occupancy threshold.",
-    )
-    parser.add_argument(
-        "--final",
-        type=str2bool,
-        default="false",
-        help="If final version or debug mode (creates dated folder).",
-    )
-    parser.add_argument(
-        "--grid_resolution",
-                type=int,
-                default=128,
-        help="Occgrid resolution.",
-    )
-    parser.add_argument(
-        "--grid_nlvl",
-                type=int,
-                default=1,
-        help="Number of grid levels.",
-    )
-    parser.add_argument(
-        "--outpath",
-                type=str,
-                default="./results",
-        help="Path to results folder.",
-    )
-    parser.add_argument(
-        "--data_root_fp",
-                type=str,
-                default="./data/lego_data/lego_jsons/two_views",
-        help="Root of dataset directory (where the transforms directory is).",
-    )
-    parser.add_argument(
-        "--pulse_path",
-                type=str,
-                default="./datasets/pulse_low_flux.mat",
-        help="Path to pulse for captured dataset.",
-    )
-    parser.add_argument(
-        "--intrinsics",
-                type=str,
-                default="./data/lego_data/lego_jsons/two_views",
-        help="Path to intrinsics for captured dataset",
-    )
-    parser.add_argument(
-        "--pixels_to_plot",
-        nargs='+',
-        type = lambda s: ast.literal_eval(s),
-        default=[(16, 16), (20, 16), (28, 25)],
-        help="Pixels used for plotting in the summary.",
-    )
-    parser.add_argument(
-        "--img_scale",
-                type=int,
-                default=100,
-        help="Image scale used in summary.",
-    )
-    parser.add_argument(
-        "--num_views",
-                type=int,
-                default=2,
-        help="Number of views trained on.",
-    )
-    parser.add_argument(
-        "--img_shape_test",
-                type=int,
-                default=64,
-        help="Test image shape.",
-    )
-    parser.add_argument(
-        "--seed",
-                type=int,
-                default=42,
-        help="Seed.",
-    )
-    parser.add_argument(
-        "--device",
-                type=str,
-                default="cuda:7",
-        help="Device.",
-    )
-    parser.add_argument("--cone_angle", type=float, default=0.0)
-    parser.add_argument(
-        "--resume",
-        type=str,
-        default=None,
-        help="Path to a checkpoint directory to resume training from.",
-    )
-    args = parser.parse_args()
-    return args
-
-def make_save_folder(args):
-    now = datetime.now()
-    now = now.strftime("%m-%d_%H:%M:%S")
-    exp_name = args.exp_name + "_" + now
-    outpath = os.path.join(args.outpath, exp_name)
-    os.makedirs(args.outpath, exist_ok=True)
-    os.mkdir(outpath)
-    shutil.copy(args.my_config, os.path.join(outpath, "params.txt"))
-    
-    with open(os.path.join(outpath, "params_full.txt"), "w") as out_file:
-        param_list = []    
-        for key, value in vars(args).items():
-            if type(value) == list:
-                value = [eval(f"{x}") for x in value]
-            elif type(value) != int and type(value) != float:
-                value = str(value)
-                value = f"'{value}'"
-            param_list.append("%s= %s" % (key, value))
-         
-        out_file.write('\n'.join(param_list))
-    return outpath
-
-def make_save_folder_final(args, optimizer, scheduler, radiance_field, occupancy_grid):
-    outpath = os.path.join(args.outpath, args.exp_name)
-
-    if not os.path.isdir(outpath):
-
-        os.makedirs(outpath, exist_ok=True)
-        with open(os.path.join(outpath, "params_full.txt"), "w") as out_file:
-            param_list = []    
-            for key, value in vars(args).items():
-                if type(value) != int and type(value) != float:
-                    value = str(value)
-                    value = f"'{value}'"
-                param_list.append("%s= %s" % (key, value))
-            
-            out_file.write('\n'.join(param_list))
-        step = 0
-        writer = SummaryWriter(log_dir=outpath)
-
-    else:
-        ckpt_path_var = os.path.join(outpath, 'variables.pth')
-        if not os.path.isfile(ckpt_path_var):
-            print(f"warning: '{ckpt_path_var}' not found; starting fresh in existing directory.")
-            step = 0
-            writer = SummaryWriter(log_dir=outpath)
-            return writer, step, outpath
-
-        ckpt = torch.load(ckpt_path_var, map_location="cpu")
-        step = int(ckpt.get('step', 0))
-
-        ckpt_path_rf = os.path.join(outpath, 'radiance_field_%04d.pth' % (step))
-        ckpt_path_oc = os.path.join(outpath, 'occupancy_grid_%04d.pth' % (step))
-        ckpt_path_opt = os.path.join(outpath, 'optimizer_%04d.pth' % (step))
-        ckpt_path_sch = os.path.join(outpath, 'scheduler_%04d.pth' % (step))
-
-        if not (os.path.isfile(ckpt_path_rf) and os.path.isfile(ckpt_path_oc)):
-            print(
-                "warning: model checkpoint files missing for saved step; "
-                "starting fresh optimizer/model state."
-            )
-            step = 0
-            writer = SummaryWriter(log_dir=outpath)
-            return writer, step, outpath
-
-        ckpt = torch.load(ckpt_path_rf, map_location=args.device)
-        radiance_field.load_state_dict(ckpt)
-        radiance_field = radiance_field.to(args.device)
-
-        ckpt = torch.load(ckpt_path_oc, map_location=args.device)
-        occupancy_grid.load_state_dict(ckpt)
-        occupancy_grid = occupancy_grid.to(args.device)
-
-        if os.path.isfile(ckpt_path_opt):
-            ckpt = torch.load(ckpt_path_opt, map_location=args.device)
-            optimizer.load_state_dict(ckpt)
-        else:
-            print(f"warning: optimizer checkpoint missing at '{ckpt_path_opt}', using fresh optimizer state.")
-
-        if os.path.isfile(ckpt_path_sch):
-            ckpt = torch.load(ckpt_path_sch, map_location=args.device)
-            scheduler.load_state_dict(ckpt)
-        else:
-            print(f"warning: scheduler checkpoint missing at '{ckpt_path_sch}', using fresh scheduler state.")
-
-        print(f"previous checkpoint loaded; current step: {step}")
-        writer = SummaryWriter(log_dir=outpath)
-    
-    return writer, step, outpath
-
-
-def resume_training(args, optimizer, scheduler, radiance_field, occupancy_grid):
-    """Load a previous checkpoint and prepare writer/step/outpath."""
-    ckpt_dir = args.resume
-    if ckpt_dir is None:
-        raise ValueError("args.resume is None, cannot resume.")
-    if not os.path.isdir(ckpt_dir):
-        raise FileNotFoundError(f"Checkpoint directory not found: {ckpt_dir}")
-
-    variables_path = os.path.join(ckpt_dir, "variables.pth")
-    step = 0
-    rays_per_pixel = None
-    if os.path.isfile(variables_path):
-        ckpt_vars = torch.load(variables_path, map_location="cpu")
-        step = ckpt_vars.get("step", 0)
-        rays_per_pixel = ckpt_vars.get("rays_per_pixel")
-    else:
-        ckpt_steps = []
-        for name in os.listdir(ckpt_dir):
-            if name.startswith("radiance_field_") and name.endswith(".pth"):
-                try:
-                    ckpt_steps.append(int(name.split("_")[-1].split(".")[0]))
-                except ValueError:
-                    continue
-        if not ckpt_steps:
-            raise FileNotFoundError(
-                "No checkpoint files found to resume from in "
-                f"{ckpt_dir}. Expected radiance_field_XXXX.pth."
-            )
-        step = max(ckpt_steps)
-
-    rf_path = os.path.join(ckpt_dir, f"radiance_field_{step:04d}.pth")
-    oc_path = os.path.join(ckpt_dir, f"occupancy_grid_{step:04d}.pth")
-    opt_path = os.path.join(ckpt_dir, f"optimizer_{step:04d}.pth")
-    sch_path = os.path.join(ckpt_dir, f"scheduler_{step:04d}.pth")
-
-    for required_path in [rf_path, oc_path]:
-        if not os.path.isfile(required_path):
-            raise FileNotFoundError(f"Missing checkpoint file: {required_path}")
-
-    radiance_field.load_state_dict(
-        torch.load(rf_path, map_location=args.device)
-    )
-    radiance_field = radiance_field.to(args.device)
-
-    occupancy_grid.load_state_dict(
-        torch.load(oc_path, map_location=args.device)
-    )
-    occupancy_grid = occupancy_grid.to(args.device)
-
-    if os.path.isfile(opt_path):
-        optimizer.load_state_dict(torch.load(opt_path, map_location=args.device))
-    else:
-        print(f"warning: missing optimizer checkpoint '{opt_path}', using fresh optimizer state.")
-
-    if os.path.isfile(sch_path):
-        scheduler.load_state_dict(torch.load(sch_path, map_location=args.device))
-    else:
-        print(f"warning: missing scheduler checkpoint '{sch_path}', using fresh scheduler state.")
-
-    writer = SummaryWriter(log_dir=ckpt_dir)
-    args.outpath = ckpt_dir
-    return writer, step, ckpt_dir, rays_per_pixel
-    
-if __name__=="__main__":
-    pass