Add reconstruction code

codes/reconstruction/FlyingWithPhotons/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+results/
+exp/
+runs/
+*.pth
+*.ckpt

codes/reconstruction/FlyingWithPhotons/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

codes/reconstruction/FlyingWithPhotons/README.md

@@ -0,0 +1,72 @@
+# FlyingWithPhotons 最小复现版
+
+保留原生训练、模型与采样代码；共同指标集中在 `evaluation/`，唯一评价入口为 `eval.py`。
+
+在项目根目录执行；服务器模型解释器为 `/work/runrong/.conda/envs/Fwp/bin/python`：
+
+```bash
+export STB_METRICS_PYTHON=/work/runrong/.conda/envs/transientangelo/bin/python
+python train_ours.py -c configs/train.ini
+python eval.py render -c configs/train.ini --config configs/eval.ini \
+  --checkpoint_dir /absolute/checkpoint_directory --step 300000 \
+  --output /absolute/new_result_directory
+```
+
+checkpoint 目录的训练归一化记录（或原 `params_full.txt`）必须与配置中的 dataset_scale、gamma 一致。
+
+示例为 design_floor1 / 10 视角，参数模板来自原 fence_box 配置，不代表论文完整历史配置。其他场景、3/5 视角需使用真实训练参数和 canonical 测试位姿。保留单值/二维硬件偏移的兼容处理；训练时的编码、裁剪与原生射线模型未重写。
+
+## 共同评价协议（V4）
+
+`eval.py` 是唯一公开评价入口，`render` 和 `saved` 最终均调用 `evaluation/evaluator.py`。`evaluation/renderer.py` 仅适配本方法的模型和射线采样；直方图和图像指标实现与其他两个项目相同。原来的两个 `shared_*` 包、`evaluate_metrics_shared.py`、FWP 的 `eval_ours.py` 和独立旧评分分支已移除。
+
+### 强度尺度与直方图 PSNR
+
+评分前逐 bin 恢复全曝光光子计数：
+
+```
+trnerf / transientangelo: prediction_counts = prediction_encoded * actual_training_scale
+FlyingWithPhotons:        prediction_counts = prediction_encoded ** training_gamma * dataset_scale
+reference_counts:        共同参考缓存中的已标定、未独立归一化的光子计数
+MSE = mean((prediction_counts - reference_counts)^2)  # 共同有效像素的全部 bins / channels
+histogram_psnr = 20*log10(P_scene) - 10*log10(MSE)
+```
+
+`P_scene` 固定于同一场景的十视角训练候选池，在三种方法及 3/5/10 视角配置之间共用。预测峰值、测试最大值和每视角拟合系数都不用于确定它。预测直方图不做上限裁剪、显示 gamma 或曝光拟合；FWP 的逆训练 gamma 在积分前逐 bin 执行。缺失实际训练尺度时直接报错，禁止用测试集最大值代替。TN/FWP 新训练会记录 `image_metric_normalization.json`；TA 将训练尺度写入 checkpoint。历史权重须提供经过核实的训练常数，代码不能从测试集推断它。
+
+共同参考由校准后全计数 GT 生成；掩码为硬件有效像素、GT 峰值 ≥100、正信号的交集，独立于预测。直方图峰值 `P_scene` 与积分图像尺度 `D_scene` 是两个不同的固定量。显示图像 PSNR、SSIM、LPIPS 沿用整理前 V4 所采用的显示变换，另报无显示 gamma 的 `linear_psnr`。这些图像分数不应标成直方图 PSNR。SSIM 使用完整有效 7×7 窗口；LPIPS 使用统一环境的 VGG v0.1 / FP32。
+
+### 对 Q6–Q8 的代码说明
+
+- **Q6：不是未经修改的发布版 eval.py。** 当前只提供统一 V4；取消旧 `scale_int` 和动态预测/GT 峰值评分。GT、掩码、固定场景尺度来自同一份 contract。原生测试均执行 30 次前向：TN 每次重新获取带抖动射线，TA 复用同一抖动批次，FWP 复用像素射线。因此不能把三者概括为“30 次独立像素抖动”。这些方法自身的采样逻辑保留。
+- **Q7：内部归一化不直接作为比较尺度。** TN/TA 预测乘回实际训练常数；FWP 逐 bin 逆训练 gamma 并乘回训练 dataset_scale；共同 GT 直接使用计数。测试加载器内部即使独立归一化，也不会把它的归一化 GT 或最大值用于评分。这解决当前流程中由训练/测试独立归一化引入的比较尺度不一致。
+- **Q8：三种视角设置均使用共同的 canonical test.json 帧及原始位姿。** 九场景合计 158 帧，逐场景 contract 强制核对完整唯一帧集合及位姿，拒绝只评部分帧或同名不同位姿。低视角下剩余训练候选帧不额外加入测试；十视角候选池仍用于冻结共同评价尺度，属于评价标定数据，不作为低视角方法的额外训练输入。
+
+以上描述的是修订后的代码协议，不能用来证明历史论文分数已经重算。此次目录整理没有重新训练模型，也没有完成九场景全量模型评测。
+
+### 输出、环境与迁移
+
+输出为 `prediction_manifest.json` 和 `unified_metrics/` 下的协议记录、逐视角指标、完整集合汇总及浮点评分数组。记录含训练尺度、gamma、共同参考/掩码校验和、评分代码哈希和解释器路径。可加 `--save-predictions` 保存未裁剪编码直方图以便复算；不保存旧口径指标和旧图表。已有结果目录禁止覆盖。
+
+三个项目必须使用同一个图像评价环境。服务器运行前设置：
+
+```bash
+export STB_METRICS_PYTHON=/work/runrong/.conda/envs/transientangelo/bin/python
+```
+
+迁移机器后将它改为共同评价环境的 Python 绝对路径。数据、标定、权重、共同参考缓存不复制进代码包；README 中的示例配置仍指向服务器的实际路径，发布数据时需同时提供对应 contract/GT 缓存并改为新路径。每种方法使用同一场景的同一份 contract。保存目录名中的旧日期仅是外部参考数据的位置，不再是代码导入依赖。
+
+评分已有预测统一使用 `python eval.py saved --help` 查看参数，例如：
+
+```bash
+python eval.py saved --prediction-dir /absolute/predictions \
+  --prediction-manifest /absolute/predictions/prediction_manifest.json \
+  --prediction-scale ACTUAL_TRAINING_SCALE --prediction-gamma 1 \
+  --prediction-bin-width-s 7.5e-10 \
+  --shared-reference-contract /absolute/reference/contract.json \
+  --output /absolute/new_scores --device cpu
+```
+
+FWP 编码输出填写真实训练 gamma；已经恢复完整计数的导出填写 scale=1、gamma=1。有单位记录的 manifest 与命令参数冲突时会报错。
+
+`requirements.txt` 保留各模型依赖。先安装匹配 CUDA 11.8 的 PyTorch 2.5.1 / torchvision 0.20.1，再安装其余依赖和 CUDA 扩展；模型环境可以不同，图像评价子进程保持一致。训练日志中的训练集损失/PSNR 仅用于优化诊断，不是测试集 benchmark 分数。

codes/reconstruction/FlyingWithPhotons/configs/eval.ini

@@ -0,0 +1,6 @@
+# STB design_floor1 / 10 views example. See README for configuration origin.
+warped = True
+t_min_test = 0
+t_max_test = 672
+transforms_path = "/work/runrong/project_all/shared_transient_metrics_20261016/references/design_floor1/poses/ten_views/transforms_test.json"
+shared_reference_contract = "/work/runrong/project_all/shared_transient_metrics_20261016/references/design_floor1/contract.json"

codes/reconstruction/FlyingWithPhotons/configs/train.ini

@@ -0,0 +1,55 @@
+# STB design_floor1 / 10 views example. See README for configuration origin.
+exp_name = "design_floor1_10views"
+dataset_scale = 1000
+meas_peak_min = 20
+img_scale = 100
+data_root = "/work/runrong/project_all/shared_transient_metrics_20261016/references/design_floor1/poses/ten_views"
+measurement_root = "/work/runrong/dataset/paper_data/design_floor1"
+version = captured
+exposure_time = 0.11242217175
+n_bins = 672
+t_min = 0
+t_max = 672
+thold_warmup = 20000
+gamma = 2
+aabb = "[-30.723363, -32.531209, -1.819858, 30.377352, 12.024207, 9.260004]"
+depth_global_offset_bins = 17
+depth_offset_valid_max = 10.0
+img_height = 192
+img_width = 256
+img_height_test = 192
+img_width_test = 256
+device = cuda:0
+prop_delay = "True"
+view_time_align = "True"
+view_time_align_quantile = 0.7
+view_time_align_target_bin = -1
+view_time_align_max_abs_bins = 96
+streaming = False
+summary = "True"
+outpath = "./results"
+steps_till_checkpoint = 10000
+summary_freq = 10000
+max_steps = 150010
+target_sample_batch_size = 262054
+seed = 42
+pixels_to_plot = ["(40, 60)", "(60, 55)", "(30, 55)"]
+hardware_shift = "True"
+hardware_shift_downsample = 8
+hardware_shift_max_abs_bins = 12
+intrinsics_path = "/work/runrong/dataset/intrinsics.npy"
+alpha_thre = 0
+lr = 0.001
+weight_decay = 1e-6
+render_step_size = 5e-2
+cone_angle = 0
+near_plane = 0.0
+far_plane = 33
+init_batch_size = 32
+occ_thre = 0.001
+grid_resolution = 256
+grid_nlvl = 2
+img_shape = 256
+img_shape_test = 256
+final = True
+depth_offset_map = "/work/runrong/dataset/paper1_data/offset.txt"

codes/reconstruction/FlyingWithPhotons/eval.py

@@ -0,0 +1,5 @@
+"""The only public evaluation entry: render predictions or score saved histograms."""
+from evaluation.cli import main
+
+if __name__ == "__main__":
+    main()

codes/reconstruction/FlyingWithPhotons/evaluation/__init__.py

@@ -0,0 +1,4 @@
+"""Common count-domain transient evaluation, independent of model training units."""
+PROTOCOL = 'shared_transient_counts_v4_20261016'
+TRANSIENT_KEYS = ('histogram_psnr', 'histogram_mse_counts', 'histogram_mae_counts',
+                  'depth_l1_m', 'transient_iou')

codes/reconstruction/FlyingWithPhotons/evaluation/arguments.py

@@ -0,0 +1,64 @@
+"""Model rendering options; all scoring options are fixed by the reference contract."""
+import ast
+import configargparse
+from utils import str2bool, load_args
+
+def load_eval_args():
+    parser = configargparse.ArgumentParser()
+    parser.add_argument("--output", "--shared-output-dir", "--shared_output_dir", dest="shared_output_dir", default=None,
+                        help="Fresh output directory for unified V4 metrics.")
+    parser.add_argument(
+        "--shared-reference-contract", "--shared_reference_contract",
+        dest="shared_reference_contract", default=None,
+        help="Scene-bound shared reference contract. Required for a scene without a verified default.",
+    )
+    parser.add('--config', '-tc', '--test_config', dest='test_config', 
+        is_config_file=True, 
+        default=None, 
+        help='Test config path.'
+    )
+    parser.add_argument(
+        "--transforms_path",
+        type=str,
+        default="",
+        help="Path to evaluation transforms file.",
+    )
+    parser.add_argument(
+        "--checkpoint_dir",
+        type=str,
+        default="/",
+        help="Directory of the checkpoint.",
+    )
+    parser.add_argument(
+        "--warped",
+        type=str2bool,
+        default="true",
+        help="Render warped or unwarped transients.",
+    )
+    parser.add_argument(
+        "--t_min_test",
+        type=int,
+        default=200,
+        help="Render min bin number.",
+    )
+    parser.add_argument(
+        "--t_max_test",
+        type=int,
+        default=700,
+        help="Render max bin number.",
+    )
+    parser.add_argument(
+        "--unwarp_method",
+        type=str,
+        default="depth",
+        help="Method to perform unwarping.",
+    )
+    parser.add_argument(
+        "--step",
+        type=int,
+        default=80000,
+        help="Which step to evaluate.",
+    )
+    parser.add_argument("--save-predictions", action="store_true", help="Save unmodified encoded histograms for re-scoring")
+    args = load_args(eval=True, parser=parser)
+    return args

codes/reconstruction/FlyingWithPhotons/evaluation/cli.py

@@ -0,0 +1,54 @@
+"""One entry point and one protocol, for all three methods."""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('source', choices=('render', 'saved'),
+                        help='render a checkpoint, or score unmodified saved histograms')
+    if len(sys.argv) < 2 or sys.argv[1] in ('-h', '--help'):
+        parser.print_help()
+        return
+    mode = parser.parse_args(sys.argv[1:2]).source
+    sys.argv = [sys.argv[0]] + sys.argv[2:]
+    from . import renderer
+    if mode == 'render':
+        return renderer.main()
+    from .evaluator import EvaluationRun
+    from .io import load_histogram, write_json, sha256
+    p = argparse.ArgumentParser(description='Score saved histograms with the same V4 evaluator as render.')
+    p.add_argument('--prediction-dir', required=True)
+    p.add_argument('--prediction-pattern', default='{view}_transient_array.npy')
+    p.add_argument('--prediction-scale', type=float, required=True,
+                   help='ACTUAL TRAINING normalization; 1 only for full-count exports')
+    p.add_argument('--prediction-gamma', type=float, default=1.)
+    p.add_argument('--prediction-bin-width-s', type=float, required=True)
+    p.add_argument('--prediction-manifest', required=True,
+                   help='Actual rendered frames and poses, in prediction-file order')
+    p.add_argument('--shared-reference-contract', required=True)
+    p.add_argument('--output', required=True)
+    p.add_argument('--device', default='cpu')
+    a = p.parse_args()
+    a.bin_width_s_loader = a.prediction_bin_width_s
+    a.n_bins = json.loads(Path(a.shared_reference_contract).read_text())['n_bins']
+    manifest = json.loads(Path(a.prediction_manifest).read_text())
+    if (Path(a.output)/'prediction_manifest.json').resolve() == Path(a.prediction_manifest).resolve():
+        raise ValueError('Use a separate output directory to preserve the source manifest')
+    # Generated manifests are binding; do not silently override their physical units.
+    for key, actual in [('prediction_scale', a.prediction_scale),
+                        ('prediction_gamma', a.prediction_gamma),
+                        ('bin_width_s', a.prediction_bin_width_s)]:
+        if key in manifest and float(manifest[key]) != actual:
+            raise ValueError('Prediction manifest disagrees with '+key)
+    frames = manifest['frames']
+    run = EvaluationRun(renderer.PROJECT, a, a.output, frames, a.prediction_scale,
+                        a.prediction_gamma, rendering=manifest.get('rendering'))
+    run.evaluator.metadata.update(prediction_manifest=str(Path(a.prediction_manifest).resolve()),
+                                  prediction_manifest_sha256=sha256(a.prediction_manifest))
+    write_json(run.evaluator.output/'evaluation_protocol.json', run.evaluator.metadata)
+    for i, frame in enumerate(frames):
+        path = Path(a.prediction_dir)/a.prediction_pattern.format(view=i, stem=Path(frame['file_path']).stem)
+        run.score(load_histogram(path), i)
+    print(run.finish())

codes/reconstruction/FlyingWithPhotons/evaluation/core.py

@@ -0,0 +1,81 @@
+"""Pure NumPy scoring. No data-dependent exposure fitting or upper clipping."""
+import numpy as np
+
+C = 299792458.0
+
+def positive(x, name):
+    x = float(x)
+    if not np.isfinite(x) or x <= 0:
+        raise ValueError(name + ' must be finite and positive')
+    return x
+
+def histogram(x):
+    if hasattr(x, 'detach'):
+        x = x.detach().cpu().numpy()
+    x = np.asarray(x)
+    if x.ndim == 3:
+        x = x[..., None]
+    if x.ndim != 4 or x.shape[-1] not in (1, 3) or min(x.shape) <= 0:
+        raise ValueError('Expected H x W x T x (1 or 3) histogram')
+    return x
+
+def decode(x, scale, gamma=1.0):
+    """Inverse training encoding, applied per bin before any summation."""
+    scale, gamma = positive(scale, 'training scale'), positive(gamma, 'gamma')
+    x = np.asarray(x, dtype=np.float64)
+    if not np.isfinite(x).all() or np.any(x < 0):
+        raise ValueError('Histogram must be finite and nonnegative, even outside the mask')
+    y = np.power(x, gamma) * scale if gamma != 1.0 else x * scale
+    if not np.isfinite(y).all():
+        raise ValueError('Count decoding overflow')
+    return y
+
+def score_histograms(prediction, reference, mask, *, prediction_scale,
+                     reference_scale, histogram_peak, bin_width_s,
+                     prediction_gamma=1.0, row_chunk=4):
+    """MSE over all bins/channels of GT-valid pixels, using a frozen train peak.
+
+    A one-channel capture is broadcast to RGB when necessary. All RGB channels
+    enter MSE; peak depth uses their arithmetic mean. Chunking bounds RAM use.
+    """
+    pred, ref = histogram(prediction), histogram(reference)
+    if pred.shape[:3] != ref.shape[:3]:
+        raise ValueError('Prediction/reference pixel grid or temporal window differs')
+    mask = np.asarray(mask)
+    if mask.shape != pred.shape[:2] or not np.isin(mask, [0, 1]).all():
+        raise ValueError('Expected binary HW reference-only mask')
+    mask = mask.astype(bool)
+    if not mask.any():
+        raise ValueError('No valid reference pixels')
+    peak = positive(histogram_peak, 'fixed histogram peak')
+    dt = positive(bin_width_s, 'physical bin width')
+    if int(row_chunk) != row_chunk or row_chunk < 1:
+        raise ValueError('row_chunk must be a positive integer')
+    h, w, t = pred.shape[:3]
+    channels = max(pred.shape[-1], ref.shape[-1])
+    ip, ig = np.zeros((h,w,3)), np.zeros((h,w,3))
+    dp, dg = np.zeros((h,w)), np.zeros((h,w))
+    squared = absolute = intersection = union = 0.0
+    for start in range(0,h,int(row_chunk)):
+        sl = slice(start,min(h,start+int(row_chunk)))
+        p = decode(pred[sl], prediction_scale, prediction_gamma)
+        g = decode(ref[sl], reference_scale)
+        ip[sl] = np.broadcast_to(p.sum(axis=-2), (len(p),w,3))
+        ig[sl] = np.broadcast_to(g.sum(axis=-2), (len(g),w,3))
+        dp[sl] = p.mean(axis=-1).argmax(axis=-1) * C * dt / 2.0
+        dg[sl] = g.mean(axis=-1).argmax(axis=-1) * C * dt / 2.0
+        a,b = np.broadcast_arrays(p[mask[sl]], g[mask[sl]])
+        error = a-b
+        squared += np.square(error).sum(dtype=np.float64)
+        absolute += np.abs(error).sum(dtype=np.float64)
+        intersection += np.minimum(a,b).sum(dtype=np.float64)
+        union += np.maximum(a,b).sum(dtype=np.float64)
+    count = int(mask.sum()) * t * channels
+    mse = squared/count
+    psnr = float(20*np.log10(peak)-10*np.log10(mse)) if mse>0 else float('inf')
+    scores = dict(histogram_psnr=psnr, histogram_mse_counts=float(mse),
+        histogram_mae_counts=float(absolute/count),
+        depth_l1_m=float(np.abs(dp[mask]-dg[mask]).mean()),
+        transient_iou=float(intersection/union) if union>0 else 1.0)
+    return scores, dict(prediction=ip, reference=ig, mask=mask,
+                        prediction_depth=dp, reference_depth=dg)

codes/reconstruction/FlyingWithPhotons/evaluation/evaluator.py

@@ -0,0 +1,161 @@
+"""Frame-bound common scoring adapter for all three native and saved entrances."""
+import json
+import operator
+import os
+from pathlib import Path
+import subprocess
+import sys
+import numpy as np
+from . import PROTOCOL
+from .core import C,positive,score_histograms
+from .io import sha256,verified,load_histogram,write_json
+
+BASE=Path(__file__).resolve().parent.parent
+PYTHON=os.environ.get('STB_METRICS_PYTHON') or '/work/runrong/.conda/envs/transientangelo/bin/python'
+
+def resolve_contract(args):
+    explicit=getattr(args,'shared_reference_contract',None) or os.environ.get('SHARED_REFERENCE_CONTRACT')
+    if explicit:return Path(explicit).resolve()
+    measurement=getattr(args,'measurement_root',None)
+    matches=[]
+    for p in Path(os.environ.get('STB_REFERENCE_ROOT', str(BASE/'references'))).glob('*/contract.json'):
+        d=json.loads(p.read_text())
+        if measurement and Path(d['measurement_root']).resolve()==Path(measurement).resolve():matches.append(p)
+    if len(matches)!=1:
+        raise ValueError('A prepared V4 canonical reference is required. Pass --shared-reference-contract '
+                         'with the matching contract.json; no legacy/test-scale fallback.')
+    return matches[0]
+
+class UnifiedEvaluator:
+    def __init__(self,project,args,output_dir,frames):
+        if project not in ('trnerf','transientangelo','FlyingWithPhotons'):raise ValueError('Unknown project')
+        if not Path(PYTHON).is_file():raise FileNotFoundError('Set STB_METRICS_PYTHON to the common evaluation Python: '+str(PYTHON))
+        self.project=project;self.path=resolve_contract(args);self.digest=sha256(self.path)
+        self.contract=c=json.loads(self.path.read_text())
+        if c.get('protocol')!=PROTOCOL:
+            raise ValueError('V4 needs a histogram reference contract, not an intensity-only V2/V3 contract')
+        self.peak=positive(c['histogram_peak'],'fixed training histogram peak')
+        self.display_scale=positive(c['display_scale'],'fixed training display scale')
+        dt=positive(c['bin_width_s'],'reference bin width')
+        if not c.get('training_frames') or not c.get('scale_policy') or c.get('time_start')!=0:
+            raise ValueError('Missing frozen training-scale provenance or invalid time origin')
+        for k in ('height','width','n_bins'):
+            if type(c[k]) is not int or c[k]<=0:raise ValueError('Invalid '+k)
+        measurement=getattr(args,'measurement_root',None)
+        if measurement and Path(measurement).resolve()!=Path(c['measurement_root']).resolve():
+            raise ValueError('Measurement scene does not match reference')
+        intrinsics=getattr(args,'intrinsics',None) or getattr(args,'intrinsics_path',None)
+        if intrinsics and sha256(intrinsics)!=c['intrinsics_sha256']:raise ValueError('Calibration mismatch')
+        actual=getattr(args,'bin_width_s_loader',None)
+        if actual is None:actual=getattr(args,'bin_width_s',None)
+        if actual is None and hasattr(args,'exposure_time'):
+            actual=float(args.exposure_time)/(C/2 if project=='FlyingWithPhotons' else C)
+        if actual is None or not np.isclose(float(actual),dt,rtol=1e-6,atol=0):raise ValueError('Physical bin width mismatch/missing')
+        # FWP uses one-way range/bin; verify it even when a loader override exists.
+        if project=='FlyingWithPhotons' and hasattr(args,'exposure_time'):
+            if not np.isclose(float(args.exposure_time)/(C/2),dt,rtol=1e-6,atol=0):raise ValueError('FWP exposure_time mismatch')
+        for name,want in [('n_bins',c['n_bins']),('t_min_test',0),('t_max_test',c['n_bins']),
+                          ('img_height_test',c['height']),('img_width_test',c['width'])]:
+            actual=getattr(args,name,None)
+            if actual is not None and int(actual)!=want:raise ValueError('Common window/grid mismatch: '+name)
+        frames=list(frames);records={Path(f['file_path']).stem:f for f in c['frames']}
+        ids=[Path(f['file_path']).stem for f in frames]
+        if (not frames or len(records)!=len(c['frames']) or len(set(ids))!=len(ids)
+                or set(ids)!=set(records)):
+            raise ValueError('Evaluation must declare the complete, unique canonical test frame set')
+        self.frames=[]
+        for f,key in zip(frames,ids):
+            r=records[key];pose=np.asarray(f['transform_matrix']);rp=np.asarray(r['transform_matrix'])
+            if pose.shape!=(4,4) or rp.shape!=(4,4) or not np.isfinite(pose).all() or not np.allclose(pose,rp,rtol=0,atol=1e-7):
+                raise ValueError('Test frame pose differs from canonical reference: '+key)
+            self.frames.append(r)
+        self.output=Path(output_dir)/'unified_metrics'
+        if (self.output/'evaluation_protocol.json').exists():
+            raise FileExistsError('Use a fresh V4 output directory; existing scores are not overwritten')
+        self.output.mkdir(parents=True,exist_ok=True);self.rows=[]
+        self.device=os.environ.get('STB_METRICS_DEVICE') or str(getattr(args,'device','cpu'))
+        self.metadata=dict(protocol=PROTOCOL,project=project,reference_contract=str(self.path),
+            reference_sha256=self.digest,scene_id=c['scene_id'],histogram_peak=self.peak,
+            display_scale=self.display_scale,mask_policy=c['mask_policy'],n_bins=c['n_bins'],bin_width_s=dt,
+            frames=[f['file_path'] for f in self.frames],
+            histogram_psnr='20log10(frozen train peak)-10log10(mean squared count error); all valid bins/channels; no upper clipping/gamma',
+            depth='argmax of channel-mean full-count histogram; bin_index*c*dt/2, metres; canonical GT mask',
+            aggregation='arithmetic mean of per-view metrics, only complete frame sets receive an aggregate',
+            training_scale_policy='explicit actual training scale; never test maximum',
+            evaluator_python=PYTHON,image_metrics_device=self.device,code_sha256={f:sha256(Path(__file__).with_name(f)) for f in ('core.py','evaluator.py','worker.py')},
+            image_code_sha256=sha256(Path(__file__).with_name('image_metrics.py')))
+        from .image_metrics import PROTOCOL_INFO
+        self.metadata['image_metric_definition']=dict(PROTOCOL_INFO,scale=self.display_scale)
+        self.metadata['checkpoint_dir']=getattr(args,'checkpoint_dir',None)
+        self.metadata['checkpoint_step']=getattr(args,'step',None)
+        self.metadata['rendering_note']='Native renderers retain their method-specific sampling; all default native V4 runs use 30 forward repetitions. Saved-output runs must record their rendering settings separately.'
+        write_json(self.output/'evaluation_protocol.json',self.metadata)
+
+    def score(self,prediction_histogram,frame_index,prediction_scale,prediction_gamma=1.0):
+        if isinstance(frame_index,(bool,np.bool_)):raise IndexError('Boolean frame index')
+        i=operator.index(frame_index)
+        if i<0 or i>=len(self.frames):raise IndexError(i)
+        if sha256(self.path)!=self.digest:raise ValueError('Reference contract changed during evaluation')
+        f=self.frames[i];c=self.contract
+        hp=verified(self.path.parent/f['histogram_path'],f['histogram_sha256'])
+        mp=verified(self.path.parent/f['mask_path'],f['mask_sha256'])
+        reference=load_histogram(hp);mask=np.load(mp,allow_pickle=False)
+        if reference.shape[:3]!=(c['height'],c['width'],c['n_bins']):raise ValueError('Reference shape differs from contract')
+        scores,arrays=score_histograms(prediction_histogram,reference,mask,
+            prediction_scale=prediction_scale,reference_scale=f['reference_scale'],
+            histogram_peak=self.peak,bin_width_s=c['bin_width_s'],prediction_gamma=prediction_gamma)
+        inp=self.output/f'view{i}_inputs.npz';result=self.output/f'view{i}_image_scores.json';display=self.output/f'view{i}_display.npz'
+        np.savez_compressed(inp,**arrays)
+        env=dict(os.environ);env['PYTHONPATH']=str(BASE)+os.pathsep+env.get('PYTHONPATH','')
+        if self.device=='cpu':env['CUDA_VISIBLE_DEVICES']=''
+        proc=subprocess.run([PYTHON,'-m','evaluation.worker',
+            '--input',str(inp),'--output',str(result),'--display',str(display),
+            '--scale',str(self.display_scale),'--device',self.device],env=env,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True)
+        if proc.returncode:raise RuntimeError('Common image scorer failed: '+proc.stdout[-5000:])
+        scores.update(json.loads(result.read_text()))
+        row=dict(view=i,frame=f['file_path'],prediction_scale=float(prediction_scale),
+                 prediction_gamma=float(prediction_gamma),valid_pixels=int(mask.sum()),**scores)
+        self.rows=[r for r in self.rows if r['view']!=i]+[row];self.rows.sort(key=lambda r:r['view'])
+        write_json(self.output/'metrics_per_view.json',self.rows)
+        complete=len(self.rows)==len(self.frames)
+        write_json(self.output/'progress.json',dict(completed_views=len(self.rows),expected_views=len(self.frames),complete=complete))
+        if complete:
+            write_json(self.output/'metrics_aggregate.json',{k:float(np.mean([r[k] for r in self.rows])) for k in scores})
+        with np.load(display) as d:p,g=d['prediction'],d['reference']
+        return dict(scores,psnr=scores['image_psnr'],prediction_display=p,reference_display=g,
+            reference_histogram=reference,reference_scale=f['reference_scale'],
+            prediction_intensity_counts=arrays['prediction'],reference_intensity_counts=arrays['reference'],
+            mask=arrays['mask'],prediction_depth=arrays['prediction_depth'],reference_depth=arrays['reference_depth'],protocol=PROTOCOL)
+
+class EvaluationRun:
+    """The same scoring/output path for native rendering and saved predictions."""
+    def __init__(self, project, args, output_dir, frames, scale, gamma=1.0,
+                 rendering=None, save_predictions=False):
+        self.scale = positive(scale, 'actual training scale')
+        self.gamma = positive(gamma, 'actual training gamma')
+        self.evaluator = UnifiedEvaluator(project, args, output_dir, frames)
+        self.output = Path(output_dir)
+        self.save_predictions = save_predictions
+        manifest = dict(frames=frames, prediction_scale=self.scale,
+                        prediction_gamma=self.gamma,
+                        bin_width_s=self.evaluator.contract['bin_width_s'],
+                        rendering=rendering or {'source': 'saved histograms; see source manifest'})
+        write_json(self.output/'prediction_manifest.json', manifest)
+        self.evaluator.metadata.update(prediction_scale=self.scale, prediction_gamma=self.gamma,
+                                       rendering=manifest['rendering'])
+        write_json(self.evaluator.output/'evaluation_protocol.json', self.evaluator.metadata)
+
+    def score(self, prediction, index):
+        if self.save_predictions:
+            if hasattr(prediction, 'detach'):
+                prediction = prediction.detach().cpu().numpy()
+            np.save(self.output/f'{index}_transient_array.npy', prediction)
+        scores = self.evaluator.score(prediction, index, self.scale, self.gamma)
+        print(self.evaluator.project, index, {k: scores[k] for k in
+              ('histogram_psnr', 'image_psnr', 'ssim', 'lpips', 'depth_l1_m')}, flush=True)
+        return scores
+
+    def finish(self):
+        if len(self.evaluator.rows) != len(self.evaluator.frames):
+            raise ValueError('Incomplete canonical test set: no complete evaluation result')
+        return self.evaluator.output/'metrics_aggregate.json'

codes/reconstruction/FlyingWithPhotons/evaluation/image_metrics.py

@@ -0,0 +1,114 @@
+"""Shared TA-style display metrics, with uncensored linear-count diagnostics.
+
+Not an exact upstream reproduction: all projects use one reference-only mask,
+explicit SSIM settings, a frozen training scale, and FP32 LPIPS.
+"""
+import numpy as np
+import torch
+import lpips
+from contextlib import contextmanager
+from scipy.ndimage import minimum_filter
+from skimage.metrics import structural_similarity
+
+PROTOCOL = 'shared_ta_display_psnr_ssim_lpips_v3_20260929'
+PRIMARY_KEYS = ('psnr', 'ssim', 'lpips')
+AUXILIARY_KEYS = ('linear_psnr', 'prediction_above_scale_percent',
+                  'reference_above_scale_percent', 'max_prediction_over_scale',
+                  'max_reference_over_scale')
+SCORE_KEYS = PRIMARY_KEYS + AUXILIARY_KEYS
+PROTOCOL_INFO = dict(
+    protocol=PROTOCOL,
+    scale_policy="explicit frozen per-scene record; no numeric scene fallback",
+    metric_labels=dict(psnr='PSNR-display', ssim='SSIM-display', lpips='LPIPS-display',
+                       linear_psnr='PSNR-linear (auxiliary)'),
+    prediction_display='clip(I/D,0,1) ** (1/2.2)',
+    reference_display='(I/D) ** (1/2.2), no upper clipping',
+    psnr='-10log10 valid-reference-pixel/RGB display MSE; fixed peak 1',
+    ssim='RGB, data_range=1, uniform 7x7, sample covariance, complete reference-valid windows',
+    lpips='same display RGB, common invalid region black, [-1,1] transform, VGG0.1 FP32',
+    linear_psnr='-10log10 mean(((prediction-reference)/D)^2); no upper clipping or gamma',
+    above_scale_percent='percentage of reference-valid pixels with ANY RGB channel > D',
+    aggregation='arithmetic mean of per-view metrics; saturation percentages are mean per-view percentages',
+    prediction_upper_clip=True, reference_upper_clip=False,
+    count_domain_upper_clip=False, fitted_test_exposure=False,
+    preview_png='clip display arrays only for uint8 export; floating scoring arrays are retained',
+    upstream_exact=False,
+)
+
+@contextmanager
+def scoring_precision():
+    previous = (torch.get_float32_matmul_precision(),
+                torch.backends.cuda.matmul.allow_tf32, torch.backends.cudnn.allow_tf32)
+    try:
+        torch.set_float32_matmul_precision('highest')
+        torch.backends.cuda.matmul.allow_tf32=False
+        torch.backends.cudnn.allow_tf32=False
+        yield
+    finally:
+        torch.set_float32_matmul_precision(previous[0])
+        torch.backends.cuda.matmul.allow_tf32=previous[1]
+        torch.backends.cudnn.allow_tf32=previous[2]
+
+def tone_map(image, scale, *, prediction):
+    """Role is explicit: upstream prediction and reference transforms differ."""
+    x=np.asarray(image,dtype=np.float64)
+    if not np.isfinite(scale) or scale <= 0:
+        raise ValueError('positive fixed scale required')
+    if not np.isfinite(x).all() or np.any(x<0):
+        raise ValueError('Expected finite nonnegative counts; no silent masking/clipping of invalid inputs')
+    x=x/scale
+    if prediction:
+        x=np.clip(x,0.,1.)
+    return x**(1/2.2)
+
+def display_pair(prediction, reference, scale, mask=None):
+    p=tone_map(prediction,scale,prediction=True)
+    g=tone_map(reference,scale,prediction=False)
+    if mask is not None:
+        mask=np.asarray(mask,bool)
+        p[~mask]=0;g[~mask]=0
+    return p,g
+
+def preview_uint8(display_image):
+    """PNG encoding only. Never pass this output back to a metric."""
+    return np.rint(np.clip(display_image,0.,1.)*255.).astype(np.uint8)
+
+def _psnr(mse):
+    return float(-10*np.log10(mse)) if mse>0 else float('inf')
+
+class ImageMetrics:
+    def __init__(self, scale, device='cuda'):
+        if not np.isfinite(scale) or scale<=0:
+            raise ValueError('positive fixed scale required')
+        self.scale=float(scale);self.device=str(device)
+        self.net=lpips.LPIPS(net='vgg',version='0.1').float().to(device).eval()
+
+    def __call__(self, prediction, reference, mask):
+        pred=np.asarray(prediction,np.float64);ref=np.asarray(reference,np.float64)
+        mask=np.asarray(mask,dtype=bool)
+        if pred.shape!=ref.shape or pred.ndim!=3 or pred.shape[-1]!=3 or mask.shape!=pred.shape[:2]:
+            raise ValueError('Expected matching HWC3 images and HW reference mask')
+        if not mask.any():
+            raise ValueError('No reference-valid pixels')
+        x,y=display_pair(pred,ref,self.scale)
+        psnr=_psnr(np.mean((x[mask]-y[mask])**2,dtype=np.float64))
+        linear_psnr=_psnr(np.mean(((pred[mask]-ref[mask])/self.scale)**2,dtype=np.float64))
+        windows=minimum_filter(mask.astype(np.uint8),size=7,mode='constant',cval=0).astype(bool)
+        if not windows.any():
+            raise ValueError('No complete 7x7 reference-valid SSIM windows')
+        _,ssim_map=structural_similarity(y,x,data_range=1.,channel_axis=-1,
+            win_size=7,gaussian_weights=False,use_sample_covariance=True,full=True)
+        ssim=float(ssim_map[windows].mean())
+        x[~mask]=0;y[~mask]=0
+        tensor=lambda z: torch.from_numpy(z.astype(np.float32)).permute(2,0,1)[None].to(self.device)*2-1
+        with scoring_precision(),torch.no_grad(),torch.autocast(device_type=self.device.split(':')[0],enabled=False):
+            score=self.net(tensor(x),tensor(y))
+        return dict(psnr=psnr,ssim=ssim,lpips=float(score.item()),linear_psnr=linear_psnr,
+            prediction_above_scale_percent=float(np.any(pred[mask]>self.scale,axis=-1).mean()*100),
+            reference_above_scale_percent=float(np.any(ref[mask]>self.scale,axis=-1).mean()*100),
+            max_prediction_over_scale=float(pred[mask].max()/self.scale),
+            max_reference_over_scale=float(ref[mask].max()/self.scale))
+
+def aggregate(rows):
+    if not rows:raise ValueError('Cannot aggregate empty results')
+    return {k:float(np.mean([r[k] for r in rows],dtype=np.float64)) for k in SCORE_KEYS}

codes/reconstruction/FlyingWithPhotons/evaluation/io.py

@@ -0,0 +1,30 @@
+import hashlib
+import json
+import os
+from pathlib import Path
+import numpy as np
+
+def sha256(path):
+    h=hashlib.sha256()
+    with Path(path).open('rb') as f:
+        for block in iter(lambda:f.read(8*1024*1024),b''):h.update(block)
+    return h.hexdigest()
+
+def write_json(path, data):
+    path=Path(path);path.parent.mkdir(parents=True,exist_ok=True)
+    tmp=path.with_name(path.name+'.%d.tmp'%os.getpid())
+    tmp.write_text(json.dumps(data,indent=2,allow_nan=True));tmp.replace(path)
+
+def verified(path, digest):
+    path=Path(path)
+    if not path.is_file() or sha256(path)!=digest:
+        raise ValueError('Frozen input missing or changed: '+str(path))
+    return path
+
+def load_histogram(path):
+    path=Path(path)
+    if path.suffix=='.npy':return np.load(path,mmap_mode='r',allow_pickle=False)
+    if path.suffix in ('.h5','.hdf5'):
+        import h5py
+        with h5py.File(path,'r') as f:return np.asarray(f['data'])
+    raise ValueError('Use unclipped .npy or .h5 histogram exports: '+str(path))

codes/reconstruction/FlyingWithPhotons/evaluation/renderer.py

@@ -0,0 +1,100 @@
+"""FlyingWithPhotons model loading and rendering; no method-specific scoring."""
+import json
+from pathlib import Path
+
+PROJECT = 'FlyingWithPhotons'
+
+def forward_average_occgrid(
+    forward_repeats,
+    radiance_field,
+    estimator,
+    rays,
+    args,
+    color_channels,
+):
+    # Match captured_neus.py: average repeated forward passes first, then evaluate metrics once.
+    rgb_sum = None
+    acc_sum = None
+    depth_sum = None
+
+    for rep_idx in range(forward_repeats):
+        if forward_repeats > 1:
+            print(f"[FORWARD AVG] rep {rep_idx + 1}/{forward_repeats}")
+
+        rgb_rep, acc_rep, depth_rep, _ = render_image_with_occgrid_test(
+            1024,
+            radiance_field,
+            estimator,
+            rays,
+            args=args,
+            near_plane=args.near_plane,
+            far_plane=args.far_plane,
+            render_step_size=args.render_step_size,
+            cone_angle=args.cone_angle,
+            alpha_thre=0.01,
+            n_output_dim=args.n_bins * color_channels,
+            prop_delay=args.prop_delay,
+            unwarp=not args.warped,
+        )
+
+        if rgb_sum is None:
+            rgb_sum = torch.zeros_like(rgb_rep)
+            acc_sum = torch.zeros_like(acc_rep)
+            depth_sum = torch.zeros_like(depth_rep)
+
+        rgb_sum += rgb_rep
+        acc_sum += acc_rep
+        depth_sum += depth_rep
+
+    rgb = rgb_sum / float(forward_repeats)
+    acc = acc_sum / float(forward_repeats)
+    depth = depth_sum / float(forward_repeats)
+    return rgb, acc, depth
+
+
+def main():
+    global torch, render_image_with_occgrid_test
+    import torch
+    import torch.nn.functional as F
+    from nerfacc import OccGridEstimator
+    from radiance_fields.ngp import NGPRadianceField
+    from loaders.utils import Rays
+    from utils import render_image_with_occgrid_test
+    from .arguments import load_eval_args
+    from .units import fwp_training_units
+    from .evaluator import EvaluationRun
+
+    args = load_eval_args()
+    if args.version != 'captured' or int(getattr(args, 'eval_repeats', 30)) != 30:
+        raise ValueError('The captured benchmark requires 30 forward repetitions')
+    scale, gamma = fwp_training_units(args)
+    frames = json.loads(Path(args.transforms_path).read_text())['frames']
+    output = args.shared_output_dir or str(Path(args.checkpoint_dir)/f'evaluation_step{args.step}')
+    run = EvaluationRun(PROJECT, args, output, frames, scale, gamma,
+        rendering=dict(forward_repeats=30, sampling='native same pixel rays, average forward outputs',
+                       warped=args.warped), save_predictions=args.save_predictions)
+    device = args.device
+    aabb = torch.tensor(args.aabb, dtype=torch.float32, device=device)
+    h, w = args.img_height_test, args.img_width_test
+    sx, sy = w/args.img_width, h/args.img_height
+    K = torch.tensor([[args.fx*sx,0,args.cx*sx],[0,args.fy*sy,args.cy*sy],[0,0,1]], dtype=torch.float32)
+    estimator = OccGridEstimator(roi_aabb=aabb, resolution=args.grid_resolution,
+                                 levels=args.grid_nlvl).to(device)
+    model = NGPRadianceField(aabb=estimator.aabbs[-1], radiance_activation=torch.nn.Sigmoid(),
+                            use_viewdirs=True, args=args).to(device)
+    model.load_state_dict(torch.load(Path(args.checkpoint_dir)/f'radiance_field_{args.step:04d}.pth', map_location=device))
+    estimator.load_state_dict(torch.load(Path(args.checkpoint_dir)/f'occupancy_grid_{args.step:04d}.pth', map_location=device))
+    # Preserve the original renderer's mode and same-ray averaging behavior.
+    with torch.no_grad():
+        for i, frame in enumerate(frames):
+            c2w = torch.tensor(frame['transform_matrix']).to(device)
+            yy, xx = torch.meshgrid(torch.arange(h,device=device), torch.arange(w,device=device), indexing='ij')
+            camera_dirs = F.pad(torch.stack([(xx-K[0,2]+0.5)/K[0,0],
+                                             (yy-K[1,2]+0.5)/K[1,1]], dim=-1), (0,1), value=1.)
+            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)
+            rays = Rays(origins=origins.reshape(h,w,3), viewdirs=viewdirs.reshape(h,w,3))
+            rgb, _, _ = forward_average_occgrid(30, model, estimator, rays, args, 1)
+            run.score(rgb.reshape(h,w,-1,1).cpu().numpy(), i)
+    print(run.finish())

codes/reconstruction/FlyingWithPhotons/evaluation/units.py

@@ -0,0 +1,84 @@
+import math
+"""Actual training units; a test-split maximum is never a fallback."""
+import ast
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from .core import positive
+from .io import write_json,sha256
+
+def record_training_units(directory,scale,gamma,train_poses,project,measurement_root=None,intrinsics=None):
+    path=Path(directory)/'image_metric_normalization.json'
+    data=dict(training_scale=positive(scale,'training scale'),training_gamma=positive(gamma,'training gamma'),
+        project=project,train_poses=str(Path(train_poses).resolve()),train_poses_sha256=sha256(train_poses),
+        measurement_root=measurement_root,intrinsics=intrinsics,
+        intrinsics_sha256=sha256(intrinsics) if intrinsics else None,
+        source='actual training loader/configuration; never computed from test data')
+    if path.exists():
+        old=json.loads(path.read_text())
+        if (float(old['training_scale'])!=data['training_scale'] or
+            float(old.get('training_gamma',1.0))!=data['training_gamma']):
+            raise ValueError('Checkpoint directory already records different training units')
+        for key in ('train_poses_sha256','intrinsics_sha256','measurement_root'):
+            if key in old and old[key]!=data[key]:
+                raise ValueError('Checkpoint training provenance differs: '+key)
+        return
+    write_json(path,data)
+
+def fwp_training_units(args):
+    root=Path(args.checkpoint_dir);metadata=root/'image_metric_normalization.json'
+    if metadata.exists():
+        record=json.loads(metadata.read_text())
+        scale,gamma=record['training_scale'],record['training_gamma']
+    else:
+        params=root/'params_full.txt'
+        if not params.is_file():raise ValueError('FWP requires saved training params_full.txt or normalization metadata')
+        values={}
+        for line in params.read_text().splitlines():
+            if '=' not in line or line.lstrip().startswith('#'):continue
+            k,v=line.split('=',1)
+            if k.strip() in ('dataset_scale','gamma'):values[k.strip()]=ast.literal_eval(v.strip())
+        scale,gamma=values['dataset_scale'],values['gamma']
+    scale,gamma=positive(scale,'training dataset_scale'),positive(gamma,'training gamma')
+    if float(args.dataset_scale)!=scale or float(args.gamma)!=gamma:
+        raise ValueError('Evaluation dataset_scale/gamma differs from saved FWP training units')
+    return scale,gamma
+
+def scalar(value):
+    if hasattr(value, 'detach'):
+        value = value.detach().cpu().item()
+    value = float(value)
+    if not math.isfinite(value) or value <= 0:
+        raise ValueError('A finite positive count scale is required')
+    return value
+
+def resolve_prediction_scale(system):
+    value = system.config.dataset.get('image_metric_training_scale', None)
+    if hasattr(system, '_image_metric_training_scale'):
+        if value is not None and scalar(value) != scalar(system._image_metric_training_scale):
+            raise ValueError('Explicit training scale conflicts with checkpoint metadata')
+        return scalar(system._image_metric_training_scale), 'training/checkpoint metadata'
+    if value is not None:
+        return scalar(value), 'explicit dataset.image_metric_training_scale'
+    raise ValueError('Missing actual training scale; use checkpoint metadata or set dataset.image_metric_training_scale. Never substitute the test maximum.')
+
+def tn_training_scale(args):
+    """Restore model output units; the independently normalized test split is not valid here."""
+    explicit = getattr(args, "shared_prediction_scale", None)
+    path = Path(args.checkpoint_dir) / "image_metric_normalization.json"
+    recorded = None
+    if path.is_file():
+        recorded = json.loads(path.read_text()).get("training_scale")
+    if explicit is None and recorded is None:
+        raise ValueError(
+            "Shared metrics require the TRAINING histogram normalization. "
+            "Supply --shared-prediction-scale from the training loader, or create "
+            + str(path) + " with training_scale and its training-data provenance. "
+            "The test split maximum must never be substituted."
+        )
+    if explicit is not None and recorded is not None and float(explicit) != float(recorded):
+        raise ValueError("Explicit prediction scale conflicts with checkpoint normalization metadata")
+    value = float(recorded if explicit is None else explicit)
+    if not math.isfinite(value) or value <= 0:
+        raise ValueError("Training histogram normalization must be finite and positive")
+    return value

codes/reconstruction/FlyingWithPhotons/evaluation/worker.py

@@ -0,0 +1,21 @@
+"""Run image scoring in the same installed environment for all three methods."""
+import argparse
+from pathlib import Path
+import numpy as np
+from .io import write_json
+
+def main():
+    p=argparse.ArgumentParser()
+    for k in ('input','output','display'):p.add_argument('--'+k,required=True)
+    p.add_argument('--scale',required=True,type=float);p.add_argument('--device',default='cpu')
+    a=p.parse_args()
+    from .image_metrics import ImageMetrics,display_pair
+    with np.load(a.input) as d:
+        pred,ref,mask=d['prediction'],d['reference'],d['mask'].astype(bool)
+    scores=ImageMetrics(a.scale,a.device)(pred,ref,mask)
+    scores['image_psnr']=scores.pop('psnr')
+    x,y=display_pair(pred,ref,a.scale,mask)
+    np.savez_compressed(a.display,prediction=x,reference=y)
+    write_json(a.output,scores)
+
+if __name__=='__main__':main()

codes/reconstruction/FlyingWithPhotons/loaders/calibration.py

@@ -0,0 +1,12 @@
+"""Expand scalar calibration or resize a 2-D map; preserve physical values."""
+import torch
+import torch.nn.functional as F
+
+def shift_map(value, height, width, device):
+    value=torch.as_tensor(value,dtype=torch.float32,device=device).squeeze()
+    if value.numel()==1:
+        return value.reshape(1,1).expand(height,width)
+    if value.ndim!=2:
+        raise ValueError('Calibration shift must be scalar or a 2-D map')
+    if tuple(value.shape)==(height,width):return value
+    return F.interpolate(value[None,None],size=(height,width),mode='bilinear',align_corners=True)[0,0]

codes/reconstruction/FlyingWithPhotons/loaders/regular_loader_our.py

@@ -0,0 +1,363 @@
+"""
+Copyright (c) 2022 Ruilong Li, UC Berkeley.
+Modified for captured SPAD data with Pinhole Model & Hardware Offsets.
+"""
+import json
+import os
+import re
+import numpy as np
+import torch
+import torch.nn.functional as F
+import h5py
+import scipy.sparse as sp
+from .utils import Rays
+import tqdm
+import sys 
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from utils import compute_transient_valid_mask_torch
+
+def read_h5(path):
+    with h5py.File(path, 'r') as f:
+        frames = np.array(f['data'])
+    return frames
+
+
+def _load_numpy_coo_npz(path):
+    pack = np.load(path, allow_pickle=False)
+    try:
+        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 read_npz(path, height, width):
+    try:
+        dense_frames = sp.load_npz(path).toarray()
+    except Exception:
+        dense_frames = _load_numpy_coo_npz(path)
+    if dense_frames.ndim == 3:
+        if dense_frames.shape[:2] != (height, width):
+            raise ValueError(
+                f"Measurement shape mismatch for {path}: got {dense_frames.shape[:2]}, "
+                f"expected {(height, width)}"
+            )
+        return dense_frames.astype(np.float32)
+    if dense_frames.ndim != 2:
+        raise ValueError(f"Unsupported sparse measurement shape {dense_frames.shape} in {path}")
+    if dense_frames.shape[0] == height * width:
+        return dense_frames.reshape(height, width, dense_frames.shape[1]).astype(np.float32)
+    if dense_frames.shape[1] == height * width:
+        return dense_frames.T.reshape(height, width, dense_frames.shape[0]).astype(np.float32)
+    raise ValueError(
+        f"Measurement pixel count mismatch for {path}: got {dense_frames.shape}, "
+        f"expected [H*W, bins] or [bins, H*W] with H*W={height * width}"
+    )
+
+
+def resolve_measurement_path(measurement_root, frame_path):
+    frame_rel = frame_path or ""
+    frame_name = os.path.basename(frame_rel)
+    frame_stem, frame_ext = os.path.splitext(frame_name)
+
+    candidates = []
+    if frame_rel:
+        candidates.append(os.path.join(measurement_root, frame_rel))
+    if frame_name:
+        candidates.append(os.path.join(measurement_root, frame_name))
+    if frame_stem:
+        candidates.append(os.path.join(measurement_root, f"{frame_stem}.h5"))
+        candidates.append(os.path.join(measurement_root, f"{frame_stem}.npz"))
+        match = re.search(r"(\d+)$", frame_stem)
+        if match:
+            frame_idx = int(match.group(1))
+            candidates.append(os.path.join(measurement_root, f"transient{frame_idx:03d}.h5"))
+            candidates.append(os.path.join(measurement_root, f"transient{frame_idx:03d}.npz"))
+    if frame_ext.lower() in {".h5", ".npz"}:
+        candidates.insert(0, os.path.join(measurement_root, frame_name))
+
+    seen = set()
+    for candidate in candidates:
+        if candidate in seen:
+            continue
+        seen.add(candidate)
+        if os.path.exists(candidate):
+            return candidate
+
+    raise FileNotFoundError(
+        f"Cannot find measurement file for frame '{frame_path}' under '{measurement_root}'. "
+        f"Tried: {candidates[:6]}"
+    )
+
+
+def read_measurement(path, args):
+    ext = os.path.splitext(path)[1].lower()
+    if ext == ".h5":
+        return read_h5(path)[..., :args.n_bins, :3]
+    if ext == ".npz":
+        rgba = read_npz(path, args.img_height, args.img_width)[..., :args.n_bins]
+        return rgba[..., None]
+    raise ValueError(f"Unsupported measurement file type: {path}")
+
+
+def select_test_frames(root_fp, frames):
+    train_json = os.path.join(root_fp, "transforms_train.json")
+    if not os.path.exists(train_json):
+        return frames
+
+    with open(train_json, "r") as fp:
+        train_meta = json.load(fp)
+
+    num_train_frames = len(train_meta.get("frames", []))
+    if num_train_frames <= 0 or num_train_frames >= len(frames):
+        return frames
+
+    selected_indices = np.linspace(0, len(frames) - 1, num=num_train_frames, dtype=int)
+    return [frames[idx] for idx in selected_indices.tolist()]
+
+def _load_offset_map(path, h, w):
+    """读取外部的逐像素深度偏移图"""
+    if path.lower().endswith('.npy'):
+        arr = np.load(path).astype(np.float32)
+    else:
+        arr = np.loadtxt(path, dtype=np.float32)
+    arr = np.asarray(arr, dtype=np.float32).squeeze()
+    if arr.size == h * w:
+        arr = arr.reshape(h, w)
+    return torch.from_numpy(arr)
+
+def _load_renderings(root_fp: str, split: str, args):
+    """Load images from disk with Area Downsampling and Pinhole K Matrix."""
+    with open(os.path.join(root_fp, f"transforms_{split}.json"), "r") as fp:
+        meta = json.load(fp)
+
+    frames = meta["frames"]
+    if split == "test" and getattr(args, "match_test_to_train_views", True):
+        frames = select_test_frames(root_fp, frames)
+
+    images = []
+    camtoworlds = []
+
+    for i in tqdm.tqdm(range(len(frames))):
+        frame = frames[i]
+        fname = resolve_measurement_path(args.measurement_root, frame.get("file_path", ""))
+        rgba = read_measurement(fname, args)
+        camtoworlds.append(frame["transform_matrix"])
+        images.append(rgba)
+    
+    images = np.stack(images, axis=0)
+    
+    if args.version == "captured":
+        images = images.mean(-1)[..., None]
+        
+    # 空间下采样的优化：使用面积插值 (Area Interpolation)
+    if split == "test" and images.shape[1] != args.img_shape_test:
+        N, H, W, T, C = images.shape
+        images_pt = torch.from_numpy(images).permute(0, 3, 4, 1, 2).reshape(N * T * C, 1, H, W)
+        images_pt = F.interpolate(images_pt, size=(args.img_height_test, args.img_width_test), mode='area')
+        images = images_pt.reshape(N, T, C, args.img_height_test, args.img_width_test).permute(0, 3, 4, 1, 2).numpy()
+        
+    images = np.clip(images / args.dataset_scale, 0, 1) ** (1 / args.gamma)
+    images = images.astype(np.float32)
+    camtoworlds = np.stack(camtoworlds, axis=0)
+
+    # 保留原 Fwp 的完美针孔相机假设，利用 camera_angle_x 计算内参矩阵 K
+    h, w = images.shape[1:3]
+    # fov = float(meta["camera_angle_x"])
+    # focal = 0.5 * w / np.tan(0.5 * fov)
+    # K = torch.tensor([
+    #     [focal, 0, w / 2.0],
+    #     [0, focal, h / 2.0],
+    #     [0, 0, 1],
+    # ], dtype=torch.float32)
+    K = torch.tensor([
+        [args.fx, 0, args.cx],
+        [0, args.fy, args.cy],
+        [0, 0, 1],
+    ], dtype=torch.float32)
+    
+    # 对内参 K 矩阵也进行对应的降采样缩放
+    if split == "test":
+        scale_x = args.img_width_test / w
+        scale_y = args.img_height_test / h
+        K[0, :] *= scale_x  # 缩放 fx 和 cx
+        K[1, :] *= scale_y  # 缩放 fy 和 cy
+        K[2, 2] = 1.0       # 保持齐次坐标为1
+
+    return images, camtoworlds, K
+
+
+class SubjectLoader(torch.utils.data.Dataset):
+    SPLITS = ["train", "val", "trainval", "test"]
+    OPENGL_CAMERA = False
+
+    def __init__(self, root_fp: str, split: str, subject_id=None, color_bkgd_aug: str="black", num_rays: int=None, near: float=None, far: float=None, batch_over_images: bool=True, args=None):
+        super().__init__()
+        self.WIDTH = args.img_width_test if split == "test" else args.img_width
+        self.HEIGHT = args.img_height_test if split == "test" else args.img_height
+        self.args = args
+        self.split = split
+        self.num_rays = num_rays
+        self.training = (num_rays is not None) and (split in ["train", "trainval"])
+        self.color_bkgd_aug = color_bkgd_aug
+        self.batch_over_images = batch_over_images
+
+        # 加载图像、位姿与针孔内参 K
+        images, camtoworlds, K = _load_renderings(root_fp, split, args)
+        self.images = torch.from_numpy(images).to(torch.float32)
+        self.camtoworlds = torch.from_numpy(camtoworlds).to(torch.float32).to(args.device)
+        self.K = K.to(args.device)
+        self.aabb = torch.tensor(args.aabb, dtype=torch.float32, device=args.device).view(1, 6)
+        
+       # ---------------------------------------------------------
+        # 1 & 2. 从 intrinsics.npy 读取已合并的 Shift 硬件偏移
+        # ---------------------------------------------------------
+        # 尝试获取 args.intrinsics_path，若未在 ini 中定义，则使用默认路径
+        intrinsics_path = getattr(args, 'intrinsics_path', 
+            '/work/runrong/project_all/FlyingWithPhotons/ini_generate/intrinsics.npy')
+        
+        if os.path.exists(intrinsics_path):
+            intrinsics = np.load(intrinsics_path, allow_pickle=True).item()
+            shift_raw = intrinsics["shift"]
+            
+            if isinstance(shift_raw, torch.Tensor):
+                shift_tensor = shift_raw.to(torch.float32).to(args.device)
+            else:
+                shift_tensor = torch.from_numpy(np.array(shift_raw, dtype=np.float32)).to(args.device)
+            
+            from loaders.calibration import shift_map
+            shift_tensor = shift_map(shift_tensor, self.HEIGHT, self.WIDTH, args.device)
+
+            # shift 为物理距离(负数)，需除以 exposure_time 转换为 bins，再取反用于正向补偿 (与 eval_ours.py 一致)
+            self.hardware_bin_shift = (-shift_tensor / args.exposure_time).to(torch.float32)
+            self.valid_mask = torch.ones((self.HEIGHT, self.WIDTH), dtype=torch.bool, device=args.device)
+        else:
+            print(f"!!! Warning: {intrinsics_path} 不存在，已将硬件补偿回退为 0 !!!")
+            self.hardware_bin_shift = torch.zeros((self.HEIGHT, self.WIDTH), dtype=torch.float32, device=args.device)
+            self.valid_mask = torch.ones((self.HEIGHT, self.WIDTH), dtype=torch.bool, device=args.device)
+
+        self.output_valid_mask = self.valid_mask.clone()
+
+    def __len__(self):
+        return len(self.images)
+
+    @torch.no_grad()
+    def __getitem__(self, index):
+        data = self.fetch_data(index)
+        return self.preprocess(data)
+
+    def preprocess(self, data):
+        rgba, rays, valid_mask = data["rgba"], data["rays"], data["valid_mask"]
+        color_bkgd = torch.zeros(3, device=self.args.device) if self.training and self.color_bkgd_aug == "black" else torch.ones(3, device=self.args.device)
+        
+        return {
+            "pixels": rgba.to(self.args.device),
+            "rays": rays,
+            "color_bkgd": color_bkgd,
+            "valid_mask": valid_mask,
+            **{k: v for k, v in data.items() if k not in ["rgba", "rays", "valid_mask"]},
+        }
+    
+    def update_num_rays(self, num_rays):
+        self.num_rays = num_rays
+
+    def fetch_data(self, index):
+        num_rays = self.num_rays
+
+        if self.training:
+            image_id = torch.randint(0, len(self.images), size=(num_rays,), device=self.camtoworlds.device) if self.batch_over_images else [index] * num_rays
+            x = torch.randint(0, self.WIDTH, size=(num_rays,), device=self.camtoworlds.device)
+            y = torch.randint(0, self.HEIGHT, size=(num_rays,), device=self.camtoworlds.device)
+        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, y = x.flatten(), y.flatten()
+
+        idx_y_cpu, idx_x_cpu = y.cpu(), x.cpu()
+        idx_img_cpu = image_id.cpu() if isinstance(image_id, torch.Tensor) else image_id
+        
+        # 获取当前光线的直方图、基础有效掩码和纯硬件偏移
+        rgba_raw = self.images[idx_img_cpu, idx_y_cpu, idx_x_cpu].to(self.args.device)
+        base_valid_mask = self.output_valid_mask[y, x]
+        bin_shift = self.hardware_bin_shift[y, x]
+        
+        c2w = self.camtoworlds[image_id]
+        
+        # 恢复原 Fwp 使用 Pinhole K 矩阵生成射线方向的逻辑
+        camera_dirs = F.pad(
+            torch.stack(
+                [
+                    (x - self.K[0, 2] + 0.5) / self.K[0, 0] ,
+                    (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  
+        )
+
+        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)
+
+        n_bins = rgba_raw.shape[1]
+
+        # ---------------------------------------------------------
+        # 3. 仅应用硬件相关的 Shift (AABB 的半程交点 Shift 已移除)
+        # ---------------------------------------------------------
+        rgba_input = rgba_raw.permute(0, 2, 1).unsqueeze(2).contiguous()
+        t_grid = torch.linspace(-1, 1, n_bins, device=self.args.device)
+        norm_shift = bin_shift / (n_bins / 2.0)
+        
+        # 应用网格偏移 (+ norm_shift)
+        grid_x = t_grid.view(1, 1, n_bins) + norm_shift.view(-1, 1, 1) 
+        grid_y = torch.zeros_like(grid_x)
+        grid = torch.stack([grid_x, grid_y], dim=-1).contiguous()
+
+        # 关闭 cudnn 避免 grid_sample 非确定性错误
+        import torch.backends.cudnn as cudnn
+        original_cudnn_state = cudnn.enabled
+        cudnn.enabled = False
+        try:
+            rgba_aligned = F.grid_sample(rgba_input, grid, mode='bilinear', padding_mode='zeros', align_corners=True)
+        finally:
+            cudnn.enabled = original_cudnn_state
+            
+        rgba = rgba_aligned.squeeze(2).permute(0, 2, 1)
+        valid_mask, meas_peak_mask, signal_mask = compute_transient_valid_mask_torch(
+            rgba,
+            self.args,
+            base_mask=base_valid_mask,
+            undo_gamma=True,
+        )
+        # if torch.rand(1).item() < 0.01: # 抽样打印
+        #     print("DEBUG Train Loader - rgba max:", rgba.max().item())
+
+        # 整理输出形状
+        if self.training:
+            origins = origins.view(num_rays, 3)
+            viewdirs = viewdirs.view(num_rays, 3)
+            rgba = rgba.view(num_rays, n_bins, -1)
+        else:
+            origins = origins.view(self.HEIGHT, self.WIDTH, 3)
+            viewdirs = viewdirs.view(self.HEIGHT, self.WIDTH, 3)
+            rgba = rgba.view(self.HEIGHT, self.WIDTH, n_bins, -1)
+            valid_mask = valid_mask.view(self.HEIGHT, self.WIDTH)
+            meas_peak_mask = meas_peak_mask.view(self.HEIGHT, self.WIDTH)
+            signal_mask = signal_mask.view(self.HEIGHT, self.WIDTH)
+
+        return {
+            "rgba": rgba,
+            "rays": Rays(origins=origins, viewdirs=viewdirs),
+            "valid_mask": valid_mask,
+            "meas_peak_mask": meas_peak_mask,
+            "signal_mask": signal_mask,
+        }

codes/reconstruction/FlyingWithPhotons/loaders/streaming_loader.py

@@ -0,0 +1,208 @@
+import json
+import os
+import numpy as np
+import torch
+import torch.nn.functional as F
+import h5py
+from .utils import Rays
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+def rays_from_h5(start, end, path, device="cuda:0"):
+    with h5py.File(os.path.join(path, "samples.h5"), 'r') as f:
+        data = np.array(f['dataset'][start:end, :, :3])
+        data = torch.from_numpy(data).to(torch.float32)
+        data = data.to(device)
+    return data
+
+def get_x(start, end, path, device="cuda:0"):
+    with h5py.File(os.path.join(path, "x.h5"), 'r') as f:
+        x = torch.tensor(f['dataset'][start:end], device=device)
+    return x
+
+def get_y(start, end, path, device="cuda:0"):
+    with h5py.File(os.path.join(path, "y.h5"), 'r') as f:
+        y = torch.tensor(f['dataset'][start:end], device=device)
+    return y
+
+def get_file_indices(start, end, path):
+    with h5py.File(os.path.join(path, "file_indices.h5"), 'r') as f:
+        indices = torch.tensor(f['dataset'][start:end])
+        indices = indices.type(torch.long)
+    return indices
+
+
+def _load_renderings_metadata(root_fp: str, subject_id: str, split: str, args):
+    """Load images from disk."""
+
+    with open(
+        os.path.join(root_fp, "transforms_{}.json".format(split)), "r"
+    ) as fp:
+        meta = json.load(fp)
+    fnames = []
+    camtoworlds = []
+
+    for i in range(len(meta["frames"])):
+        frame = meta["frames"][i]
+        camtoworlds.append(frame["transform_matrix"])
+
+    camtoworlds = np.stack(camtoworlds, axis=0)
+
+    if args.version == "simulated":
+        h, w = args.img_shape, args.img_shape
+        camera_angle_x = float(meta["camera"])
+        focal = 0.5 * w / np.tan(0.5 * camera_angle_x)
+        K = torch.tensor(
+            [
+                [focal, 0, w / 2.0],
+                [0, focal, h / 2.0],
+                [0, 0, 1],
+            ],
+            dtype=torch.float32)
+    else:
+        K = torch.tensor(np.array(meta["camera"])).to(torch.float32)
+
+    with h5py.File(os.path.join(root_fp, "samples.h5"), 'r') as f:
+        length = f['dataset'].shape[0]
+    return length, camtoworlds, K
+
+class SubjectLoaderIterable(torch.utils.data.IterableDataset):
+    """Single subject data loader for training and evaluation."""
+
+    SPLITS = ["train", "val", "trainval", "test"]
+    OPENGL_CAMERA = True
+
+    def __init__(
+        self,
+        counter,
+        num_rays,
+        root_fp: str,
+        split: str,
+        color_bkgd_aug: str = "white",
+        subject_id = None, 
+        near: float = None,
+        far: float = None,
+        args = None,
+         
+    ):
+        super().__init__()
+        self.WIDTH = args.img_shape
+        self.HEIGHT = args.img_shape
+
+        self.args = args
+        self.split = split
+        self.num_rays = num_rays
+        self.training = (num_rays is not None) and (
+            split in ["train", "trainval"]
+        )
+        self.color_bkgd_aug = color_bkgd_aug
+        self.root_fp = root_fp
+        self.subject_id = subject_id
+        self.len, self.camtoworlds, K = _load_renderings_metadata(
+                self.root_fp, self.subject_id, self.split, args
+        )
+
+        self.camtoworlds = torch.from_numpy(self.camtoworlds).to(torch.float32)
+        
+        self.K = K
+        self.camtoworlds = self.camtoworlds.to(self.args.device)
+        self.K = self.K.to(self.args.device)
+        self.counter = counter
+    
+
+    def __iter__(self):
+        while True:
+            data = self.fetch_data()
+            data = self.preprocess(data)
+            yield data
+            
+    def __len__(self):
+        return self.len
+
+    def preprocess(self, data):
+        pixels, rays = data["rgba"], data["rays"]   
+        pixels = torch.clip(pixels[...,self.args.t_min:self.args.t_max, :3]/self.args.dataset_scale, 0, 1)**(1/self.args.gamma)
+    
+        return {
+            "pixels": pixels,  # [n_rays, 3] or [h, w, 3]
+            "rays": rays,  # [n_rays,] or [h, w]
+            "color_bkgd": None,  # [3,]
+            **{k: v for k, v in data.items() if k not in ["rgba", "rays"]},
+        }
+
+
+    def fetch_data(self):
+        with self.num_rays.get_lock():  # ensure that only one worker can update num_rays at a time
+            num_rays = self.num_rays.value 
+        with self.counter.get_lock():  # ensure that only one worker can update the counter at a time
+                start_index = self.counter.value
+                end_index = start_index + num_rays
+                if end_index > self.len:
+                    self.counter.value = end_index - self.len
+                elif end_index == self.len:
+                    self.counter.value = 0
+                    start_index = 0
+                    end_index = num_rays
+                else:
+                    self.counter.value += num_rays
+
+        # Load chunk of data.
+        if end_index <= self.len:
+            data = rays_from_h5(start_index, end_index, self.root_fp, self.args.device)
+            x = get_x(start_index, end_index, self.root_fp, self.args.device)
+            y = get_y(start_index, end_index, self.root_fp, self.args.device)
+            cam_index = get_file_indices(start_index, end_index, self.root_fp)
+
+        elif start_index < self.len and end_index > self.len:
+            first_data = rays_from_h5(start_index, self.len, self.root_fp, self.args.device)
+            second_data = rays_from_h5(0, end_index - self.len, self.root_fp, self.args.device)
+            first_x = get_x(start_index, self.len, self.root_fp, self.args.device)
+            second_x = get_x(0, end_index - self.len, self.root_fp, self.args.device)
+            first_y = get_y(start_index, self.len, self.root_fp, self.args.device)
+            second_y = get_y(0, end_index - self.len, self.root_fp, self.args.device)
+            first_cam_index = get_file_indices(start_index, self.len, self.root_fp)
+            second_cam_index = get_file_indices(0, end_index - self.len, self.root_fp)
+
+            data = torch.cat((first_data, second_data),axis=0)
+            x = torch.cat((first_x, second_x),axis=0)
+            y = torch.cat((first_y, second_y),axis=0)
+            cam_index = torch.cat((first_cam_index,second_cam_index),axis=0)
+
+    
+        c2w = self.camtoworlds[cam_index]
+        rgba = data
+        
+        camera_dirs = F.pad(
+            torch.stack(
+                [
+                    (x - self.K[0, 2] + 0.5) / self.K[0, 0],
+                    (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),
+        )  # [num_rays, 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
+        )
+
+        if self.training:
+            origins = torch.reshape(origins, (num_rays, 3))
+            viewdirs = torch.reshape(viewdirs, (num_rays, 3))
+        else:
+            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, -1))
+
+        rays = Rays(origins=origins, viewdirs=viewdirs)
+
+        return {
+            "rgba": rgba,  # [h, w, 4] or [num_rays, 4]
+            "rays": rays,  # [h, w, 3] or [num_rays, 3]
+        }

codes/reconstruction/FlyingWithPhotons/loaders/utils.py

@@ -0,0 +1,12 @@
+"""
+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/FlyingWithPhotons/misc/dataset_utils.py

@@ -0,0 +1,169 @@
+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/FlyingWithPhotons/misc/summary.py

@@ -0,0 +1,116 @@
+import imgviz
+import numpy as np
+from utils import render_image_with_occgrid_test
+import matplotlib.pyplot as plt
+import torchvision
+import torch
+import os 
+
+@torch.no_grad()
+def write_summary_histogram(radiance_field, estimator, writer, test_dataset, step, args):
+    img_scale = args.img_scale
+    radiance_field.eval()
+    estimator.eval()
+    rgb_images = []
+    depth_images = [] 
+    gt_imgs = []
+    accs = []
+
+    pixels_to_plot = args.pixels_to_plot
+    plotting_transients = []
+    plotting_transients_depth = []
+
+    plotting_transients_gt = []
+
+    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"]
+
+            # rendering
+            rgb, acc, depth, _ = render_image_with_occgrid_test(
+                1024,
+                # scene
+                radiance_field,
+                estimator,
+                rays,
+                args=args,
+                # rendering options
+                near_plane=args.near_plane,
+                far_plane=args.far_plane,
+                render_step_size=args.render_step_size,
+                render_bkgd=render_bkgd,
+                cone_angle=args.cone_angle,
+                alpha_thre=args.alpha_thre,
+                n_output_dim=n_output_dim, 
+                prop_delay=args.prop_delay
+            )
+            
+            rgb = rgb.reshape(rays.origins.shape[0], rays.origins.shape[1], -1, color_channels)
+
+            torch.save(rgb, os.path.join(args.outpath, f"test_{ind}_conv.pt"))
+            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_imgs.append(torch.clip(pixels.sum(-2).cpu().permute(2, 0, 1)/img_scale, 0, 1)**(1/2.2))
+                rgb_images.append(torch.clip(rgb.sum(-2).cpu().permute(2, 0, 1)/img_scale, 0, 1)**(1/2.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.mean((torch.stack(gt_imgs, dim=0) - torch.stack(rgb_images, dim=0))**2, (1,2,3))
+        psnr = -10.0 * torch.log(mse) / np.log(10.0)
+        print(f"image psnr: {psnr.mean():.2f}\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()
+    estimator.train()
+    
+

codes/reconstruction/FlyingWithPhotons/misc/transient_volrend.py

@@ -0,0 +1,637 @@
+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
+
+def rendering(
+    # 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,
+    rgb_alpha_fn: Optional[Callable] = None,
+    # rendering options
+    render_bkgd: Optional[Tensor] = None,
+    args = None,
+    t_mins: Optional[Tensor] = None,  # 新增：接收每个样本对应射线的 AABB 入射距离
+    step: int = -1,
+) -> Tuple[Tensor, Tensor, Tensor, Dict]:
+    """Render the rays through the radience field defined by `rgb_sigma_fn`.
+
+    This function is differentiable to the outputs of `rgb_sigma_fn` so it can
+    be used for gradient-based optimization. It supports both batched and flattened input tensor.
+    For flattened input tensor, both `ray_indices` and `n_rays` should be provided.
+
+
+    Note:
+        Either `rgb_sigma_fn` or `rgb_alpha_fn` should be provided.
+
+    Warning:
+        This function is not differentiable to `t_starts`, `t_ends` and `ray_indices`.
+
+    Args:
+        t_starts: Per-sample start distance. Tensor with shape (n_rays, n_samples) or (all_samples,).
+        t_ends: Per-sample end distance. Tensor with shape (n_rays, n_samples) or (all_samples,).
+        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.
+        rgb_sigma_fn: A function that takes in samples {t_starts, t_ends,
+            ray indices} and returns the post-activation rgb (..., 3) and density
+            values (...,). The shape `...` is the same as the shape of `t_starts`.
+        rgb_alpha_fn: A function that takes in samples {t_starts, t_ends,
+            ray indices} and returns the post-activation rgb (..., 3) and opacity
+            values (...,). The shape `...` is the same as the shape of `t_starts`.
+        render_bkgd: Background color. Tensor with shape (3,).
+        args: Arguments from config.
+
+    Returns:
+        Ray colors (n_rays, 3), opacities (n_rays, 1), depths (n_rays, 1) and a dict
+        containing extra intermediate results (e.g., "weights", "trans", "alphas")
+    """
+    if ray_indices is not None:
+        assert (
+            t_starts.shape == t_ends.shape == ray_indices.shape
+        ), "Since nerfacc 0.5.0, t_starts, t_ends and ray_indices must have the same shape (N,). "
+
+    if rgb_sigma_fn is None and rgb_alpha_fn is None:
+        raise ValueError(
+            "At least one of `rgb_sigma_fn` and `rgb_alpha_fn` should be specified."
+        )
+
+    # Query sigma/alpha and color with gradients
+    if rgb_sigma_fn is not None:
+        if t_starts.shape[0] != 0:
+            rgbs, sigmas = rgb_sigma_fn(t_starts, t_ends, ray_indices)
+            
+            # Shift for propagaton delay.
+            if args.prop_delay:
+                # rgbs = rgbs.reshape(rgbs.shape[0], args.n_bins, -1)
+                # sample_dist = (t_starts + t_ends).view(-1, 1)
+                # assert ray_indices.max() < t_mins.shape[0], "ray_indices 超出了 t_mins 的范围！"
+                # #shift = (t_starts + t_ends)[:, None]/ 2.0
+                # curr_t_mins = t_mins[ray_indices].view(-1, 1)
+                # shift = sample_dist - 2.0*curr_t_mins
+                # assert shift.shape == (t_starts.shape[0], 1), f"Shift 形状错误: {shift.shape}"
+
+                # rgbs= shift_transient_grid_sample_3d(rgbs, shift, args.exposure_time, args.n_bins,chunk_size=16384)[..., None]
+            #rgbs = rgbs.reshape((rgbs.shape[0], -1))
+                
+                # 诊断 1：检查 MLP 原始输出是否为 0
+                do_debug = (step>=0 and step% 5000==0)
+                if do_debug:
+                    print(f"\n[STEP{step}诊断]")
+                    print(f"DEBUG: MLP rgbs max before shift: {rgbs.max().item():.6f}")
+                shift = (t_starts + t_ends)[:, None]/ 2.0
+                # 诊断 2：检查平移量（Bins）的量级
+                avg_bins_move = (shift / args.exposure_time).mean().item()
+                if do_debug:
+                    print(f"DEBUG: Average bins_move: {avg_bins_move:.2f}")
+                rgbs_transient = rgbs.reshape(rgbs.shape[0], args.n_bins, -1)  
+                # 执行平移
+                rgbs_shifted = shift_transient_grid_sample_3d(
+                    rgbs_transient, 
+                    shift, 
+                    args.exposure_time, 
+                    args.n_bins,
+                    chunk_size=16384
+                )
+                # 诊断 3：检查平移后是否全为 0
+                if do_debug and rgbs_shifted.max() == 0 and rgbs_transient.max() > 0:
+                    print("警告：grid_sample 将所有信号平移到了有效窗口之外！请检查 exposure_time 和 shift 物理单位���")
+
+            rgbs = rgbs_shifted.reshape((rgbs.shape[0], -1))
+
+ 
+        else:
+            rgbs = torch.empty((0, 3), device=t_starts.device)
+            sigmas = torch.empty((0,), device=t_starts.device)
+            channel_num = 1
+        assert (
+            sigmas.shape == t_starts.shape
+        ), "sigmas must have shape of (N,)! Got {}".format(sigmas.shape)
+        
+        # Rendering: compute weights.
+        weights, trans, alphas = render_weight_from_density(
+            t_starts,
+            t_ends,
+            sigmas,
+            ray_indices=ray_indices,
+            n_rays=n_rays,
+        )
+        extras = {
+            "weights": weights,
+            "alphas": alphas,
+            "trans": trans,
+            "sigmas": sigmas,
+            "rgbs": rgbs,
+        }
+    elif rgb_alpha_fn is not None:
+        if t_starts.shape[0] != 0:
+            rgbs, alphas = rgb_alpha_fn(t_starts, t_ends, ray_indices)
+        else:
+            rgbs = torch.empty((0, 3), device=t_starts.device)
+            alphas = torch.empty((0,), device=t_starts.device)
+
+        assert (
+            alphas.shape == t_starts.shape
+        ), "alphas must have shape of (N,)! Got {}".format(alphas.shape)
+        
+        # Rendering: compute weights.
+        weights, trans = render_weight_from_alpha(
+            alphas,
+            ray_indices=ray_indices,
+            n_rays=n_rays,
+        )
+        extras = {
+            "weights": weights,
+            "trans": trans,
+            "rgbs": rgbs,
+            "alphas": alphas,
+        }
+
+    # Rendering: accumulate rgbs, opacities, and depths along the rays.
+    colors = accumulate_along_rays(
+        weights, values=rgbs, ray_indices=ray_indices, n_rays=n_rays
+    )
+    # print("debug:accumulate rgbs:",colors.max())
+
+    opacities = accumulate_along_rays(
+        weights, values=None, ray_indices=ray_indices, n_rays=n_rays
+    )
+    depths = accumulate_along_rays(
+        weights,
+        values=(t_starts + t_ends)[..., None] / 2.0,
+        ray_indices=ray_indices,
+        n_rays=n_rays,
+    )
+    depths = depths / opacities.clamp_min(torch.finfo(rgbs.dtype).eps)
+    return colors, opacities, depths, extras
+
+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])
+    """
+    # FIXME Try not to use exclusive_prod because:
+    # 1. torch.cumprod is much slower than torch.cumsum
+    # 2. exclusive_prod gradient on input == 0 is not correct.
+    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 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, chunk_size=16384):
+    # 修改移动函数，分块执行1D信号平移，防止显存爆炸
+    # all_samples = transient.shape[0]
+    # shifted_chunks = []
+    # z_base = torch.arange(n_bins, device=transient.device).float().view(1, n_bins)
+    # for i in range(0, all_samples, chunk_size):
+    #     curr_transient = transient[i : i+chunk_size]
+    #     curr_depth = depth[i : i+chunk_size]
+    #     curr_x_dim = curr_transient.shape[0]
+    #     bins_move = curr_depth / exposure_time
+    #     if curr_x_dim % 2 == 0:
+    #         x = (torch.arange(curr_x_dim, device=transient.device) - curr_x_dim//2+0.5)/(curr_x_dim//2-0.5)
+    #     else:
+    #         x = (torch.arange(curr_x_dim, device=transient.device) - curr_x_dim//2)/(curr_x_dim//2)
+    #     if curr_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 = torch.nn.functional.grid_sample(
+    #         curr_transient.permute(2, 0, 1)[None],
+    #         grid,
+    #         align_corners=True,
+    #         padding_mode='zeros'
+    #     )
+    #     shifted_chunks.append(shifted.squeeze(0).permute(1, 2, 0))
+    # return torch.cat(shifted_chunks, dim=0)
+    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/FlyingWithPhotons/radiance_fields/ngp.py

@@ -0,0 +1,306 @@
+"""
+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.args = args
+        if self.version == "simulated":
+            self.colour_channels = 3
+        else:
+            self.colour_channels = 1
+        
+        self.radiance_activation = radiance_activation 
+        self.n_output_dim = args.n_bins*self.colour_channels
+                   
+        
+
+
+        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/FlyingWithPhotons/requirements.txt

@@ -0,0 +1,23 @@
+# Install PyTorch 2.5.1 / CUDA 11.8 first; see README.
+ConfigArgParse==1.7.5
+ImageIO==2.37.2
+PyYAML==6.0.3
+h5py==3.15.1
+imgviz==1.7.6
+lpips==0.1.4
+mat73==0.65
+matplotlib==3.10.7
+nerfacc==0.5.3
+numpy==1.26.4
+packaging==25.0
+pillow==12.0.0
+scikit-image==0.25.2
+scipy==1.15.3
+sparse==0.17.0
+tensorboard==2.10.1
+torch==2.5.1
+torchvision==0.20.1
+tqdm==4.67.1
+
+# CUDA extensions (install after PyTorch; source build needs the CUDA toolchain).
+tinycudann @ git+https://github.com/NVlabs/tiny-cuda-nn@38e50edc4a5f785afe0ef21f9c75b8949890be84#subdirectory=bindings/torch