Upload STB code utilities

codes/annotation tool/labelLidarwave.py

@@ -0,0 +1,1780 @@
+# visualize_semantic_labels_v3.py
+# ------------------------------------------------------------
+# Sequential peak annotation workflow + Multi-layer semantic 3D
+#
+# Added: Traditional Magic Wand UI & Edge-aware region growing
+#
+# MOD (New Features Request - V3):
+# ✅ [Restored] 3D Bins Visualization button and logic.
+# ✅ [Modified] Pixel Histogram now works in a dedicated "Inspect" tool mode.
+#    - Pick/Brush/Eraser: Perform labeling ONLY.
+#    - Inspect: Performs histogram visualization ONLY (Safe mode).
+# ------------------------------------------------------------
+
+import sys
+import os
+import traceback
+import argparse
+import numpy as np
+import cv2
+from glob import glob
+from collections import deque
+import matplotlib
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+# Set backend before importing pyplot
+matplotlib.use("Qt5Agg")
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+    print("[Warning] Pandas not installed. TXT->NPY conversion will be disabled.")
+
+from PyQt5.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QLabel, QPushButton, QSlider, QRadioButton, QGroupBox,
+    QSplitter, QSizePolicy, QTextEdit, QScrollArea, QCheckBox,
+    QButtonGroup, QShortcut, QListWidget, QListWidgetItem,
+    QProgressBar, QMessageBox, QLineEdit, QFileDialog, QDialog
+)
+from PyQt5.QtCore import Qt, QPoint, QRect, QThread, pyqtSignal
+from PyQt5.QtGui import QImage, QPixmap, QPainter, QColor, QPen, QKeySequence
+
+try:
+    import open3d as o3d
+    HAS_OPEN3D = True
+except ImportError:
+    HAS_OPEN3D = False
+    print("[Warning] Open3D not installed. 3D visualization will be disabled.")
+
+
+# ==========================================
+# Config
+# ==========================================
+class AppConfig:
+    IMG_H = 192
+    IMG_W = 256
+    NUM_LAYERS = 30
+    BIN_UNIT = 297 * 1e-12 * 299792458 / 2.0
+    DEFAULT_SIGNAL_THRESHOLD = 5
+    DEFAULT_SNR_THRESHOLD = 2.0
+    LABEL_FWHM_RATIO = 0.5
+
+    CLASS_LABELS = [
+        "Tree (树)", "Road (路)", "Fence (围栏)", "Person (人)",
+        "Non-motor (非机动车)", "Car (汽车)", "Street Light (路灯)",
+        "Signage (指示牌)", "Traffic Light (信号灯)", "Door (门)",
+        "Building (建筑)", "Wall (墙壁)", "Indoor Roof (室内屋顶)",
+        "Unknown (未知)"
+    ]
+
+    CUSTOM_COLORS = {
+        1: (0, 255, 0),       2: (128, 128, 128),   3: (255, 165, 0),
+        4: (255, 0, 0),       5: (255, 20, 147),    6: (30, 144, 255),
+        7: (218, 165, 32),    8: (0, 255, 255),     9: (255, 69, 0),
+        10: (165, 42, 42),    11: (160, 32, 240),   12: (189, 183, 107),
+        13: (0, 128, 128),    14: (255, 255, 0)
+    }
+
+    CAM_K = np.array([[120.94, 0.0, 130.41], [0.0, 121.12, 97.12], [0.0, 0.0, 1.0]], dtype=np.float64)
+    CAM_D = np.array([-0.276, 0.062, 0.0, 0.0, 0.0], dtype=np.float64)
+
+    DEFAULT_WAND_TOLERANCE = 15
+    DEFAULT_WAND_EDGE_HIGH = 80
+    DEFAULT_WAND_CONNECTIVITY_8 = True
+    DEFAULT_WAND_EDGE_AWARE = True
+
+
+def get_class_colors_dict():
+    colors = {0: (0, 0, 0)}
+    colors.update(AppConfig.CUSTOM_COLORS)
+    return colors
+
+
+CLASS_COLORS = get_class_colors_dict()
+
+
+def _cv2_cmap(name: str, fallback):
+    return getattr(cv2, name, fallback)
+
+
+PEAK_CMAPS = [
+    ("VIRIDIS", _cv2_cmap("COLORMAP_VIRIDIS", cv2.COLORMAP_JET)),
+    ("PLASMA",  _cv2_cmap("COLORMAP_PLASMA",  cv2.COLORMAP_JET)),
+    ("INFERNO", _cv2_cmap("COLORMAP_INFERNO", cv2.COLORMAP_JET)),
+    ("MAGMA",   _cv2_cmap("COLORMAP_MAGMA",   cv2.COLORMAP_JET)),
+    ("TURBO",   _cv2_cmap("COLORMAP_TURBO",   cv2.COLORMAP_JET)),
+    ("JET",     cv2.COLORMAP_JET),
+    ("HOT",     cv2.COLORMAP_HOT),
+    ("OCEAN",   cv2.COLORMAP_OCEAN),
+]
+
+
+# ==========================================
+# Helpers (General)
+# ==========================================
+def load_hist_npy(path: str) -> np.ndarray:
+    try:
+        print(f"[Log] Loading NPY: {path}")
+        data = np.load(path, mmap_mode="r")
+        if data.ndim == 3:
+            H, W, B = data.shape
+            data = data.reshape(-1, B)
+        elif data.ndim == 1:
+            data = data.reshape(1, -1)
+        return np.ascontiguousarray(data, dtype=np.float32)
+    except Exception as e:
+        print(f"[Error] Loading {path} failed: {e}", flush=True)
+        return None
+
+
+def analyze_peak_structure(vector, peak_idx, noise_floor):
+    B = len(vector)
+    peak_val = vector[peak_idx]
+    if peak_val <= noise_floor:
+        return (peak_idx, peak_idx), (peak_idx, peak_idx)
+
+    label_thresh = peak_val * AppConfig.LABEL_FWHM_RATIO
+    l_lab, r_lab = peak_idx, peak_idx
+    while l_lab > 0 and vector[l_lab] > label_thresh:
+        l_lab -= 1
+    while r_lab < B - 1 and vector[r_lab] > label_thresh:
+        r_lab += 1
+
+    l_rem, r_rem = peak_idx, peak_idx
+    while l_rem > 0:
+        if vector[l_rem] < noise_floor or vector[l_rem - 1] > vector[l_rem]:
+            break
+        l_rem -= 1
+    while r_rem < B - 1:
+        if vector[r_rem] < noise_floor or vector[r_rem + 1] > vector[r_rem]:
+            break
+        r_rem += 1
+
+    l_rem = min(l_rem, l_lab)
+    r_rem = max(r_rem, r_lab)
+    return (l_lab, r_lab), (l_rem, r_rem)
+
+
+def safe_numpy_to_pixmap(img_data):
+    if img_data is None:
+        return None
+    h, w = img_data.shape[:2]
+    try:
+        if not img_data.flags["C_CONTIGUOUS"]:
+            img_data = np.ascontiguousarray(img_data)
+
+        if img_data.ndim == 2:
+            qimg = QImage(img_data.data, w, h, w, QImage.Format_Grayscale8).copy()
+        elif img_data.ndim == 3:
+            if img_data.shape[2] == 3:
+                img_rgba = cv2.cvtColor(img_data, cv2.COLOR_BGR2RGBA)
+                qimg = QImage(img_rgba.data, w, h, w * 4, QImage.Format_RGBA8888).copy()
+            elif img_data.shape[2] == 4:
+                qimg = QImage(img_data.data, w, h, w * 4, QImage.Format_RGBA8888).copy()
+            else:
+                return None
+        else:
+            return None
+        return QPixmap.fromImage(qimg)
+    except Exception:
+        return None
+
+
+def get_robust_colors(values, colormap_name="jet", p_min=2, p_max=99.5):
+    vmin, vmax = np.percentile(values, [p_min, p_max])
+    denom = max(vmax - vmin, 1e-6)
+    norm_values = np.clip((values - vmin) / denom, 0, 1)
+    cmap = plt.get_cmap(colormap_name)
+    colors = cmap(norm_values)[:, :3]
+    return colors
+
+
+def sem_bins_to_layers(sem_bins: np.ndarray, H: int, W: int, num_layers: int):
+    N, B = sem_bins.shape
+    masks = [np.zeros((H, W), dtype=np.uint8) for _ in range(num_layers)]
+    flat = sem_bins
+
+    for i in range(N):
+        row = flat[i]
+        nz = np.flatnonzero(row)
+        if nz.size == 0:
+            continue
+        breaks = np.flatnonzero(np.diff(nz) != 1)
+        run_starts = np.concatenate(([0], breaks + 1))
+        run_ends = np.concatenate((breaks, [nz.size - 1]))
+        segments = []
+        for rs, re in zip(run_starts, run_ends):
+            b0 = int(nz[rs])
+            b1 = int(nz[re])
+            cid = int(row[b0])
+            if cid <= 0: continue
+            segments.append((b0, b1, cid))
+        segments.sort(key=lambda t: t[0])
+        y = i // W
+        x = i % W
+        for k, (_, __, cid) in enumerate(segments[:num_layers]):
+            masks[k][y, x] = cid
+    return masks
+
+
+def save_iterative_peeling_layers(out_path, raw_data, manual_masks, layer_thresholds, H, W, fallback_thresh):
+    try:
+        folder = os.path.dirname(out_path)
+        if folder and not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+
+        N, B = raw_data.shape
+        sem_bins = np.zeros((N, B), dtype=np.uint8)
+        working_data = raw_data.copy()
+        saved_count = 0
+
+        for l, mask2d in enumerate(manual_masks):
+            thr = layer_thresholds[l] if layer_thresholds[l] is not None else fallback_thresh
+            mask_flat = mask2d.reshape(-1)
+            labeled_idx = np.flatnonzero(mask_flat > 0)
+            if labeled_idx.size == 0:
+                continue
+            for idx in labeled_idx:
+                cid = int(mask_flat[idx])
+                hist = working_data[idx]
+                if np.max(hist) <= thr:
+                    continue
+                peak_idx = int(np.argmax(hist))
+                (l_lab, r_lab), (l_rem, r_rem) = analyze_peak_structure(hist, peak_idx, thr)
+                if r_rem <= l_rem:
+                    continue
+                sem_bins[idx, l_lab:r_lab + 1] = cid
+                working_data[idx, l_rem:r_rem + 1] = 0
+                saved_count += 1
+
+        np.save(out_path, sem_bins)
+        return True, f"Saved: {os.path.basename(out_path)} [Pts: {saved_count}]", saved_count
+    except Exception as e:
+        traceback.print_exc()
+        return False, f"Error saving: {str(e)}", 0
+
+
+# ==========================================
+# Batch Conversion 
+# ==========================================
+def convert_one_file(file_path, output_root):
+    try:
+        import pandas as pd
+        basename = os.path.basename(file_path)
+        npy_name = os.path.splitext(basename)[0] + '.npy'
+        out_path = os.path.join(output_root, npy_name)
+        if os.path.exists(out_path):
+            return "Skipped (Exists)"
+        df = pd.read_csv(file_path, sep=r'\s+', header=None, dtype=np.float32, engine='c', memory_map=True)
+        data = df.values
+        if data.ndim == 1:
+            data = data.reshape(1, -1)
+        np.save(out_path, data)
+        return "Success"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+class BatchConverterThread(QThread):
+    progress_signal = pyqtSignal(int, int)
+    log_signal = pyqtSignal(str)
+    finished_signal = pyqtSignal(int, int, int)
+
+    def __init__(self, root_search_dir, output_dir):
+        super().__init__()
+        self.root_search_dir = root_search_dir
+        self.output_dir = output_dir
+        self.is_running = True
+
+    def run(self):
+        if not HAS_PANDAS:
+            self.log_signal.emit("[Error] Pandas not found.")
+            self.finished_signal.emit(0, 0, 0)
+            return
+
+        self.log_signal.emit(f"Scanning for TXT files in: {self.root_search_dir}")
+        search_pattern = os.path.join(self.root_search_dir, "**", "RawDataHistogramMap_frame_*.txt")
+        files = glob(search_pattern, recursive=True)
+        if not files:
+            search_pattern_alt = os.path.join(self.root_search_dir, "**", "*.txt")
+            files = glob(search_pattern_alt, recursive=True)
+
+        total_files = len(files)
+        self.log_signal.emit(f"Found {total_files} files.")
+        if total_files == 0:
+            self.finished_signal.emit(0, 0, 0)
+            return
+
+        try:
+            os.makedirs(self.output_dir, exist_ok=True)
+        except Exception as e:
+            self.finished_signal.emit(0, 0, 0)
+            return
+        
+        success_count = 0
+        skip_count = 0
+        error_count = 0
+        processed = 0
+        max_workers = min(os.cpu_count() or 4, 8)
+        
+        with ProcessPoolExecutor(max_workers=max_workers) as executor:
+            future_to_file = {executor.submit(convert_one_file, f, self.output_dir): f for f in files}
+            for future in as_completed(future_to_file):
+                if not self.is_running:
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    break
+                result = future.result()
+                processed += 1
+                if result == "Success": success_count += 1
+                elif result == "Skipped (Exists)": skip_count += 1
+                else: error_count += 1
+                self.progress_signal.emit(processed, total_files)
+
+        self.finished_signal.emit(success_count, skip_count, error_count)
+
+    def stop(self):
+        self.is_running = False
+
+
+# ==========================================
+# GUI widgets
+# ==========================================
+class CenteredCanvas(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setMouseTracking(True)
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.img_pixmap = None
+        self.zoom = 1.0
+        self.offset = QPoint(0, 0)
+        self.last_mouse_pos = QPoint()
+        self.mode = "pick"
+        self.panning = False
+        self.drawing = False
+        self.start_pos = QPoint()
+        self.curr_pos = QPoint()
+        self.action_callback = None
+        self.mask_overlay = None
+        self.ghost_overlay = None
+        self.hide_labels = False
+        self.ctrl_pressed = False
+
+    def set_content(self, pixmap, mask_pixmap, ghost_pixmap=None):
+        self.img_pixmap = pixmap
+        self.mask_overlay = mask_pixmap
+        self.ghost_overlay = ghost_pixmap
+        self.update()
+
+    def fit_to_window(self):
+        if self.img_pixmap is None:
+            return
+        w_view, h_view = self.width(), self.height()
+        w_img, h_img = self.img_pixmap.width(), self.img_pixmap.height()
+        if w_img > 0 and h_img > 0:
+            self.zoom = min(w_view / w_img, h_view / h_img) * 0.98
+            self.offset = QPoint(0, 0)
+        self.update()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), QColor(40, 40, 40))
+        if self.img_pixmap is None:
+            return
+        ww, wh = self.width(), self.height()
+        cx, cy = ww // 2, wh // 2
+        painter.translate(cx + self.offset.x(), cy + self.offset.y())
+        painter.scale(self.zoom, self.zoom)
+        iw, ih = self.img_pixmap.width(), self.img_pixmap.height()
+        painter.translate(-iw // 2, -ih // 2)
+        painter.setRenderHint(QPainter.SmoothPixmapTransform, False)
+        painter.drawPixmap(0, 0, self.img_pixmap)
+        if not self.hide_labels:
+            if self.ghost_overlay is not None:
+                painter.setOpacity(0.30)
+                painter.drawPixmap(0, 0, self.ghost_overlay)
+                painter.setOpacity(1.0)
+            if self.mask_overlay is not None:
+                painter.setOpacity(1.0)
+                painter.drawPixmap(0, 0, self.mask_overlay)
+        
+        # Only draw selection box if NOT in inspect mode or pure panning
+        if self.drawing and self.mode == "pick":
+            pen = QPen(Qt.green, 2) if self.ctrl_pressed else QPen(Qt.yellow, 1)
+            pen.setStyle(Qt.SolidLine if self.ctrl_pressed else Qt.DashLine)
+            painter.setPen(pen)
+            painter.drawRect(QRect(self.start_pos, self.curr_pos).normalized())
+
+    def get_img_pos(self, widget_pos):
+        ww, wh = self.width(), self.height()
+        cx, cy = ww // 2, wh // 2
+        if self.img_pixmap:
+            dx = widget_pos.x() - (cx + self.offset.x())
+            dy = widget_pos.y() - (cy + self.offset.y())
+            return int(dx / self.zoom + self.img_pixmap.width() / 2), int(dy / self.zoom + self.img_pixmap.height() / 2)
+        return 0, 0
+
+    def wheelEvent(self, event):
+        self.zoom *= 1.1 if event.angleDelta().y() > 0 else 0.9
+        self.zoom = max(0.1, min(self.zoom, 50.0))
+        self.update()
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MiddleButton:
+            self.panning = True
+            self.last_mouse_pos = event.pos()
+            self.setCursor(Qt.ClosedHandCursor)
+        elif event.button() == Qt.LeftButton:
+            x, y = self.get_img_pos(event.pos())
+            self.start_pos = QPoint(x, y)
+            self.curr_pos = QPoint(x, y)
+            self.drawing = True
+            if self.mode == "draw" and self.action_callback:
+                self.action_callback("draw_start", self.start_pos, None)
+
+    def mouseMoveEvent(self, event):
+        if self.panning:
+            self.offset += event.pos() - self.last_mouse_pos
+            self.last_mouse_pos = event.pos()
+            self.update()
+        else:
+            x, y = self.get_img_pos(event.pos())
+            self.curr_pos = QPoint(x, y)
+            if self.drawing:
+                if self.mode == "draw" and self.action_callback:
+                    self.action_callback("draw_drag", self.start_pos, self.curr_pos)
+                    self.start_pos = self.curr_pos
+                elif self.mode == "pick":
+                    self.update()
+
+    def mouseReleaseEvent(self, event):
+        if self.panning:
+            self.panning = False
+            self.setCursor(Qt.ArrowCursor)
+            return
+        if event.button() == Qt.LeftButton and self.drawing:
+            self.drawing = False
+            end_pos = self.curr_pos if not self.curr_pos.isNull() else self.start_pos
+            if self.mode == "pick" and self.action_callback:
+                self.action_callback("pick_end_ctrl" if self.ctrl_pressed else "pick_end", self.start_pos, end_pos)
+            elif self.mode == "draw" and self.action_callback:
+                self.action_callback("draw_end", end_pos, None)
+            self.update()
+
+class PopupImageDialog(QDialog):
+    def __init__(self, pixmap, title, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(title + " (Double click to close)")
+        self.resize(800, 600)
+        self.setWindowFlags(Qt.Window)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.viewer = CenteredCanvas()
+        self.viewer.set_content(pixmap, None)
+        self.viewer.fit_to_window()
+        layout.addWidget(self.viewer)
+        
+    def showEvent(self, event):
+        self.viewer.fit_to_window()
+        super().showEvent(event)
+
+class ResizableImage(QWidget):
+    def __init__(self, parent=None, title=""):
+        super().__init__(parent)
+        self.pixmap = None
+        self.title = title
+        self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
+        self.setMinimumHeight(150)
+        self.setCursor(Qt.PointingHandCursor)
+        self.setToolTip("Double click to enlarge (Popup)")
+
+    def set_image(self, pixmap):
+        self.pixmap = pixmap
+        self.update()
+
+    def set_title(self, title: str):
+        self.title = title
+        self.update()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), QColor(25, 25, 25))
+        painter.setPen(Qt.white)
+        painter.drawText(10, 20, self.title)
+        if self.pixmap:
+            target = self.rect().adjusted(0, 25, 0, 0)
+            scaled = self.pixmap.scaled(target.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            x = target.x() + (target.width() - scaled.width()) // 2
+            y = target.y() + (target.height() - scaled.height()) // 2
+            painter.drawPixmap(x, y, scaled)
+
+    def mouseDoubleClickEvent(self, event):
+        if self.pixmap:
+            self.pop = PopupImageDialog(self.pixmap, self.title, self)
+            self.pop.show()
+
+class PixelHistogramDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Pixel Histogram Inspector")
+        self.resize(600, 450)
+        self.setWindowFlags(Qt.Window)
+        layout = QVBoxLayout(self)
+        self.fig = Figure(figsize=(5, 4), dpi=100)
+        self.canvas = FigureCanvas(self.fig)
+        self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        layout.addWidget(self.canvas)
+        self.ax = self.fig.add_subplot(111)
+        self.status_label = QLabel("Switch tool to 'Inspect' and click pixel.")
+        layout.addWidget(self.status_label)
+
+    def update_plot(self, x, y, raw_vec, labels_info, noise_floor=0):
+        self.ax.clear()
+        self.ax.plot(raw_vec, color='black', linewidth=1.0, label='Photon Counts')
+        max_val = np.max(raw_vec) if raw_vec.size > 0 else 1.0
+        drawn_labels = set()
+        for item in labels_info:
+            cid = item['cid']
+            l_range, r_range = item['range']
+            rgb = item['color']
+            c_norm = (rgb[0]/255.0, rgb[1]/255.0, rgb[2]/255.0)
+            x_vals = np.arange(l_range, r_range + 1)
+            if x_vals.size > 0:
+                label_text = f"Class {cid}"
+                if cid not in drawn_labels:
+                    self.ax.fill_between(x_vals, 0, max_val * 1.1, color=c_norm, alpha=0.3, label=label_text)
+                    drawn_labels.add(cid)
+                else:
+                    self.ax.fill_between(x_vals, 0, max_val * 1.1, color=c_norm, alpha=0.3)
+        if noise_floor > 0:
+            self.ax.axhline(y=noise_floor, color='gray', linestyle='--', alpha=0.5, label='Noise Level')
+        self.ax.set_title(f"Pixel ({x}, {y}) | Max: {max_val:.1f}")
+        self.ax.set_xlabel("Time Bins")
+        self.ax.set_ylabel("Counts")
+        self.ax.grid(True, linestyle=':', alpha=0.6)
+        if drawn_labels:
+            self.ax.legend(loc='upper right')
+        self.canvas.draw()
+        self.status_label.setText(f"Inspecting Pixel: x={x}, y={y}")
+
+
+# ==========================================
+# Main window
+# ==========================================
+class SPADLabelerPixel(QMainWindow):
+    def __init__(self, args):
+        super().__init__()
+        self.args = args
+        self.setWindowTitle("SPAD Labeler - Sequential Peak Annotation")
+        self.resize(1780, 1040)
+        os.makedirs(self.args.cache_dir, exist_ok=True)
+
+        self.H, self.W = AppConfig.IMG_H, AppConfig.IMG_W
+        self.num_layers = AppConfig.NUM_LAYERS
+        self.class_names = {i + 1: name for i, name in enumerate(AppConfig.CLASS_LABELS)}
+        self.UNKNOWN_CID = int(max(self.class_names.keys()))
+        self.class_colors_rgb = CLASS_COLORS
+
+        self.raw_data = None
+        self.noise_map = None
+        self.layer_view_cache = {}
+
+        self.manual_masks = [np.zeros((self.H, self.W), dtype=np.uint8) for _ in range(self.num_layers)]
+        self.layer_thresholds = [None for _ in range(self.num_layers)]
+
+        self.undo_stack = deque(maxlen=20)
+        self.is_dirty = False
+        self.mask_revision = 0
+        self.brush_size = 5
+        self.tool_mode = "pick"
+        self.current_class = 1
+        self.peel_depth = 0
+        self.edit_layer = 0
+        self.region_step = 0
+        self.peel_by_class = True
+        self._region_cache_layer = None
+        self._region_cache_revision = -1
+        self._region_cache_mode = None
+        self._region_cache_regions = []
+
+        self.wand_tolerance = int(AppConfig.DEFAULT_WAND_TOLERANCE)
+        self.wand_connectivity_8 = bool(AppConfig.DEFAULT_WAND_CONNECTIVITY_8)
+        self.wand_edge_aware = bool(AppConfig.DEFAULT_WAND_EDGE_AWARE)
+        self.wand_edge_high = int(AppConfig.DEFAULT_WAND_EDGE_HIGH)
+
+        self.converter_thread = None
+        self.hist_inspector = None
+
+        self.init_ui()
+
+        self.file_list = sorted(glob(os.path.join(args.in_dir, args.pattern)))
+        self.current_file_idx = 0
+        self.update_file_list_ui()
+        if self.file_list:
+            self.load_file(self.file_list[0])
+
+    # ---------------- UI ----------------
+    def init_ui(self):
+        self.splitter = QSplitter(Qt.Horizontal)
+        self.setCentralWidget(self.splitter)
+
+        self.left_panel = QSplitter(Qt.Vertical)
+        self.lbl_global = ResizableImage(title="Layer 0 (Raw Peak)")
+        self.left_panel.addWidget(self.lbl_global)
+        self.lbl_result = ResizableImage(title="Annotation Preview (Unpeeled + Current Region State)")
+        self.left_panel.addWidget(self.lbl_result)
+        self.lbl_info = ResizableImage(title="Peeling View")
+        self.left_panel.addWidget(self.lbl_info)
+        self.lbl_depth = ResizableImage(title="Depth Map (Visible Peak)")
+        self.left_panel.addWidget(self.lbl_depth)
+
+        self.left_ctrl = QWidget()
+        l_lay = QVBoxLayout(self.left_ctrl)
+        l_lay.addWidget(QLabel("<b>Peel / Edit / Region Control</b>"))
+        l_lay.addWidget(QLabel("<i>Tip: Double-click images above to enlarge.</i>"))
+
+        l_lay.addWidget(QLabel("Peel Depth (display stage):"))
+        self.sl_peel = QSlider(Qt.Horizontal)
+        self.sl_peel.setRange(0, self.num_layers)
+        self.sl_peel.setValue(0)
+        self.sl_peel.valueChanged.connect(self.change_peel_depth)
+        l_lay.addWidget(self.sl_peel)
+
+        self.lbl_region = QLabel("Semantic Step (current peeled layer): 0 / 0")
+        l_lay.addWidget(self.lbl_region)
+        self.sl_region = QSlider(Qt.Horizontal)
+        self.sl_region.setRange(0, 0)
+        self.sl_region.setValue(0)
+        self.sl_region.valueChanged.connect(self.change_region_step)
+        l_lay.addWidget(self.sl_region)
+
+        self.lbl_next_region = QLabel("Selected Peel Target: -")
+        self.lbl_next_region.setWordWrap(True)
+        l_lay.addWidget(self.lbl_next_region)
+
+        l_lay.addWidget(QLabel("Edit Layer (write target):"))
+        self.sl_edit = QSlider(Qt.Horizontal)
+        self.sl_edit.setRange(0, self.num_layers - 1)
+        self.sl_edit.setValue(0)
+        self.sl_edit.valueChanged.connect(self.change_edit_layer)
+        l_lay.addWidget(self.sl_edit)
+
+        self.chk_auto_edit = QCheckBox("Auto Edit Layer = Peel Depth (recommended)")
+        self.chk_auto_edit.setChecked(True)
+        self.chk_auto_edit.toggled.connect(self.on_auto_edit_toggled)
+        l_lay.addWidget(self.chk_auto_edit)
+
+        self.chk_lock_to_visible = QCheckBox("Lock labeling to visible peak")
+        self.chk_lock_to_visible.setChecked(True)
+        self.chk_lock_to_visible.toggled.connect(self.update_all_views)
+        l_lay.addWidget(self.chk_lock_to_visible)
+
+        self.chk_focus_edit = QCheckBox("Focus view to Edit Layer")
+        self.chk_focus_edit.setChecked(True)
+        self.chk_focus_edit.toggled.connect(self.update_all_views)
+        l_lay.addWidget(self.chk_focus_edit)
+
+        self.chk_peel_class = QCheckBox("Region Step by Semantic")
+        self.chk_peel_class.setChecked(True)
+        self.chk_peel_class.toggled.connect(self.on_peel_mode_changed)
+        l_lay.addWidget(self.chk_peel_class)
+
+        self.lbl_state = QLabel("Peel Depth: 0 | Region Step: 0 | Edit Layer: 0")
+        l_lay.addWidget(self.lbl_state)
+        self.lbl_peeled_ids = QLabel("Fully Peeled Layers: None")
+        self.lbl_peeled_ids.setStyleSheet("color: #FFA500; font-weight: bold;")
+        l_lay.addWidget(self.lbl_peeled_ids)
+        self.btn_clear_layer_thr = QPushButton("Clear Layer Threshold Locks")
+        self.btn_clear_layer_thr.clicked.connect(self.clear_layer_threshold_locks)
+        l_lay.addWidget(self.btn_clear_layer_thr)
+
+        l_lay.addStretch()
+        self.left_panel.addWidget(self.left_ctrl)
+        self.left_panel.setSizes([220, 220, 220, 220, 300])
+        self.splitter.addWidget(self.left_panel)
+
+        self.canvas = CenteredCanvas()
+        self.canvas.action_callback = self.handle_canvas_action
+        self.splitter.addWidget(self.canvas)
+
+        self.right_panel = QWidget()
+        r_lay = QVBoxLayout(self.right_panel)
+
+        r_lay.addWidget(QLabel("<b>File List:</b>"))
+        self.file_list_widget = QListWidget()
+        self.file_list_widget.setFixedHeight(200)
+        self.file_list_widget.currentRowChanged.connect(self.on_file_list_clicked)
+        r_lay.addWidget(self.file_list_widget)
+
+        r_lay.addWidget(QLabel("<b>Batch Convert Config:</b>"))
+        h_src = QHBoxLayout()
+        self.txt_source_edit = QLineEdit()
+        self.txt_source_edit.setText(self.args.in_dir) 
+        self.txt_source_edit.setPlaceholderText("Path to folder with TXT files...")
+        btn_browse_src = QPushButton("...")
+        btn_browse_src.setFixedWidth(30)
+        btn_browse_src.clicked.connect(self.browse_txt_source)
+        h_src.addWidget(self.txt_source_edit)
+        h_src.addWidget(btn_browse_src)
+        r_lay.addLayout(h_src)
+
+        self.btn_convert = QPushButton("Batch Convert TXT -> NPY")
+        self.btn_convert.setStyleSheet("background-color: #3d3d3d; color: #aaffaa;")
+        self.btn_convert.clicked.connect(self.start_batch_conversion)
+        r_lay.addWidget(self.btn_convert)
+        self.pbar = QProgressBar()
+        self.pbar.setVisible(False)
+        r_lay.addWidget(self.pbar)
+
+        h_nav = QHBoxLayout()
+        btn_pl = QPushButton("Peel -1 (A)")
+        btn_pl.clicked.connect(self.apply_peel_prev)
+        btn_nl = QPushButton("Peel +1 (D)")
+        btn_nl.clicked.connect(self.apply_peel_next)
+        h_nav.addWidget(btn_pl)
+        h_nav.addWidget(btn_nl)
+        r_lay.addLayout(h_nav)
+
+        h_reg = QHBoxLayout()
+        btn_rprev = QPushButton("Region -1 (Z)")
+        btn_rprev.clicked.connect(self.region_prev)
+        btn_rnext = QPushButton("Region +1 (X)")
+        btn_rnext.clicked.connect(self.region_next)
+        h_reg.addWidget(btn_rprev)
+        h_reg.addWidget(btn_rnext)
+        r_lay.addLayout(h_reg)
+
+        h_edit = QHBoxLayout()
+        btn_el = QPushButton("Edit -1 (Shift+A)")
+        btn_el.clicked.connect(self.edit_prev)
+        btn_er = QPushButton("Edit +1 (Shift+D)")
+        btn_er.clicked.connect(self.edit_next)
+        h_edit.addWidget(btn_el)
+        h_edit.addWidget(btn_er)
+        r_lay.addLayout(h_edit)
+
+        h_file = QHBoxLayout()
+        btn_pf = QPushButton("<< File")
+        btn_pf.clicked.connect(self.prev_file)
+        btn_nf = QPushButton("File >>")
+        btn_nf.clicked.connect(self.next_file)
+        h_file.addWidget(btn_pf)
+        h_file.addWidget(btn_nf)
+        r_lay.addLayout(h_file)
+
+        self.chk_autosave = QCheckBox("Auto Save")
+        self.chk_autosave.setChecked(True)
+        r_lay.addWidget(self.chk_autosave)
+
+        h_viz = QHBoxLayout()
+        self.chk_ghost = QCheckBox("Ghost (G)")
+        self.chk_ghost.toggled.connect(self.update_all_views)
+        self.chk_hide = QCheckBox("Hide (H)")
+        self.chk_hide.toggled.connect(self.update_all_views)
+        btn_viz = QPushButton("3D Depth")
+        btn_viz.clicked.connect(self.visualize_3d_point_cloud)
+        btn_sem = QPushButton("3D Semantic")
+        btn_sem.clicked.connect(self.visualize_3d_semantic_point_cloud)
+        
+        # [RESTORED] 3D Bins Button
+        btn_bins = QPushButton("3D Bins")
+        btn_bins.clicked.connect(self.visualize_3d_semantic_bins_point_cloud)
+
+        btn_hist = QPushButton("Pixel Hist")
+        btn_hist.clicked.connect(self.open_pixel_inspector)
+
+        h_viz.addWidget(self.chk_ghost)
+        h_viz.addWidget(self.chk_hide)
+        h_viz.addWidget(btn_viz)
+        h_viz.addWidget(btn_sem)
+        h_viz.addWidget(btn_bins) # Add back
+        h_viz.addWidget(btn_hist)
+        r_lay.addLayout(h_viz)
+
+        g_filt = QGroupBox("Filter (Threshold & SNR)")
+        f_lay = QVBoxLayout(g_filt)
+        self.sl_thresh = QSlider(Qt.Horizontal)
+        self.sl_thresh.setRange(0, 2000)
+        self.sl_thresh.setValue(AppConfig.DEFAULT_SIGNAL_THRESHOLD)
+        self.lbl_thr = QLabel(f"Int Thresh: {AppConfig.DEFAULT_SIGNAL_THRESHOLD}")
+        self.sl_thresh.valueChanged.connect(self.on_thresh_changed)
+        h_t = QHBoxLayout()
+        h_t.addWidget(self.sl_thresh)
+        h_t.addWidget(self.lbl_thr)
+        f_lay.addLayout(h_t)
+        self.sl_snr = QSlider(Qt.Horizontal)
+        self.sl_snr.setRange(10, 200)
+        self.sl_snr.setValue(int(AppConfig.DEFAULT_SNR_THRESHOLD * 10))
+        self.lbl_snr = QLabel(f"SNR (Peak/Mean) > {AppConfig.DEFAULT_SNR_THRESHOLD:.1f}")
+        self.sl_snr.valueChanged.connect(self.on_snr_changed)
+        h_s = QHBoxLayout()
+        h_s.addWidget(self.sl_snr)
+        h_s.addWidget(self.lbl_snr)
+        f_lay.addLayout(h_s)
+        r_lay.addWidget(g_filt)
+
+        g_wand = QGroupBox("Magic Wand (传统魔棒)")
+        w_lay = QVBoxLayout(g_wand)
+        self.chk_wand_edge = QCheckBox("Edge-aware")
+        self.chk_wand_edge.setChecked(self.wand_edge_aware)
+        self.chk_wand_edge.toggled.connect(self.on_wand_params_changed)
+        w_lay.addWidget(self.chk_wand_edge)
+        self.chk_wand_conn8 = QCheckBox("8-way connectivity")
+        self.chk_wand_conn8.setChecked(self.wand_connectivity_8)
+        self.chk_wand_conn8.toggled.connect(self.on_wand_params_changed)
+        w_lay.addWidget(self.chk_wand_conn8)
+        w_lay.addWidget(QLabel("Tolerance:"))
+        self.sl_wand_tol = QSlider(Qt.Horizontal)
+        self.sl_wand_tol.setRange(0, 255)
+        self.sl_wand_tol.setValue(self.wand_tolerance)
+        self.sl_wand_tol.valueChanged.connect(self.on_wand_tol_changed)
+        self.lbl_wand_tol = QLabel(str(self.wand_tolerance))
+        h_tol = QHBoxLayout()
+        h_tol.addWidget(self.sl_wand_tol)
+        h_tol.addWidget(self.lbl_wand_tol)
+        w_lay.addLayout(h_tol)
+        w_lay.addWidget(QLabel("Edge strength:"))
+        self.sl_wand_edge = QSlider(Qt.Horizontal)
+        self.sl_wand_edge.setRange(0, 255)
+        self.sl_wand_edge.setValue(self.wand_edge_high)
+        self.sl_wand_edge.valueChanged.connect(self.on_wand_edge_changed)
+        self.lbl_wand_edge = QLabel(str(self.wand_edge_high))
+        h_ed = QHBoxLayout()
+        h_ed.addWidget(self.sl_wand_edge)
+        h_ed.addWidget(self.lbl_wand_edge)
+        w_lay.addLayout(h_ed)
+        r_lay.addWidget(g_wand)
+
+        g_tool = QGroupBox("Tools")
+        t_lay = QVBoxLayout(g_tool)
+        self.rb_pick = QRadioButton("Pick (Q)")
+        self.rb_pick.setChecked(True)
+        self.rb_pick.toggled.connect(self.update_tool_mode)
+        self.rb_brush = QRadioButton("Brush (W)")
+        self.rb_brush.toggled.connect(self.update_tool_mode)
+        self.rb_eraser = QRadioButton("Eraser (E)")
+        self.rb_eraser.toggled.connect(self.update_tool_mode)
+        
+        # [NEW] Inspect Mode
+        self.rb_inspect = QRadioButton("Inspect (I)")
+        self.rb_inspect.toggled.connect(self.update_tool_mode)
+        
+        t_lay.addWidget(self.rb_pick)
+        t_lay.addWidget(self.rb_brush)
+        t_lay.addWidget(self.rb_eraser)
+        t_lay.addWidget(self.rb_inspect)
+
+        h_sz = QHBoxLayout()
+        h_sz.addWidget(QLabel("Brush Size:"))
+        self.sl_size = QSlider(Qt.Horizontal)
+        self.sl_size.setRange(1, 30)
+        self.sl_size.setValue(self.brush_size)
+        self.lbl_size = QLabel(str(self.brush_size))
+        self.sl_size.valueChanged.connect(self.update_brush_size)
+        h_sz.addWidget(self.sl_size)
+        h_sz.addWidget(self.lbl_size)
+        t_lay.addLayout(h_sz)
+        self.chk_overwrite = QCheckBox("Allow Overwrite (允许覆盖)")
+        self.chk_overwrite.setChecked(True)
+        t_lay.addWidget(self.chk_overwrite)
+        r_lay.addWidget(g_tool)
+
+        g_cls = QGroupBox("Classes")
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        content = QWidget()
+        sc_lay = QVBoxLayout(content)
+        self.cls_bg = QButtonGroup(self)
+        self.cls_radios = {}
+        for cid, name in self.class_names.items():
+            rgb = self.class_colors_rgb.get(cid, (0, 0, 0))
+            rb = QRadioButton(f"■ {name}")
+            rb.setStyleSheet(f"color: rgb{rgb}; font-weight: bold;")
+            self.cls_bg.addButton(rb, cid)
+            self.cls_radios[cid] = rb
+            sc_lay.addWidget(rb)
+        scroll.setWidget(content)
+        c_lay = QVBoxLayout(g_cls)
+        c_lay.addWidget(scroll)
+        r_lay.addWidget(g_cls)
+        self.cls_bg.buttonClicked[int].connect(lambda i: setattr(self, "current_class", int(i)))
+
+        self.log_win = QTextEdit()
+        self.log_win.setReadOnly(True)
+        self.log_win.setFixedHeight(100)
+        r_lay.addWidget(self.log_win)
+
+        btn_unk = QPushButton("Fill Unknown (Layer U)")
+        btn_unk.clicked.connect(self.fill_unknown_current_layer)
+        r_lay.addWidget(btn_unk)
+        btn_save = QPushButton("SAVE (Ctrl+S)")
+        btn_save.clicked.connect(self.save_current)
+        r_lay.addWidget(btn_save)
+
+        self.splitter.addWidget(self.right_panel)
+        self.splitter.setSizes([430, 980, 340])
+
+        self.init_shortcuts()
+        self.hist_inspector = PixelHistogramDialog(self)
+
+    def init_shortcuts(self):
+        QShortcut(QKeySequence("A"), self, self.apply_peel_prev)
+        QShortcut(QKeySequence("D"), self, self.apply_peel_next)
+        QShortcut(QKeySequence("Z"), self, self.region_prev)
+        QShortcut(QKeySequence("X"), self, self.region_next)
+        QShortcut(QKeySequence("Shift+A"), self, self.edit_prev)
+        QShortcut(QKeySequence("Shift+D"), self, self.edit_next)
+        QShortcut(QKeySequence("Left"), self, self.prev_file)
+        QShortcut(QKeySequence("Right"), self, self.next_file)
+        QShortcut(QKeySequence("Q"), self, lambda: self.rb_pick.setChecked(True))
+        QShortcut(QKeySequence("W"), self, lambda: self.rb_brush.setChecked(True))
+        QShortcut(QKeySequence("E"), self, lambda: self.rb_eraser.setChecked(True))
+        # [NEW] Shortcut for Inspect
+        QShortcut(QKeySequence("I"), self, lambda: self.rb_inspect.setChecked(True))
+        
+        QShortcut(QKeySequence("Ctrl+S"), self, self.save_current)
+        QShortcut(QKeySequence("Ctrl+Z"), self, self.undo)
+        QShortcut(QKeySequence("U"), self, self.fill_unknown_current_layer)
+        QShortcut(QKeySequence("H"), self, lambda: self.chk_hide.setChecked(not self.chk_hide.isChecked()))
+        QShortcut(QKeySequence("G"), self, lambda: self.chk_ghost.setChecked(not self.chk_ghost.isChecked()))
+        QShortcut(QKeySequence("F"), self, lambda: self.chk_focus_edit.setChecked(not self.chk_focus_edit.isChecked()))
+        QShortcut(QKeySequence("T"), self, lambda: self.chk_lock_to_visible.setChecked(not self.chk_lock_to_visible.isChecked()))
+        QShortcut(QKeySequence("R"), self, lambda: self.chk_peel_class.setChecked(not self.chk_peel_class.isChecked()))
+        QShortcut(QKeySequence("["), self, self.cycle_class_prev)
+        QShortcut(QKeySequence("]"), self, self.cycle_class_next)
+        QShortcut(QKeySequence("="), self, lambda: self.morph_current_mask("dilate"))
+        QShortcut(QKeySequence("-"), self, lambda: self.morph_current_mask("erode"))
+
+        keys = [Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_4, Qt.Key_5,
+                Qt.Key_6, Qt.Key_7, Qt.Key_8, Qt.Key_9, Qt.Key_0]
+        for i, key in enumerate(keys):
+            cls_idx = i + 1
+            if cls_idx in self.class_names:
+                QShortcut(QKeySequence(key), self, lambda idx=cls_idx: self.set_class_by_key(idx))
+
+    # ---------------- UI Helper Methods ----------------
+    def browse_txt_source(self):
+        directory = QFileDialog.getExistingDirectory(
+            self, "Select TXT Source Directory", self.txt_source_edit.text()
+        )
+        if directory:
+            self.txt_source_edit.setText(directory)
+
+    # ---------------- Pixel Inspector ----------------
+    def open_pixel_inspector(self):
+        if self.hist_inspector is None:
+            self.hist_inspector = PixelHistogramDialog(self)
+        self.hist_inspector.show()
+        self.hist_inspector.raise_()
+        self.hist_inspector.activateWindow()
+        # Auto switch to inspect mode for convenience? Optional.
+        # self.rb_inspect.setChecked(True)
+
+    def update_histogram_inspector(self, x, y):
+        if self.hist_inspector is None or not self.hist_inspector.isVisible():
+            # If closed, re-open
+            self.open_pixel_inspector()
+            
+        if self.raw_data is None: return
+        idx = y * self.W + x
+        if idx >= self.raw_data.shape[0]: return
+        raw_vec = self.raw_data[idx]
+        labels_info = self.simulate_pixel_peeling(x, y, raw_vec)
+        noise = self.noise_map[y, x] if self.noise_map is not None else 0
+        self.hist_inspector.update_plot(x, y, raw_vec, labels_info, noise)
+
+    def simulate_pixel_peeling(self, x, y, raw_vec):
+        labels_info = []
+        working_vec = raw_vec.copy()
+        curr_thr = int(self.sl_thresh.value())
+        for l in range(self.num_layers):
+            m = self.manual_masks[l]
+            cid = int(m[y, x])
+            if cid > 0:
+                thr = self.layer_thresholds[l] if self.layer_thresholds[l] is not None else curr_thr
+                if np.max(working_vec) > thr:
+                    peak_idx = int(np.argmax(working_vec))
+                    (l_lab, r_lab), (l_rem, r_rem) = analyze_peak_structure(working_vec, peak_idx, thr)
+                    if r_lab >= l_lab:
+                        color = self.class_colors_rgb.get(cid, (128, 128, 128))
+                        labels_info.append({'cid': cid, 'range': (l_lab, r_lab), 'color': color})
+                    if r_rem > l_rem:
+                        working_vec[l_rem:r_rem + 1] = 0
+        return labels_info
+
+    # ... [Batch Conversion methods kept same] ...
+    def start_batch_conversion(self):
+        if self.converter_thread is not None and self.converter_thread.isRunning(): return
+        target_dir = self.txt_source_edit.text().strip()
+        if not target_dir or not os.path.isdir(target_dir):
+            QMessageBox.warning(self, "Invalid Path", "Please select a valid directory containing TXT files.")
+            return
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        output_npy_dir = os.path.join(script_dir, "npy")
+        reply = QMessageBox.question(self, 'Batch Convert', 
+                                     f"Convert TXT files from:\n{target_dir}\n\nTo NPY files in:\n{output_npy_dir} ?",
+                                     QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+        if reply == QMessageBox.No: return
+        self.btn_convert.setEnabled(False)
+        self.pbar.setVisible(True)
+        self.pbar.setValue(0)
+        self.log_win.append(f"Starting batch conversion...")
+        self.converter_thread = BatchConverterThread(target_dir, output_npy_dir)
+        self.converter_thread.progress_signal.connect(self.on_conversion_progress)
+        self.converter_thread.log_signal.connect(self.log_win.append)
+        self.converter_thread.finished_signal.connect(self.on_conversion_finished)
+        self.converter_thread.start()
+
+    def on_conversion_progress(self, current, total):
+        self.pbar.setMaximum(total)
+        self.pbar.setValue(current)
+
+    def on_conversion_finished(self, success, skip, error):
+        self.log_win.append(f"Conversion Done! Success: {success}, Skipped: {skip}, Errors: {error}")
+        self.pbar.setVisible(False)
+        self.btn_convert.setEnabled(True)
+        source_dir = self.txt_source_edit.text().strip()
+        output_npy_dir = os.path.join(source_dir, "npy")
+        if os.path.abspath(self.args.in_dir) == os.path.abspath(output_npy_dir):
+            self.file_list = sorted(glob(os.path.join(self.args.in_dir, self.args.pattern)))
+            self.update_file_list_ui()
+
+    # ---------------- Magic Wand/Tools ----------------
+    def on_wand_params_changed(self, _=None):
+        self.wand_edge_aware = bool(self.chk_wand_edge.isChecked())
+        self.wand_connectivity_8 = bool(self.chk_wand_conn8.isChecked())
+
+    def on_wand_tol_changed(self, v):
+        self.wand_tolerance = int(v)
+        self.lbl_wand_tol.setText(str(int(v)))
+
+    def on_wand_edge_changed(self, v):
+        self.wand_edge_high = int(v)
+        self.lbl_wand_edge.setText(str(int(v)))
+
+    # ... [State helpers kept same] ...
+    def clear_layer_cache(self): self.layer_view_cache.clear()
+    def set_dirty(self):
+        self.clear_layer_cache()
+        self.is_dirty = True
+        self.mask_revision += 1
+        if " *" not in self.windowTitle(): self.setWindowTitle(self.windowTitle() + " *")
+    def push_undo(self):
+        stack = np.stack(self.manual_masks, axis=0).copy()
+        thr = list(self.layer_thresholds)
+        self.undo_stack.append((stack, thr, self.peel_depth, self.region_step, self.edit_layer, self.peel_by_class))
+    def clear_layer_threshold_locks(self):
+        self.layer_thresholds = [None for _ in range(self.num_layers)]
+        self.clear_layer_cache()
+        self.update_all_views()
+    def _clamp_xy(self, x, y):
+        x = max(0, min(int(x), self.W - 1))
+        y = max(0, min(int(y), self.H - 1))
+        return x, y
+    def _ensure_layer_threshold(self, layer_idx: int):
+        if self.layer_thresholds[layer_idx] is None:
+            self.layer_thresholds[layer_idx] = int(self.sl_thresh.value())
+
+    def update_brush_size(self, val):
+        self.brush_size = int(val)
+        self.lbl_size.setText(str(self.brush_size))
+
+    def on_thresh_changed(self, v):
+        self.clear_layer_cache()
+        self.update_all_views()
+        self.lbl_thr.setText(f"Int Thresh: {int(v)}")
+
+    def on_snr_changed(self, v):
+        val = float(v) / 10.0
+        self.lbl_snr.setText(f"SNR > {val:.1f}")
+        self.clear_layer_cache()
+        self.update_all_views()
+
+    def update_tool_mode(self):
+        # Determine mode
+        if self.rb_pick.isChecked(): self.tool_mode = "pick"
+        elif self.rb_brush.isChecked(): self.tool_mode = "brush"
+        elif self.rb_eraser.isChecked(): self.tool_mode = "eraser"
+        elif self.rb_inspect.isChecked(): self.tool_mode = "inspect"
+        
+        # Set canvas visual mode (inspect shares pick cursor logic, but handled differently in click)
+        if self.tool_mode in ["brush", "eraser"]:
+            self.canvas.mode = "draw"
+        else:
+            self.canvas.mode = "pick"
+
+    # ... [Peel/Edit logic kept same] ...
+    def on_auto_edit_toggled(self, checked):
+        if checked: self._sync_edit_with_peel()
+        self.update_all_views()
+    def on_peel_mode_changed(self, checked):
+        self.peel_by_class = bool(checked)
+        self.region_step = 0
+        self.clear_layer_cache()
+        self._region_cache_layer = None
+        self._region_cache_revision = -1
+        self._region_cache_mode = None
+        self._region_cache_regions = []
+        self._sync_region_slider()
+        self.update_all_views()
+    def _sync_edit_with_peel(self):
+        target = min(int(self.peel_depth), self.num_layers - 1)
+        if int(self.edit_layer) != target:
+            self.edit_layer = target
+            self.sl_edit.blockSignals(True)
+            self.sl_edit.setValue(self.edit_layer)
+            self.sl_edit.blockSignals(False)
+    def change_peel_depth(self, idx):
+        self.peel_depth = int(idx)
+        self.region_step = 0
+        if self.chk_auto_edit.isChecked(): self._sync_edit_with_peel()
+        self._sync_region_slider()
+        self.update_all_views()
+    def change_region_step(self, idx):
+        self.region_step = int(idx)
+        self.clear_layer_cache()
+        self.update_all_views()
+    def change_edit_layer(self, idx):
+        self.edit_layer = int(idx)
+        self.update_all_views()
+    def apply_peel_next(self):
+        self.peel_depth = min(self.num_layers, self.peel_depth + 1)
+        self.region_step = 0
+        self.sl_peel.blockSignals(True)
+        self.sl_peel.setValue(self.peel_depth)
+        self.sl_peel.blockSignals(False)
+        if self.chk_auto_edit.isChecked(): self._sync_edit_with_peel()
+        self._sync_region_slider()
+        self.update_all_views()
+    def apply_peel_prev(self):
+        self.peel_depth = max(0, self.peel_depth - 1)
+        self.region_step = 0
+        self.sl_peel.blockSignals(True)
+        self.sl_peel.setValue(self.peel_depth)
+        self.sl_peel.blockSignals(False)
+        if self.chk_auto_edit.isChecked(): self._sync_edit_with_peel()
+        self._sync_region_slider()
+        self.update_all_views()
+    def region_next(self):
+        maxv = self.sl_region.maximum()
+        self.region_step = min(maxv, self.region_step + 1)
+        self.sl_region.blockSignals(True)
+        self.sl_region.setValue(self.region_step)
+        self.sl_region.blockSignals(False)
+        self.clear_layer_cache()
+        self.update_all_views()
+    def region_prev(self):
+        self.region_step = max(0, self.region_step - 1)
+        self.sl_region.blockSignals(True)
+        self.sl_region.setValue(self.region_step)
+        self.sl_region.blockSignals(False)
+        self.clear_layer_cache()
+        self.update_all_views()
+    def edit_next(self):
+        self.edit_layer = min(self.num_layers - 1, self.edit_layer + 1)
+        self.sl_edit.blockSignals(True)
+        self.sl_edit.setValue(self.edit_layer)
+        self.sl_edit.blockSignals(False)
+        self.update_all_views()
+    def edit_prev(self):
+        self.edit_layer = max(0, self.edit_layer - 1)
+        self.sl_edit.blockSignals(True)
+        self.sl_edit.setValue(self.edit_layer)
+        self.sl_edit.blockSignals(False)
+        self.update_all_views()
+    def _get_peak_cmap_for_depth(self, peel_depth: int):
+        name, cmap = PEAK_CMAPS[int(peel_depth) % len(PEAK_CMAPS)]
+        return name, cmap
+
+    # ... [File list / Load Save ... same] ...
+    def update_file_list_ui(self):
+        self.file_list_widget.clear()
+        for f in self.file_list:
+            base = os.path.splitext(os.path.basename(f))[0]
+            is_lbl = os.path.exists(os.path.join(self.args.out_root, f"{base}_semantic.npy"))
+            item = QListWidgetItem(os.path.basename(f))
+            if is_lbl:
+                item.setForeground(QColor(0, 150, 0))
+                font = item.font()
+                font.setBold(True)
+                item.setFont(font)
+                item.setText(f"✔ {os.path.basename(f)}")
+            self.file_list_widget.addItem(item)
+        if 0 <= self.current_file_idx < len(self.file_list):
+            self.file_list_widget.setCurrentRow(self.current_file_idx)
+    def on_file_list_clicked(self, row):
+        if row < 0 or row >= len(self.file_list): return
+        if self.chk_autosave.isChecked() and self.is_dirty: self.save_current(silent=True)
+        self.current_file_idx = int(row)
+        self.load_file(self.file_list[self.current_file_idx])
+    def prev_file(self): self.on_file_list_clicked(max(0, self.current_file_idx - 1))
+    def next_file(self): self.on_file_list_clicked(min(len(self.file_list) - 1, self.current_file_idx + 1))
+
+    def load_file(self, path):
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        self.is_dirty = False
+        try:
+            self.undo_stack.clear()
+            self.current_file_path = path
+            self.setWindowTitle(f"SPAD Labeler - {os.path.basename(path)}")
+            self.raw_data = load_hist_npy(path)
+            if self.raw_data is None: return
+            self.noise_map = np.mean(self.raw_data, axis=1).reshape(self.H, self.W)
+            self.manual_masks = [np.zeros((self.H, self.W), dtype=np.uint8) for _ in range(self.num_layers)]
+            self.layer_thresholds = [None for _ in range(self.num_layers)]
+            self.layer_view_cache.clear()
+            base = os.path.splitext(os.path.basename(path))[0]
+            npy = os.path.join(self.args.out_root, f"{base}_semantic.npy")
+            if os.path.exists(npy):
+                try:
+                    d = np.load(npy)
+                    if d.ndim == 2 and d.shape[0] == self.H * self.W:
+                        self.manual_masks = sem_bins_to_layers(d.astype(np.uint8), self.H, self.W, self.num_layers)
+                        self.log_win.append("Loaded existing semantic.npy.")
+                except Exception: pass
+            self.peel_depth = 0
+            self.edit_layer = 0
+            self.region_step = 0
+            self.peel_by_class = bool(self.chk_peel_class.isChecked())
+            self.sl_peel.setValue(0)
+            self.sl_edit.setValue(0)
+            self._sync_region_slider()
+            self.update_all_views()
+            if self.hist_inspector and self.hist_inspector.isVisible():
+                self.hist_inspector.ax.clear()
+                self.hist_inspector.canvas.draw()
+        except Exception as e:
+            traceback.print_exc()
+        finally:
+            QApplication.restoreOverrideCursor()
+
+    def save_current(self, silent=False):
+        if not self.is_dirty and not silent: return
+        base = os.path.splitext(os.path.basename(self.current_file_path))[0]
+        out = os.path.join(self.args.out_root, f"{base}_semantic.npy")
+        ok, msg, _ = save_iterative_peeling_layers(out, self.raw_data, self.manual_masks, self.layer_thresholds, self.H, self.W, int(self.sl_thresh.value()))
+        if ok:
+            self.is_dirty = False
+            self.setWindowTitle(f"SPAD Labeler - {os.path.basename(self.current_file_path)}")
+            if not silent: self.log_win.append(msg)
+            self.update_file_list_ui()
+
+    def closeEvent(self, event):
+        if self.chk_autosave.isChecked() and self.is_dirty: self.save_current(silent=True)
+        if self.hist_inspector: self.hist_inspector.close()
+        event.accept()
+
+    # ... [Region calc/Peel calc/Display state... same] ...
+    def _get_current_peeled_layer(self):
+        if self.peel_depth <= 0: return None
+        return self.peel_depth - 1
+    def _compute_regions_for_layer(self, layer_idx: int, peel_by_class: bool):
+        mask2d = self.manual_masks[layer_idx]
+        regions = []
+        if peel_by_class:
+            flat = mask2d.reshape(-1)
+            for cid in sorted(self.class_names.keys()):
+                pix = np.flatnonzero(flat == cid)
+                if pix.size == 0: continue
+                regions.append({"cid": int(cid), "pixels": pix, "area": int(pix.size)})
+            regions.sort(key=lambda r: (r["cid"],))
+            return regions
+        for cid in sorted(self.class_names.keys()):
+            binary = (mask2d == cid).astype(np.uint8)
+            if binary.sum() == 0: continue
+            n, cc = cv2.connectedComponents(binary, connectivity=8)
+            for k in range(1, n):
+                pix = np.flatnonzero(cc.reshape(-1) == k)
+                if pix.size == 0: continue
+                regions.append({"cid": int(cid), "pixels": pix, "area": int(pix.size)})
+        regions.sort(key=lambda r: (r["cid"], -r["area"]))
+        return regions
+    def _get_regions_cached(self, layer_idx: int):
+        if layer_idx is None: return []
+        mode = bool(self.peel_by_class)
+        if (self._region_cache_layer == layer_idx and self._region_cache_revision == self.mask_revision and self._region_cache_mode == mode):
+            return self._region_cache_regions
+        regions = self._compute_regions_for_layer(layer_idx, peel_by_class=mode)
+        self._region_cache_layer = layer_idx
+        self._region_cache_revision = self.mask_revision
+        self._region_cache_mode = mode
+        self._region_cache_regions = regions
+        return regions
+    def _sync_region_slider(self):
+        L = self._get_current_peeled_layer()
+        if L is None:
+            self.sl_region.blockSignals(True)
+            self.sl_region.setRange(0, 0)
+            self.sl_region.setValue(0)
+            self.sl_region.blockSignals(False)
+            self.lbl_region.setText("Semantic Step: 0 / 0")
+            self.lbl_next_region.setText("Selected Peel Target: -")
+            return
+        regions = self._get_regions_cached(L)
+        n = len(regions)
+        self.region_step = max(0, min(self.region_step, n))
+        self.sl_region.blockSignals(True)
+        self.sl_region.setRange(0, n)
+        self.sl_region.setValue(self.region_step)
+        self.sl_region.blockSignals(False)
+        self.lbl_region.setText(f"Semantic Step (Layer {L}): {self.region_step} / {n}")
+        if n == 0: self.lbl_next_region.setText("Target: (no regions)")
+        elif self.region_step == 0: self.lbl_next_region.setText("Target: (none)")
+        else:
+            rid = min(max(0, self.region_step - 1), n - 1)
+            r = regions[rid]
+            cname = self.class_names.get(int(r["cid"]), f"Class {r['cid']}")
+            self.lbl_next_region.setText(f"Target: #{rid+1} | {cname} | area={r['area']}")
+
+    def _peel_pixels_peak_segment(self, working_data, pixel_indices, thr, peel_count=None):
+        if pixel_indices is None or pixel_indices.size == 0: return
+        for idx in pixel_indices:
+            hist = working_data[idx]
+            if np.max(hist) > thr:
+                p_idx = int(np.argmax(hist))
+                _, (l_rem, r_rem) = analyze_peak_structure(hist, p_idx, thr)
+                if r_rem > l_rem:
+                    working_data[idx, l_rem:r_rem + 1] = 0
+                    if peel_count is not None: peel_count[idx] += 1
+    def _build_working_hist_for_display(self, return_peel_count=False):
+        working = self.raw_data.copy()
+        curr_thr = int(self.sl_thresh.value())
+        peel_count = None
+        if return_peel_count: peel_count = np.zeros((self.H * self.W,), dtype=np.int16)
+        if self.peel_depth <= 0: return (working, peel_count) if return_peel_count else working
+        full_end = self.peel_depth - 1
+        for l in range(0, max(0, full_end)):
+            mask_flat = self.manual_masks[l].reshape(-1)
+            pix = np.flatnonzero(mask_flat > 0)
+            if pix.size == 0: continue
+            thr = self.layer_thresholds[l] if self.layer_thresholds[l] is not None else curr_thr
+            self._peel_pixels_peak_segment(working, pix, thr, peel_count=peel_count)
+        L = self.peel_depth - 1
+        thrL = self.layer_thresholds[L] if self.layer_thresholds[L] is not None else curr_thr
+        regions = self._get_regions_cached(L)
+        if len(regions) > 0 and self.region_step > 0:
+            rid = min(max(0, self.region_step - 1), len(regions) - 1)
+            self._peel_pixels_peak_segment(working, regions[rid]["pixels"], thrL, peel_count=peel_count)
+        return (working, peel_count) if return_peel_count else working
+    def get_display_state(self, return_peak_idx=False):
+        key_thr = int(self.sl_thresh.value())
+        lock_sig = tuple([(-1 if t is None else int(t)) for t in self.layer_thresholds[:max(0, self.peel_depth)]])
+        key = (int(self.peel_depth), int(self.region_step), int(self.peel_by_class), key_thr, lock_sig, int(self.mask_revision), int(return_peak_idx))
+        if key in self.layer_view_cache: return self.layer_view_cache[key]
+        working, peel_count = self._build_working_hist_for_display(return_peel_count=True)
+        raw2d = np.max(working, axis=1).reshape(self.H, self.W)
+        peel2d = peel_count.reshape(self.H, self.W)
+        if return_peak_idx:
+            peak_idx2d = np.argmax(working, axis=1).reshape(self.H, self.W)
+            self.layer_view_cache[key] = (raw2d, peel2d, peak_idx2d)
+            return raw2d, peel2d, peak_idx2d
+        self.layer_view_cache[key] = (raw2d, peel2d)
+        return raw2d, peel2d
+    def _get_valid_edit_mask(self, peel2d):
+        if not self.chk_lock_to_visible.isChecked(): return np.ones((self.H, self.W), dtype=bool)
+        return peel2d == int(self.edit_layer)
+    def _get_snr_mask(self, current_intensity):
+        if self.noise_map is None: return np.ones((self.H, self.W), dtype=bool)
+        snr_map = current_intensity / (self.noise_map + 1e-6)
+        return snr_map > (float(self.sl_snr.value()) / 10.0)
+
+    # ... [Combine layers/Split layers... same] ...
+    def _combine_layers(self, l_start, l_end_exclusive):
+        combined = np.zeros((self.H, self.W), dtype=np.uint8)
+        for l in range(max(0, int(l_start)), min(self.num_layers, int(l_end_exclusive))):
+            m = self.manual_masks[l]
+            combined[m > 0] = m[m > 0]
+        return combined
+    def _split_partial_layer_by_region_step(self, layer_idx):
+        peeled = np.zeros(self.H * self.W, dtype=np.uint8)
+        unpeeled = np.zeros(self.H * self.W, dtype=np.uint8)
+        if layer_idx is None: return peeled, unpeeled
+        regions = self._get_regions_cached(layer_idx)
+        if len(regions) == 0: return peeled, unpeeled
+        if self.region_step <= 0:
+            for r in regions: unpeeled[r["pixels"]] = np.uint8(r["cid"])
+            return peeled, unpeeled
+        sel = min(max(0, self.region_step - 1), len(regions) - 1)
+        for rid, r in enumerate(regions):
+            if rid == sel: peeled[r["pixels"]] = np.uint8(r["cid"])
+            else: unpeeled[r["pixels"]] = np.uint8(r["cid"])
+        return peeled, unpeeled
+
+    # ... [update_all_views ... same] ...
+    def update_all_views(self):
+        if self.raw_data is None: return
+        self._sync_region_slider()
+        L = self._get_current_peeled_layer()
+        raw, peel2d, peak_idx2d = self.get_display_state(return_peak_idx=True)
+        display_raw = raw.copy()
+        snr_mask = self._get_snr_mask(display_raw)
+        if self.chk_focus_edit.isChecked():
+            display_raw[~self._get_valid_edit_mask(peel2d)] = 0
+        display_raw[display_raw < int(self.sl_thresh.value())] = 0
+        display_raw[~snr_mask] = 0
+        norm = cv2.normalize(np.log1p(display_raw), None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+        cmap_name, cmap = self._get_peak_cmap_for_depth(self.peel_depth)
+        self.lbl_info.set_image(safe_numpy_to_pixmap(cv2.applyColorMap(norm, cmap)))
+        
+        depth_vis = peak_idx2d.astype(np.float32) * float(AppConfig.BIN_UNIT)
+        valid = display_raw > 0
+        depth_vis[~valid] = 0.0
+        if np.any(valid):
+            d = depth_vis[valid]
+            lo, hi = float(np.percentile(d, 2)), float(np.percentile(d, 98))
+            if hi <= lo: hi = lo + 1e-6
+            dn = np.clip((depth_vis - lo) / (hi - lo), 0.0, 1.0)
+            depth_col = cv2.applyColorMap((dn * 255.0).astype(np.uint8), _cv2_cmap("COLORMAP_TURBO", cv2.COLORMAP_JET))
+            depth_col[~valid] = 0
+        else: depth_col = np.zeros((self.H, self.W, 3), dtype=np.uint8)
+        self.lbl_depth.set_image(safe_numpy_to_pixmap(depth_col))
+
+        l0_raw = np.max(self.raw_data, axis=1).reshape(self.H, self.W)
+        n0 = cv2.normalize(np.log1p(l0_raw), None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+        self.lbl_global.set_image(safe_numpy_to_pixmap(cv2.applyColorMap(n0, _cv2_cmap("COLORMAP_MAGMA", cv2.COLORMAP_JET))))
+
+        unpeeled_mask = self._combine_layers(self.peel_depth, self.num_layers)
+        ghost_mask = self._combine_layers(0, max(0, self.peel_depth - 1)) if self.chk_ghost.isChecked() else None
+        pL, uL = self._split_partial_layer_by_region_step(L)
+        if L is not None: unpeeled_mask[uL.reshape(self.H, self.W) > 0] = uL.reshape(self.H, self.W)[uL.reshape(self.H, self.W) > 0]
+        if self.chk_ghost.isChecked() and L is not None and ghost_mask is not None:
+             ghost_mask[pL.reshape(self.H, self.W) > 0] = pL.reshape(self.H, self.W)[pL.reshape(self.H, self.W) > 0]
+
+        mask_rgba = np.zeros((self.H, self.W, 4), dtype=np.uint8)
+        ghost_rgba = np.zeros((self.H, self.W, 4), dtype=np.uint8) if ghost_mask is not None else None
+        if not self.chk_hide.isChecked():
+            for cid, rgb in self.class_colors_rgb.items():
+                if cid <= 0: continue
+                mask_rgba[unpeeled_mask == cid] = [rgb[0], rgb[1], rgb[2], 180]
+                if ghost_rgba is not None: ghost_rgba[ghost_mask == cid] = [rgb[0], rgb[1], rgb[2], 180]
+        self.canvas.hide_labels = self.chk_hide.isChecked()
+        self.canvas.set_content(safe_numpy_to_pixmap(depth_col), safe_numpy_to_pixmap(mask_rgba), safe_numpy_to_pixmap(ghost_rgba))
+        
+        res_rgb = np.zeros((self.H, self.W, 3), dtype=np.uint8)
+        for cid, rgb in self.class_colors_rgb.items():
+            if cid > 0: res_rgb[unpeeled_mask == cid] = rgb
+        self.lbl_result.set_image(safe_numpy_to_pixmap(res_rgb))
+
+    # ... [Assign/Erase... same] ...
+    def _assign_to_current_layer(self, region, cid, layer, overwrite=True):
+        if cid <= 0 or region is None or not np.any(region): return 0
+        m = self.manual_masks[int(layer)]
+        target = region if overwrite else (region & (m == 0))
+        if not np.count_nonzero(target): return 0
+        m[target] = np.uint8(cid)
+        self._ensure_layer_threshold(int(layer))
+        return np.count_nonzero(target)
+    def _erase_current_layer(self, region, layer):
+        if region is None or not np.any(region): return 0
+        m = self.manual_masks[int(layer)]
+        hit = region & (m > 0)
+        if not np.count_nonzero(hit): return 0
+        m[hit] = 0
+        return np.count_nonzero(hit)
+    def _erase_topmost_per_pixel(self, region): return self._erase_current_layer(region, self.edit_layer)
+    def _make_brush_region_circle(self, x, y, radius):
+        tmp = np.zeros((self.H, self.W), dtype=np.uint8)
+        cv2.circle(tmp, (x, y), int(radius), 1, -1)
+        return tmp > 0
+    def _make_brush_region_line(self, x1, y1, x2, y2, thickness):
+        tmp = np.zeros((self.H, self.W), dtype=np.uint8)
+        cv2.line(tmp, (x1, y1), (x2, y2), 1, int(thickness))
+        return tmp > 0
+
+    # ... [Magic Wand ... same] ...
+    def _compute_edge_barrier(self, raw_u8):
+        if not self.wand_edge_aware: return np.zeros_like(raw_u8, dtype=bool)
+        high = int(self.wand_edge_high)
+        return cv2.Canny(raw_u8, max(0, min(255, int(high * 0.5))), high).astype(bool)
+    def _magic_wand_grow(self, seed_x, seed_y, raw2d, valid_mask, thr):
+        if seed_x < 0 or seed_x >= self.W or seed_y < 0 or seed_y >= self.H: return np.zeros((self.H, self.W), dtype=bool)
+        if not valid_mask[seed_y, seed_x] or raw2d[seed_y, seed_x] <= thr: return np.zeros((self.H, self.W), dtype=bool)
+        raw_u8 = cv2.normalize(np.log1p(np.clip(raw2d, 0, None)), None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+        seed_I, tol, barrier = int(raw_u8[seed_y, seed_x]), int(self.wand_tolerance), self._compute_edge_barrier(raw_u8)
+        neigh = [(-1, -1), (0, -1), (1, -1), (-1,  0), (1,  0), (-1,  1), (0,  1), (1,  1)] if self.wand_connectivity_8 else [(0, -1), (-1, 0), (1, 0), (0, 1)]
+        visited, region = np.zeros((self.H, self.W), dtype=bool), np.zeros((self.H, self.W), dtype=bool)
+        dq = deque([(seed_x, seed_y)])
+        visited[seed_y, seed_x] = True
+        while dq:
+            x, y = dq.popleft()
+            if barrier[y, x] or not valid_mask[y, x] or raw2d[y, x] <= thr or abs(int(raw_u8[y, x]) - seed_I) > tol: continue
+            region[y, x] = True
+            for dx, dy in neigh:
+                nx, ny = x + dx, y + dy
+                if 0 <= nx < self.W and 0 <= ny < self.H and not visited[ny, nx]:
+                    visited[ny, nx] = True
+                    if not barrier[ny, nx] and valid_mask[ny, nx] and raw2d[ny, nx] > thr: dq.append((nx, ny))
+        return region
+
+    # ==========================================
+    # Canvas actions (Modified for Inspect Mode)
+    # ==========================================
+    def handle_canvas_action(self, action, p1, p2):
+        if self.raw_data is None or p1 is None: return
+        if action == "draw_end": return
+
+        x1, y1 = self._clamp_xy(p1.x(), p1.y())
+        x2, y2 = (x1, y1) if p2 is None else self._clamp_xy(p2.x(), p2.y())
+
+        # [NEW LOGIC] If in Inspect Mode, only update histogram and exit.
+        if self.tool_mode == "inspect":
+            if action in ["pick_end", "pick_end_ctrl"]:
+                # Only react to single clicks to avoid confusion with dragging
+                if (p1 - p2).manhattanLength() <= 5:
+                    self.update_histogram_inspector(x1, y1)
+            return  # <--- STOP HERE, do NOT proceed to labeling logic
+
+        # --- Labeling Logic Below (Pick/Brush/Eraser) ---
+        raw, peel2d, peak_idx2d = self.get_display_state(return_peak_idx=True)
+        curr_thresh = int(self.sl_thresh.value())
+        is_erase_action = (self.tool_mode == "eraser") or (action == "pick_end_ctrl")
+        valid_mask = np.ones((self.H, self.W), dtype=bool) if is_erase_action else self._get_valid_edit_mask(peel2d)
+        valid_mask = valid_mask & self._get_snr_mask(raw)
+
+        if action in ["draw_start", "pick_end", "pick_end_ctrl"]: self.push_undo()
+        changed = 0
+        allow_overwrite = self.chk_overwrite.isChecked()
+
+        if action == "draw_start":
+            region = self._make_brush_region_circle(x1, y1, self.brush_size)
+            if not is_erase_action: region = region & valid_mask
+            changed = self._erase_topmost_per_pixel(region) if self.tool_mode == "eraser" else self._assign_to_current_layer(region, int(self.current_class), int(self.edit_layer), allow_overwrite)
+        elif action == "draw_drag":
+            region = self._make_brush_region_line(x1, y1, x2, y2, self.brush_size * 2)
+            if not is_erase_action: region = region & valid_mask
+            changed = self._erase_topmost_per_pixel(region) if self.tool_mode == "eraser" else self._assign_to_current_layer(region, int(self.current_class), int(self.edit_layer), allow_overwrite)
+        elif action in ["pick_end", "pick_end_ctrl"]:
+            if (p1 - p2).manhattanLength() > 5:
+                xs, xe, ys, ye = sorted([x1, x2])[0], sorted([x1, x2])[1], sorted([y1, y2])[0], sorted([y1, y2])[1]
+                xe, ye = min(xe + 1, self.W), min(ye + 1, self.H)
+                region = np.zeros((self.H, self.W), dtype=bool)
+                roi = raw[ys:ye, xs:xe]
+                region[ys:ye, xs:xe] = (roi > curr_thresh) & valid_mask[ys:ye, xs:xe]
+            else:
+                region = self._magic_wand_grow(x1, y1, raw, valid_mask, curr_thresh)
+            
+            if not np.any(region):
+                if not is_erase_action and self.chk_lock_to_visible.isChecked():
+                    self.log_win.append("Pick ignored: invalid area.")
+            else:
+                ctrl_erase = (action == "pick_end_ctrl")
+                changed = self._erase_topmost_per_pixel(region) if (ctrl_erase or self.tool_mode == "eraser") else self._assign_to_current_layer(region, int(self.current_class), int(self.edit_layer), allow_overwrite)
+
+        if changed > 0:
+            self.set_dirty()
+            self.update_all_views()
+
+    # ... [Undo/Morph/Key events ... same] ...
+    def undo(self):
+        if not self.undo_stack: return
+        stack, thr, pd, rs, el, peel_mode = self.undo_stack.pop()
+        self.manual_masks = [stack[l].copy() for l in range(self.num_layers)]
+        self.layer_thresholds = list(thr)
+        self.peel_depth, self.region_step, self.edit_layer, self.peel_by_class = int(pd), int(rs), int(el), bool(peel_mode)
+        self.chk_peel_class.blockSignals(True)
+        self.chk_peel_class.setChecked(self.peel_by_class)
+        self.chk_peel_class.blockSignals(False)
+        self.sl_peel.blockSignals(True)
+        self.sl_peel.setValue(self.peel_depth)
+        self.sl_peel.blockSignals(False)
+        self.sl_edit.blockSignals(True)
+        self.sl_edit.setValue(self.edit_layer)
+        self.sl_edit.blockSignals(False)
+        self.clear_layer_cache()
+        self.is_dirty = True
+        self.mask_revision += 1
+        self._sync_region_slider()
+        self.update_all_views()
+        self.log_win.append("Undo.")
+        if self.hist_inspector and self.hist_inspector.isVisible():
+            self.hist_inspector.ax.clear()
+            self.hist_inspector.canvas.draw()
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key_Up: self.sl_thresh.setValue(self.sl_thresh.value() + (10 if event.modifiers() & Qt.ShiftModifier else 1))
+        elif event.key() == Qt.Key_Down: self.sl_thresh.setValue(max(0, self.sl_thresh.value() - (10 if event.modifiers() & Qt.ShiftModifier else 1)))
+        elif event.key() == Qt.Key_Control:
+            self.canvas.ctrl_pressed = True
+            self.canvas.update()
+        else: super().keyPressEvent(event)
+    def keyReleaseEvent(self, event):
+        if event.key() == Qt.Key_Control:
+            self.canvas.ctrl_pressed = False
+            self.canvas.update()
+        super().keyReleaseEvent(event)
+    def set_class_by_key(self, idx):
+        if int(idx) in self.cls_radios:
+            self.cls_radios[int(idx)].setChecked(True)
+            self.current_class = int(idx)
+    def cycle_class_prev(self): self.set_class_by_key(self.current_class - 1 if self.current_class > 1 else len(self.class_names))
+    def cycle_class_next(self): self.set_class_by_key(self.current_class + 1 if self.current_class < len(self.class_names) else 1)
+    def morph_current_mask(self, op):
+        mask = self.manual_masks[0]
+        if not np.any(mask): return
+        self.push_undo()
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+        for cid in self.class_names:
+            c_mask = (mask == cid).astype(np.uint8)
+            if not np.any(c_mask): continue
+            proc = cv2.dilate(c_mask, kernel) if op == "dilate" else cv2.erode(c_mask, kernel)
+            mask[proc > 0] = cid
+        self.set_dirty()
+        self.update_all_views()
+    def fill_unknown_current_layer(self):
+        if self.raw_data is None: return
+        layer = int(self.edit_layer)
+        raw2d, peel2d = self.get_display_state()
+        valid = self._get_valid_edit_mask(peel2d) & self._get_snr_mask(raw2d)
+        region = (raw2d > int(self.sl_thresh.value())) & valid
+        m = self.manual_masks[layer]
+        fill = region & (m == 0)
+        if not np.count_nonzero(fill): return
+        self.push_undo()
+        m[fill] = np.uint8(self.UNKNOWN_CID)
+        self._ensure_layer_threshold(layer)
+        self.set_dirty()
+        self.update_all_views()
+
+    # ==========================================
+    # 3D
+    # ==========================================
+    def visualize_3d_point_cloud(self):
+        if not HAS_OPEN3D or self.raw_data is None: return
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            raw, _ = self.get_display_state()
+            snr_mask = self._get_snr_mask(raw)
+            valid = (raw > int(self.sl_thresh.value())) & snr_mask
+            rows, cols = np.where(valid)
+            working_data = self._build_working_hist_for_display(return_peel_count=False)
+            zs = [int(np.argmax(working_data[r * self.W + c])) for r, c in zip(rows, cols)]
+            Z = np.array(zs, dtype=np.float32) * AppConfig.BIN_UNIT
+            u, v = cols.astype(float), rows.astype(float)
+            pts_uv = np.stack([u, v], axis=1).reshape(-1, 1, 2)
+            pts_undist = cv2.undistortPoints(pts_uv, AppConfig.CAM_K, AppConfig.CAM_D).reshape(-1, 2)
+            xyz = np.stack([pts_undist[:, 0] * Z, pts_undist[:, 1] * Z, Z], axis=1)
+            pcd = o3d.geometry.PointCloud()
+            pcd.points = o3d.utility.Vector3dVector(xyz)
+            pcd.colors = o3d.utility.Vector3dVector(get_robust_colors(raw[rows, cols]))
+            o3d.visualization.draw_geometries([pcd], window_name=f"3D Depth (PeelDepth {self.peel_depth})")
+        finally: QApplication.restoreOverrideCursor()
+
+    def visualize_3d_semantic_point_cloud(self):
+        if not HAS_OPEN3D or self.raw_data is None: return
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            curr_thr = int(self.sl_thresh.value())
+            working = self.raw_data.copy()
+            all_rows, all_cols, all_Z, all_cids = [], [], [], []
+            for l in range(self.num_layers):
+                m = self.manual_masks[l]
+                flat = m.reshape(-1)
+                labeled_idx = np.flatnonzero(flat > 0)
+                if labeled_idx.size == 0: continue
+                thr_l = self.layer_thresholds[l] if self.layer_thresholds[l] is not None else curr_thr
+                for idx in labeled_idx:
+                    cid = int(flat[idx])
+                    hist = working[idx]
+                    if np.max(hist) <= thr_l: continue
+                    peak_idx = int(np.argmax(hist))
+                    (__, ___), (l_rem, r_rem) = analyze_peak_structure(hist, peak_idx, thr_l)
+                    if r_rem <= l_rem: continue
+                    all_rows.append(int(idx // self.W))
+                    all_cols.append(int(idx % self.W))
+                    all_Z.append(float(peak_idx) * AppConfig.BIN_UNIT)
+                    all_cids.append(cid)
+                    working[idx, l_rem:r_rem + 1] = 0
+            if len(all_rows) == 0: return
+            rows, cols, Z, cids = np.asarray(all_rows), np.asarray(all_cols), np.asarray(all_Z), np.asarray(all_cids)
+            u, v = cols.astype(np.float32), rows.astype(np.float32)
+            pts_uv = np.stack([u, v], axis=1).reshape(-1, 1, 2)
+            pts_undist = cv2.undistortPoints(pts_uv, AppConfig.CAM_K, AppConfig.CAM_D).reshape(-1, 2)
+            xyz = np.stack([pts_undist[:, 0] * Z, pts_undist[:, 1] * Z, Z], axis=1)
+            colors = np.zeros((cids.size, 3), dtype=np.float32)
+            for i, cid in enumerate(cids):
+                rgb = self.class_colors_rgb.get(int(cid), (255, 255, 255))
+                colors[i] = [rgb[0]/255.0, rgb[1]/255.0, rgb[2]/255.0]
+            pcd = o3d.geometry.PointCloud()
+            pcd.points = o3d.utility.Vector3dVector(xyz)
+            pcd.colors = o3d.utility.Vector3dVector(colors)
+            o3d.visualization.draw_geometries([pcd], window_name="3D Semantic (Multi-layer)")
+        finally: QApplication.restoreOverrideCursor()
+
+    # [RESTORED METHOD]
+    def visualize_3d_semantic_bins_point_cloud(self):
+        if not HAS_OPEN3D or self.raw_data is None: return
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            thr_global = int(self.sl_thresh.value())
+            H, W = self.H, self.W
+            BIN_STRIDE = 1
+            PIX_STRIDE = 1
+            MAX_POINTS = 2_000_000
+            working = self.raw_data.copy()
+            all_xyz, all_rgb = [], []
+            total_pts = 0
+
+            for layer in range(self.num_layers):
+                m = self.manual_masks[layer]
+                flat = m.reshape(-1)
+                pix = np.flatnonzero(flat > 0)
+                if pix.size == 0: continue
+                if PIX_STRIDE > 1: pix = pix[::PIX_STRIDE]
+                thr = self.layer_thresholds[layer] if self.layer_thresholds[layer] is not None else thr_global
+                thr = int(thr)
+                rows, cols = (pix // W).astype(np.int32), (pix % W).astype(np.int32)
+                pts_uv = np.stack([cols.astype(np.float32), rows.astype(np.float32)], axis=1).reshape(-1, 1, 2)
+                pts_undist = cv2.undistortPoints(pts_uv, AppConfig.CAM_K, AppConfig.CAM_D).reshape(-1, 2)
+                xnd, ynd = pts_undist[:, 0], pts_undist[:, 1]
+                cids = flat[pix].astype(np.int32)
+
+                for i, idx in enumerate(pix):
+                    hist = working[idx]
+                    if hist.max() <= thr: continue
+                    p_idx = int(np.argmax(hist))
+                    (l_lab, r_lab), (l_rem, r_rem) = analyze_peak_structure(hist, p_idx, thr)
+                    if r_lab >= l_lab:
+                        bins = np.arange(l_lab, r_lab + 1, BIN_STRIDE, dtype=np.int32)
+                        if bins.size > 0:
+                            Z = bins.astype(np.float32) * float(AppConfig.BIN_UNIT)
+                            xyz = np.stack([xnd[i] * Z, ynd[i] * Z, Z], axis=1)
+                            cid = int(cids[i])
+                            rgb = self.class_colors_rgb.get(cid, (64, 64, 64))
+                            rgb_f = (np.array(rgb, dtype=np.float32) / 255.0).reshape(1, 3)
+                            rgb_arr = np.repeat(rgb_f, xyz.shape[0], axis=0)
+                            all_xyz.append(xyz)
+                            all_rgb.append(rgb_arr)
+                            total_pts += xyz.shape[0]
+                            if total_pts >= MAX_POINTS: break
+                    if r_rem > l_rem: working[idx, l_rem:r_rem + 1] = 0
+                if total_pts >= MAX_POINTS: break
+
+            if total_pts == 0:
+                self.log_win.append("3D Labeled Bins: no labeled bin segments to draw.")
+                return
+            xyz = np.concatenate(all_xyz, axis=0)
+            rgb = np.concatenate(all_rgb, axis=0)
+            pcd = o3d.geometry.PointCloud()
+            pcd.points = o3d.utility.Vector3dVector(xyz)
+            pcd.colors = o3d.utility.Vector3dVector(rgb)
+            o3d.visualization.draw_geometries([pcd], window_name="3D Labeled Bins (per-pixel labeled segments)")
+        finally: QApplication.restoreOverrideCursor()
+
+
+if __name__ == "__main__":
+    import multiprocessing as mp
+    mp.freeze_support()
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in_dir", default="npy")
+    ap.add_argument("--out_root", default="output")
+    ap.add_argument("--pattern", default="*.npy")
+    ap.add_argument("--cache_dir", default="cache")
+    args = ap.parse_args()
+
+    app = QApplication(sys.argv)
+    win = SPADLabelerPixel(args)
+    win.show()
+    sys.exit(app.exec_())

codes/pointcloud_extract/ann2pc.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""
+将标注文件 (semantic.npy) 转换为带语义标签的PLY点云真值
+基于 visualize_semantic_labels.py 的标注逻辑
+"""
+
+import os
+import glob
+import numpy as np
+import cv2
+import yaml
+from tqdm import tqdm
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import multiprocessing
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+def load_config(config_path=None):
+    if config_path is None:
+        config_path = os.path.join(SCRIPT_DIR, 'config.yaml')
+    with open(config_path, 'r', encoding='utf-8') as f:
+        return yaml.safe_load(f)
+
+CONFIG = load_config()
+
+# 相机和深度参数
+IMG_H, IMG_W = 192, 256
+BIN_TO_M = 299_792_458.0 * CONFIG['common']['dt_ps'] * 1e-12 / 2.0
+
+
+def save_ply_with_label(pts, path):
+    """保存带语义标签的PLY文件: x y z label"""
+    with open(path, "wb") as f:
+        header = f"ply\nformat ascii 1.0\nelement vertex {len(pts)}\n"
+        header += "property float x\nproperty float y\nproperty float z\nproperty int label\nend_header\n"
+        f.write(header.encode())
+        np.savetxt(f, pts, fmt='%.6f %.6f %.6f %d')
+
+
+def process_single_ann(args):
+    """处理单个标注文件，转换为PLY点云"""
+    npy_path, cam_config, out_dir = args
+    
+    # 从文件名提取基础名 (去掉 _semantic.npy)
+    basename = os.path.basename(npy_path)
+    if basename.endswith('_semantic.npy'):
+        basename = basename[:-13]  # 去掉 '_semantic.npy'
+    
+    out_path = os.path.join(out_dir, f"{basename}_gt.ply")
+    
+    try:
+        # 加载标注数据 (H*W, num_bins)
+        sem_bins = np.load(npy_path)
+        num_pos, num_bins = sem_bins.shape
+        
+        # 预计算相机参数
+        K = np.array([[cam_config['fx'], 0, cam_config['cx']], 
+                      [0, cam_config['fy'], cam_config['cy']], 
+                      [0, 0, 1]], dtype=np.float64)
+        D = np.array([cam_config['k1'], cam_config['k2'], cam_config['p1'], cam_config['p2']], dtype=np.float64)
+        
+        points = []
+        
+        # 遍历每个像素，提取标注的峰值
+        for idx in range(num_pos):
+            row = sem_bins[idx]
+            nz = np.flatnonzero(row > 0)  # 找到有标注的bin
+            if nz.size == 0:
+                continue
+            
+            # 找到连续的标注段
+            breaks = np.flatnonzero(np.diff(nz) != 1)
+            run_starts = np.concatenate(([0], breaks + 1))
+            run_ends = np.concatenate((breaks, [nz.size - 1]))
+            
+            for rs, re in zip(run_starts, run_ends):
+                b0 = int(nz[rs])
+                b1 = int(nz[re])
+                cid = int(row[b0])  # 语义类别
+                if cid <= 0:
+                    continue
+                
+                # 使用标注段的中心bin作为深度
+                peak_bin = (b0 + b1) // 2
+                depth = peak_bin * BIN_TO_M
+                
+                # 深度范围过滤
+                if depth < CONFIG['common']['min_range_m'] or depth > CONFIG['common']['max_range_m']:
+                    continue
+                
+                # 计算3D坐标
+                v, u = idx // IMG_W, idx % IMG_W
+                
+                if CONFIG['common']['undistort']:
+                    uv = np.array([[[u, v]]], dtype=np.float32)
+                    uv_norm = cv2.undistortPoints(uv, K, D)
+                    x_n, y_n = uv_norm[0, 0, 0], uv_norm[0, 0, 1]
+                else:
+                    x_n = (u - cam_config['cx']) / cam_config['fx']
+                    y_n = (v - cam_config['cy']) / cam_config['fy']
+                
+                if CONFIG['common']['depth_is_range']:
+                    ray = np.array([x_n, y_n, 1.0])
+                    ray_unit = ray / np.linalg.norm(ray)
+                    xyz = ray_unit * depth
+                else:
+                    xyz = np.array([x_n * depth, y_n * depth, depth])
+                
+                points.append([xyz[0], xyz[1], xyz[2], cid])
+        
+        if len(points) == 0:
+            return basename, False, 0
+        
+        pts = np.array(points, dtype=np.float32)
+        pts[:, 3] = pts[:, 3].astype(np.int32)  # 确保label是整数
+        save_ply_with_label(pts, out_path)
+        
+        return basename, True, len(pts)
+    
+    except Exception as e:
+        print(f"Error processing {npy_path}: {e}")
+        return basename, False, 0
+
+
+def main():
+    config = load_config()
+    datasets = config['datasets']
+    
+    ann_root = os.path.join(SCRIPT_DIR, 'ann')
+    output_root = os.path.join(SCRIPT_DIR, 'output_denoised', 'gt')
+    
+    num_workers = min(config['common'].get('num_workers', 8), multiprocessing.cpu_count())
+    
+    print(f"[INFO] Converting annotations to PLY ground truth")
+    print(f"[INFO] Ann root: {ann_root}")
+    print(f"[INFO] Output root: {output_root}")
+    print(f"[INFO] Workers: {num_workers}")
+    
+    # 遍历数据集 (p1, p2)
+    for dataset_name, cam_config in datasets.items():
+        dataset_ann_path = os.path.join(ann_root, dataset_name)
+        if not os.path.isdir(dataset_ann_path):
+            print(f"[Skip] {dataset_name} not found in ann/")
+            continue
+        
+        print(f"\n[Dataset] {dataset_name}")
+        
+        # 遍历序列目录
+        seq_dirs = [d for d in os.listdir(dataset_ann_path) 
+                    if os.path.isdir(os.path.join(dataset_ann_path, d))]
+        
+        for seq_name in seq_dirs:
+            seq_path = os.path.join(dataset_ann_path, seq_name)
+            out_dir = os.path.join(output_root, seq_name)
+            os.makedirs(out_dir, exist_ok=True)
+            
+            # 查找所有标注文件
+            npy_files = sorted(glob.glob(os.path.join(seq_path, "*_semantic.npy")))
+            if not npy_files:
+                continue
+            
+            # 准备任务
+            tasks = [(f, cam_config, out_dir) for f in npy_files]
+            
+            success_count = 0
+            total_pts = 0
+            
+            with ProcessPoolExecutor(max_workers=num_workers) as executor:
+                futures = [executor.submit(process_single_ann, t) for t in tasks]
+                
+                pbar = tqdm(as_completed(futures), total=len(npy_files), 
+                           desc=f"  {seq_name}", leave=False)
+                for future in pbar:
+                    basename, ok, pts_count = future.result()
+                    if ok:
+                        success_count += 1
+                        total_pts += pts_count
+            
+            print(f"  {seq_name}: {success_count}/{len(npy_files)} files, {total_pts:,} pts")
+    
+    print(f"\n[Done] Ground truth PLY saved to: {output_root}")
+
+
+if __name__ == "__main__":
+    main()

codes/pointcloud_extract/raw2pc.py

@@ -0,0 +1,533 @@
+import argparse
+import glob
+import os
+import re
+
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+C = 299_792_458.0  # m/s
+COMMON_SIZES = ((192, 256), (256, 192))
+TARGET_PIXELS = 192 * 256
+
+OUTPUT_COLUMNS = ["Timestamp", "X", "Y", "Z", "Reflectivity"]
+
+
+def _str2bool(value):
+    if isinstance(value, bool):
+        return value
+    text = str(value).strip().lower()
+    return text in {"1", "true", "yes", "y", "on"}
+
+
+def _extract_timestamp_from_name(path):
+    name = os.path.basename(path)
+    m = re.search(r"(\d+)(?=\.txt$)", name)
+    if m:
+        return int(m.group(1))
+
+    nums = re.findall(r"\d+", name)
+    if nums:
+        return int(nums[-1])
+    return -1
+
+
+def _infer_shape(num_pos):
+    for h, w in COMMON_SIZES:
+        if h * w == num_pos:
+            return h, w, num_pos
+
+    if num_pos >= TARGET_PIXELS:
+        return 192, 256, TARGET_PIXELS
+
+    h = int(np.sqrt(num_pos))
+    while h > 1 and num_pos % h != 0:
+        h -= 1
+    w = num_pos // h
+    return h, w, num_pos
+
+
+def _build_intrinsics(fx, fy, cx, cy, k1, k2, p1, p2):
+    K = np.array(
+        [
+            [fx, 0, cx],
+            [0, fy, cy],
+            [0, 0, 1],
+        ],
+        dtype=np.float64,
+    )
+    D = np.array([k1, k2, p1, p2], dtype=np.float64)
+    return K, D
+
+
+def _top2_counts_per_row(data):
+    top2 = np.partition(data, -2, axis=1)[:, -2:]
+    second = top2[:, 0].astype(np.float32)
+    peak = top2[:, 1].astype(np.float32)
+    return peak, second
+
+
+def _load_hist_intensity_depth(txt_path, dt_ps):
+    data = np.loadtxt(txt_path, dtype=np.int64)
+    if data.ndim == 1:
+        data = data.reshape(1, -1)
+
+    num_pos, _ = data.shape
+    intensity_1d, _ = _top2_counts_per_row(data)
+    peak_bin_1d = data.argmax(axis=1).astype(np.int32)
+
+    dt = dt_ps * 1e-12
+    bin_to_m = C * dt / 2.0
+    # depth_m_1d = peak_bin_1d.astype(np.float32) * bin_to_m
+    depth_m_1d = ( peak_bin_1d.astype(np.float32) - 17) * bin_to_m#25 18
+    
+    ###
+    offset = np.loadtxt("./offset.txt", dtype=float)
+    idx_offset = np.argwhere( offset < 10 )[:,0]
+    depth_m_1d[idx_offset] -= offset[idx_offset]
+
+    height, width, keep_n = _infer_shape(num_pos)
+    if keep_n < num_pos:
+        intensity_1d = intensity_1d[:keep_n]
+        depth_m_1d = depth_m_1d[:keep_n]
+
+    intensity = intensity_1d.reshape(height, width)
+    depth_m = depth_m_1d.reshape(height, width)
+    
+    return intensity, depth_m, height, width
+
+
+def _compute_points_undistort_points(
+    intensity,
+    depth_m,
+    K,
+    D,
+    depth_is_range,
+    min_range_m,
+    max_range_m,
+    intensity_min,
+    intensity_max,
+    undistort_intensity,
+):
+    if undistort_intensity:
+        intensity_u = cv2.undistort(intensity, K, D)
+    else:
+        intensity_u = intensity
+
+    depth_u = depth_m
+
+    h, w = depth_u.shape
+    u, v = np.meshgrid(np.arange(w), np.arange(h))
+
+    valid = (
+        np.isfinite(depth_u)
+        & (depth_u > float(min_range_m))
+        & (depth_u < float(max_range_m))
+        & (intensity_u >= float(intensity_min))
+    )
+    if intensity_max is not None:
+        valid &= intensity_u <= float(intensity_max)
+    
+    offset = np.loadtxt("offset.txt", dtype=float)
+    offset_m = offset.reshape(h, w)
+    valid_offset = offset_m < 10
+    valid = valid & valid_offset
+
+    u_valid = u[valid].astype(np.float32)
+    v_valid = v[valid].astype(np.float32)
+    d_valid = depth_u[valid].astype(np.float32)
+    i_valid = intensity_u[valid].astype(np.float32)
+
+    uv = np.stack([u_valid, v_valid], axis=1).reshape(-1, 1, 2).astype(np.float32)
+    xy = cv2.undistortPoints(uv, K, D)
+    x_n = xy[:, 0, 0]
+    y_n = xy[:, 0, 1]
+
+    ray = np.stack([x_n, y_n, np.ones_like(x_n)], axis=1)
+    ray_norm = np.linalg.norm(ray, axis=1, keepdims=True)
+    ray_unit = ray / np.maximum(ray_norm, 1e-12)
+
+    if depth_is_range:
+        pts = ray_unit * d_valid.reshape(-1, 1)
+    else:
+        pts = ray_unit * (d_valid.reshape(-1, 1) / np.maximum(ray_unit[:, 2:3], 1e-12))
+
+    reflectivity = np.rint(i_valid).astype(np.int32)
+    return pts.astype(np.float32), reflectivity, intensity_u, depth_u
+
+
+def _normalize_to_u8(values):
+    arr = values.astype(np.float32)
+    if arr.size == 0:
+        return np.array([], dtype=np.uint8)
+    lo = float(np.min(arr))
+    hi = float(np.max(arr))
+    if hi <= lo:
+        return np.zeros(arr.shape, dtype=np.uint8)
+    return ((arr - lo) * (255.0 / (hi - lo))).clip(0, 255).astype(np.uint8)
+
+
+def _write_ply_ascii(path, pts, reflectivity):
+    i_255 = _normalize_to_u8(reflectivity.astype(np.float32))
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("ply\n")
+        f.write("format ascii 1.0\n")
+        f.write(f"element vertex {pts.shape[0]}\n")
+        f.write("property float x\n")
+        f.write("property float y\n")
+        f.write("property float z\n")
+        f.write("property uchar red\n")
+        f.write("property uchar green\n")
+        f.write("property uchar blue\n")
+        f.write("end_header\n")
+        for idx in range(pts.shape[0]):
+            x, y, z = pts[idx]
+            ii = int(i_255[idx]) if idx < i_255.shape[0] else 0
+            f.write(f"{x} {y} {z} {ii} {ii} {ii}\n")
+
+
+def _save_maps_png(path, intensity_u, depth_u):
+    plt.figure(figsize=(12, 5))
+    plt.subplot(1, 2, 1)
+    plt.imshow(intensity_u, origin="upper")
+    plt.title("Intensity (max count)")
+    plt.colorbar()
+    plt.subplot(1, 2, 2)
+    plt.imshow(depth_u, origin="upper")
+    plt.title("Depth (m) from peak bin")
+    plt.colorbar()
+    plt.tight_layout()
+    plt.savefig(path, dpi=150)
+    plt.close()
+
+
+def _points_to_simple_csv(pts, reflectivity, timestamp):
+    n = pts.shape[0]
+    df = pd.DataFrame(
+        {
+            "Timestamp": np.full(n, int(timestamp), dtype=np.int64),
+            "X": pts[:, 0],
+            "Y": pts[:, 1],
+            "Z": pts[:, 2],
+            "Reflectivity": reflectivity.astype(np.int32),
+        },
+        columns=OUTPUT_COLUMNS,
+    )
+    return df
+
+
+def _maybe_visualize_open3d(pts, reflectivity, point_size=1.5):
+    try:
+        import open3d as o3d
+        import matplotlib.cm as cm
+    except Exception:
+        print("[warn] open3d/matplotlib colormap not available, skip visualization")
+        return
+
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(pts.astype(np.float64))
+
+    if reflectivity.size > 0:
+        refl = reflectivity.astype(np.float32)
+        refl_norm = (refl - refl.min()) / (refl.max() - refl.min() + 1e-12)
+        colors = cm.get_cmap("turbo")(refl_norm)[:, :3]
+        pcd.colors = o3d.utility.Vector3dVector(colors.astype(np.float64))
+
+    axis = o3d.geometry.TriangleMesh.create_coordinate_frame(size=0.2, origin=[0, 0, 0])
+
+    vis = o3d.visualization.Visualizer()
+    vis.create_window(window_name="SP Point Cloud (undistortPoints)", width=1200, height=800)
+    vis.add_geometry(pcd)
+    vis.add_geometry(axis)
+    opt = vis.get_render_option()
+    if opt is not None:
+        opt.point_size = float(point_size)
+        opt.background_color = np.array([0.02, 0.02, 0.02], dtype=np.float64)
+    vis.run()
+    vis.destroy_window()
+
+
+def convert_one_txt(
+    txt_path,
+    output_base,
+    dt_ps,
+    depth_is_range,
+    undistort_intensity,
+    K,
+    D,
+    min_range_m,
+    max_range_m,
+    intensity_min,
+    intensity_max,
+    output_mode,
+    save_maps,
+    show,
+    show_point_size=1.5,
+):
+    timestamp = _extract_timestamp_from_name(txt_path)
+    if timestamp < 0:
+        raise ValueError(f"No timestamp found in filename: {txt_path}")
+
+    intensity, depth_m, _, _ = _load_hist_intensity_depth(txt_path=txt_path, dt_ps=dt_ps)
+    pts, refl, intensity_u, depth_u = _compute_points_undistort_points(
+        intensity=intensity,
+        depth_m=depth_m,
+        K=K,
+        D=D,
+        depth_is_range=depth_is_range,
+        min_range_m=min_range_m,
+        max_range_m=max_range_m,
+        intensity_min=intensity_min,
+        intensity_max=intensity_max,
+        undistort_intensity=undistort_intensity,
+    )
+
+    csv_path = ""
+    ply_path = ""
+    map_path = ""
+
+    if output_mode in ("csv", "both"):
+        csv_path = output_base + ".csv"
+        _points_to_simple_csv(pts, refl, timestamp).to_csv(csv_path, index=False)
+
+    if output_mode in ("ply", "both"):
+        ply_path = output_base + ".ply"
+        _write_ply_ascii(ply_path, pts, refl)
+
+    if save_maps:
+        map_path = output_base + "_maps.png"
+        _save_maps_png(map_path, intensity_u, depth_u)
+
+    if show:
+        _maybe_visualize_open3d(pts, refl, point_size=show_point_size)
+
+    return {
+        "txt": txt_path,
+        "timestamp": timestamp,
+        "points": int(pts.shape[0]),
+        "csv": csv_path,
+        "ply": ply_path,
+        "maps": map_path,
+    }
+
+
+def batch_convert(
+    input_dir,
+    output_dir,
+    pattern,
+    prefix,
+    start_index,
+    dt_ps,
+    depth_is_range,
+    undistort_intensity,
+    K,
+    D,
+    min_range_m,
+    max_range_m,
+    intensity_min,
+    intensity_max,
+    output_mode,
+    save_maps,
+):
+    os.makedirs(output_dir, exist_ok=True)
+
+    txt_files = glob.glob(os.path.join(input_dir, pattern))
+    if not txt_files:
+        raise FileNotFoundError(f"No files matched: {os.path.join(input_dir, pattern)}")
+
+    txt_files.sort(key=lambda p: (_extract_timestamp_from_name(p), os.path.basename(p)))
+
+    results = []
+    out_idx = int(start_index)
+    for txt_path in txt_files:
+        out_base = os.path.join(output_dir, f"{prefix}{out_idx}")
+        info = convert_one_txt(
+            txt_path=txt_path,
+            output_base=out_base,
+            dt_ps=dt_ps,
+            depth_is_range=depth_is_range,
+            undistort_intensity=undistort_intensity,
+            K=K,
+            D=D,
+            min_range_m=min_range_m,
+            max_range_m=max_range_m,
+            intensity_min=intensity_min,
+            intensity_max=intensity_max,
+            output_mode=output_mode,
+            save_maps=save_maps,
+            show=False,
+        )
+        results.append(info)
+
+        outputs = []
+        if info["csv"]:
+            outputs.append(os.path.basename(info["csv"]))
+        if info["ply"]:
+            outputs.append(os.path.basename(info["ply"]))
+        if info["maps"]:
+            outputs.append(os.path.basename(info["maps"]))
+        out_text = ", ".join(outputs) if outputs else "<none>"
+
+        print(
+            f"[{out_idx}] {os.path.basename(txt_path)} -> {out_text}, "
+            f"ts={info['timestamp']}, points={info['points']}"
+        )
+        out_idx += 1
+
+    return results
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        description="Convert single-photon histogram txt to point cloud with cv2.undistortPoints."
+    )
+
+    parser.add_argument("--input-dir", type=str, default="./imaging")
+    parser.add_argument("--output-dir", type=str, default="./imaging")
+    parser.add_argument(
+        "--pattern",
+        type=str,
+        default="RawDataHistogramMap_frame_0_*.txt",
+        help="glob pattern under input-dir",
+    )
+    parser.add_argument("--prefix", type=str, default="")
+    parser.add_argument("--start-index", type=int, default=1)
+
+    parser.add_argument("--single-txt", type=str, default="", help="optional: convert one txt only")
+    parser.add_argument(
+        "--single-out-base",
+        type=str,
+        default="",
+        help="optional: output base path without extension for --single-txt",
+    )
+
+    parser.add_argument("--dt-ps", type=float, default=750.0)
+    parser.add_argument("--depth-is-range", type=_str2bool, default=True)
+    parser.add_argument("--undistort-intensity", type=_str2bool, default=True)
+
+    parser.add_argument("--fx", type=float, default=118.6514575329715)
+    parser.add_argument("--fy", type=float, default=118.7964934010577)
+    parser.add_argument("--cx", type=float, default=130.6802784645003)
+    parser.add_argument("--cy", type=float, default=100.3605702468140)
+
+    parser.add_argument("--k1", type=float, default=-0.257910069121181)
+    parser.add_argument("--k2", type=float, default=0.053237073644331)
+    parser.add_argument("--p1", type=float, default=0.0)
+    parser.add_argument("--p2", type=float, default=0.0)
+
+    parser.add_argument("--min-range-m", type=float, default=0.0)
+    parser.add_argument("--max-range-m", type=float, default=20.0)
+    parser.add_argument("--intensity-min", type=float, default=1.0)
+    parser.add_argument(
+        "--intensity-max",
+        type=float,
+        default=None,
+        help="optional max photon-count threshold",
+    )
+
+    parser.add_argument(
+        "--output-mode",
+        type=str,
+        choices=["ply", "csv", "both"],
+        default="csv",
+        help="export file mode",
+    )
+    parser.add_argument("--save-maps", type=_str2bool, default=True)
+    parser.add_argument("--show", type=_str2bool, default=False)
+    parser.add_argument("--show-point-size", type=float, default=1.5)
+
+    return parser
+
+
+def main():
+    args = build_parser().parse_args()
+
+    K, D = _build_intrinsics(
+        fx=args.fx,
+        fy=args.fy,
+        cx=args.cx,
+        cy=args.cy,
+        k1=args.k1,
+        k2=args.k2,
+        p1=args.p1,
+        p2=args.p2,
+    )
+
+    if args.single_txt:
+        if args.single_out_base:
+            out_base = args.single_out_base
+        else:
+            base = os.path.splitext(os.path.basename(args.single_txt))[0]
+            out_base = os.path.join(args.output_dir, base)
+
+        os.makedirs(os.path.dirname(out_base) or ".", exist_ok=True)
+        info = convert_one_txt(
+            txt_path=args.single_txt,
+            output_base=out_base,
+            dt_ps=args.dt_ps,
+            depth_is_range=args.depth_is_range,
+            undistort_intensity=args.undistort_intensity,
+            K=K,
+            D=D,
+            min_range_m=args.min_range_m,
+            max_range_m=args.max_range_m,
+            intensity_min=args.intensity_min,
+            intensity_max=args.intensity_max,
+            output_mode=args.output_mode,
+            save_maps=args.save_maps,
+            show=args.show,
+            show_point_size=args.show_point_size,
+        )
+        print(
+            f"done: {os.path.basename(info['txt'])}, points={info['points']}, "
+            f"csv={info['csv'] or '-'}, ply={info['ply'] or '-'}, maps={info['maps'] or '-'}"
+        )
+        return
+
+    results = batch_convert(
+        input_dir=args.input_dir,
+        output_dir=args.output_dir,
+        pattern=args.pattern,
+        prefix=args.prefix,
+        start_index=args.start_index,
+        dt_ps=args.dt_ps,
+        depth_is_range=args.depth_is_range,
+        undistort_intensity=args.undistort_intensity,
+        K=K,
+        D=D,
+        min_range_m=args.min_range_m,
+        max_range_m=args.max_range_m,
+        intensity_min=args.intensity_min,
+        intensity_max=args.intensity_max,
+        output_mode=args.output_mode,
+        save_maps=args.save_maps,
+    )
+    print(f"done: converted {len(results)} files")
+
+    if args.show and results:
+        target = results[0]["txt"]
+        out_base = os.path.join(args.output_dir, "_preview_first")
+        info = convert_one_txt(
+            txt_path=target,
+            output_base=out_base,
+            dt_ps=args.dt_ps,
+            depth_is_range=args.depth_is_range,
+            undistort_intensity=args.undistort_intensity,
+            K=K,
+            D=D,
+            min_range_m=args.min_range_m,
+            max_range_m=args.max_range_m,
+            intensity_min=args.intensity_min,
+            intensity_max=args.intensity_max,
+            output_mode="ply",
+            save_maps=False,
+            show=True,
+            show_point_size=args.show_point_size,
+        )
+        print(f"preview shown for: {os.path.basename(info['txt'])}")
+
+
+if __name__ == "__main__":
+    main()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

codes/reconstruction/transientnerf/eval.py

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

codes/reconstruction/transientnerf/loaders/README.md

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

codes/reconstruction/transientnerf/loaders/loader_captured.py

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

codes/reconstruction/transientnerf/loaders/loader_captured_ours.py

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

codes/reconstruction/transientnerf/loaders/loader_synthetic.py

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

codes/reconstruction/transientnerf/loaders/utils.py

@@ -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/transientnerf/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/transientnerf/misc/download_dataset.py

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

codes/reconstruction/transientnerf/misc/eval_utils.py

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

codes/reconstruction/transientnerf/misc/summary.py

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

codes/reconstruction/transientnerf/misc/transient_volrend.py

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

codes/reconstruction/transientnerf/radiance_fields/mlp.py

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

codes/reconstruction/transientnerf/radiance_fields/ngp.py

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

codes/reconstruction/transientnerf/train_ours.py

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

codes/reconstruction/transientnerf/utils.py

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

codes/simulator/generate_data_sim.py

@@ -0,0 +1,402 @@
+# 处理data文件夹数据生成仿真数据的脚本
+import include.simsp as simsp
+import numpy as np
+import cv2
+import argparse
+import os
+import torch
+from tqdm import tqdm
+import re
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+import time
+
+
+def get_matching_files(images_dir, depth_dir):
+    """
+    获取匹配的图像和深度文件对
+    
+    Args:
+        images_dir (str): 图像文件夹路径
+        depth_dir (str): 深度图文件夹路径
+    
+    Returns:
+        list: 匹配的文件对列表 [(image_path, depth_path, base_name), ...]
+    """
+    # 检查文件夹是否存在
+    if not os.path.exists(images_dir):
+        raise FileNotFoundError(f"图像文件夹不存在: {images_dir}")
+    if not os.path.exists(depth_dir):
+        raise FileNotFoundError(f"深度文件夹不存在: {depth_dir}")
+    
+    # 获取所有图像文件
+    image_files = []
+    for ext in ['*.jpg', '*.jpeg', '*.JPG', '*.JPEG']:
+        image_files.extend(Path(images_dir).glob(ext))
+    
+    # 获取所有深度文件
+    depth_files = []
+    for ext in ['*.png', '*.PNG']:
+        depth_files.extend(Path(depth_dir).glob(ext))
+    
+    # 创建文件名到路径的映射
+    image_dict = {}
+    depth_dict = {}
+    
+    for img_path in image_files:
+        # 提取基础文件名（不含扩展名）
+        base_name = img_path.stem
+        image_dict[base_name] = str(img_path)
+    
+    for depth_path in depth_files:
+        # 提取基础文件名（不含扩展名）
+        base_name = depth_path.stem
+        depth_dict[base_name] = str(depth_path)
+    
+    # 找到匹配的文件对
+    matched_pairs = []
+    for base_name in image_dict.keys():
+        if base_name in depth_dict:
+            matched_pairs.append((
+                image_dict[base_name],
+                depth_dict[base_name],
+                base_name
+            ))
+    
+    print(f"找到 {len(matched_pairs)} 对匹配的文件")
+    return matched_pairs
+
+
+def png_to_npy_depth(png_path, output_path=None):
+    """
+    将PNG深度图转换为numpy数组格式
+    
+    Args:
+        png_path (str): PNG深度图路径
+        output_path (str): 输出npy文件路径（可选）
+    
+    Returns:
+        np.ndarray: 深度数组
+    """
+    # 读取PNG深度图
+    depth_img = cv2.imread(png_path, cv2.IMREAD_UNCHANGED)
+    
+    if depth_img is None:
+        raise ValueError(f"无法读取深度图: {png_path}")
+    
+    # 如果是3通道图像，转换为单通道
+    if len(depth_img.shape) == 3:
+        depth_img = cv2.cvtColor(depth_img, cv2.COLOR_BGR2GRAY)
+    
+    # 转换为浮点数并归一化
+    depth_array = depth_img.astype(np.float64)
+    
+    # 根据深度图的编码方式进行处理
+    # 假设PNG深度图使用16位编码，需要转换为实际深度值（米）
+    # 这里可能需要根据具体的深度图编码方式调整
+    if depth_array.max() > 1.0:
+        # 如果最大值大于1，假设是16位编码，转换为0-1范围
+        depth_array = depth_array / 65535.0
+    
+    # 转换为实际深度值（假设最大深度为15米）
+    max_depth = 15.0
+    depth_array = depth_array * max_depth
+    
+    # 保存为npy文件（如果指定了输出路径）
+    if output_path:
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        np.save(output_path, depth_array)
+    
+    return depth_array
+
+
+def generate_sim_data_from_png(image_path, depth_png_path, SBR=0.2, meanSigDetect=4, save_path=None):
+    """
+    从PNG深度图和JPG图像生成仿真数据
+    
+    Args:
+        image_path (str): RGB图像文件路径
+        depth_png_path (str): PNG深度图文件路径
+        SBR (float): 信号背景比 (默认0.2)
+        meanSigDetect (int): 每像素平均信号光子数 (推荐值2/3/4)
+        save_path (str): 数据保存路径 (.npz文件)
+    
+    Returns:
+        tuple: (Z_true, depth_ssp, tBinMax, binDuration)
+    """
+    # 转换PNG深度图为numpy数组
+    Z_true = png_to_npy_depth(depth_png_path)
+    
+    # 读取并处理RGB图像
+    rgb_img = cv2.imread(image_path)
+    if rgb_img is None:
+        raise ValueError(f"无法读取图像: {image_path}")
+    
+    Alpha_true = cv2.cvtColor(rgb_img, cv2.COLOR_BGR2GRAY).astype(np.float64)
+    
+    # 确保两个图像尺寸一致
+    if Z_true.shape != Alpha_true.shape:
+        # 将Alpha_true调整为与Z_true相同的尺寸
+        Alpha_true = cv2.resize(Alpha_true, (Z_true.shape[1], Z_true.shape[0]), 
+                               interpolation=cv2.INTER_AREA)
+    
+    # 动态计算参数
+    zMax = int(np.max(Z_true) * 1.5) if np.max(Z_true) > 0 else 15
+    binDuration = zMax / 2e11
+    
+    # 计算目标尺寸（保持长宽比，缩放到64像素）
+    target_size = 64
+    height, width = Z_true.shape
+    scale = target_size / min(height, width)
+    new_width = int(width * scale)
+    new_height = int(height * scale)
+    
+    # 缩放图像
+    Z_true = cv2.resize(Z_true, (new_width, new_height), interpolation=cv2.INTER_AREA)
+    Alpha_true = cv2.resize(Alpha_true, (new_width, new_height), interpolation=cv2.INTER_AREA)
+    
+    # 生成仿真数据
+    tBinMax, sigDetect, spad = simsp.generate_simdata(
+        Z_true, Alpha_true, SBR, meanSigDetect, save_path, zMax, binDuration
+    )
+    
+    # 使用SSP算法进行深度估计
+    from include.singlephoton import SinglePhotonImaging
+    lr, lc = Z_true.shape
+    sp = SinglePhotonImaging(lr, lc, binDuration)
+    # depth_ssp = sp.ssp(spad)
+    
+    # 保存结果
+    if save_path:
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        dic_data = {
+            # "depth_ssp": depth_ssp,
+            "Alpha_true": Alpha_true,
+            "Z_true": Z_true,
+            "tBinMax": tBinMax,
+            "binDuration": binDuration,
+            "spad_data": spad.data,
+            "spad_indices": spad.indices,
+            "spad_indptr": spad.indptr,
+            "spad_shape": spad.shape,
+            "sigDetect_data": sigDetect,
+        }
+        np.savez_compressed(save_path, **dic_data)
+    
+    # return Z_true, depth_ssp, tBinMax, binDuration
+    return Z_true, Alpha_true, tBinMax, binDuration
+
+
+def process_single_file(args_tuple):
+    """
+    处理单个文件的线程安全函数
+    
+    Args:
+        args_tuple: (image_path, depth_path, base_name, output_dir, sbr, meanSigDetect, thread_id)
+    
+    Returns:
+        tuple: (success, base_name, error_msg)
+    """
+    image_path, depth_path, base_name, output_dir, sbr, meanSigDetect, thread_id = args_tuple
+    
+    try:
+        output_path = os.path.join(output_dir, f"{base_name}.npz")
+        
+        # 跳过已存在的文件
+        if os.path.exists(output_path):
+            return True, base_name, f"文件已存在，跳过: {base_name}"
+        
+        # 生成仿真数据
+        generate_sim_data_from_png(
+            image_path, depth_path, 
+            sbr, meanSigDetect, 
+            output_path
+        )
+        
+        return True, base_name, None
+        
+    except Exception as e:
+        # 清理GPU内存（如果使用了GPU）
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        return False, base_name, str(e)
+
+
+def process_files_multithread(matched_files, output_dir, sbr, meanSigDetect, max_workers=4):
+    """
+    多线程处理文件
+    
+    Args:
+        matched_files: 匹配的文件对列表
+        output_dir: 输出目录
+        sbr: 信噪比
+        meanSigDetect: 平均检测信号强度
+        max_workers: 最大线程数
+    
+    Returns:
+        tuple: (success_count, error_count, error_files)
+    """
+    success_count = 0
+    error_count = 0
+    error_files = []
+    
+    # 准备任务参数
+    tasks = []
+    for i, (image_path, depth_path, base_name) in enumerate(matched_files):
+        task_args = (image_path, depth_path, base_name, output_dir, sbr, meanSigDetect, i)
+        tasks.append(task_args)
+    
+    # 使用线程池执行任务
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # 提交所有任务
+        future_to_task = {executor.submit(process_single_file, task): task for task in tasks}
+        
+        # 使用tqdm显示进度
+        with tqdm(total=len(tasks), desc="多线程处理进度") as pbar:
+            for future in as_completed(future_to_task):
+                task = future_to_task[future]
+                try:
+                    success, base_name, error_msg = future.result()
+                    if success:
+                        success_count += 1
+                        if error_msg:  # 跳过的文件
+                            pbar.set_postfix_str(f"跳过: {base_name}")
+                    else:
+                        error_count += 1
+                        error_files.append((base_name, error_msg))
+                        pbar.set_postfix_str(f"错误: {base_name}")
+                        print(f"\n处理 {base_name} 时发生错误: {error_msg}")
+                        
+                except Exception as e:
+                    error_count += 1
+                    base_name = task[2]
+                    error_files.append((base_name, str(e)))
+                    pbar.set_postfix_str(f"异常: {base_name}")
+                    print(f"\n处理 {base_name} 时发生异常: {str(e)}")
+                
+                pbar.update(1)
+    
+    return success_count, error_count, error_files
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description='处理data文件夹生成仿真数据')
+    parser.add_argument('--sbr', type=float, default=0.5,
+                        help='信噪比 (默认: 0.5)')
+    parser.add_argument('--meanSigDetect', type=float, default=2,
+                        help='平均检测信号强度 (默认: 2)')
+    parser.add_argument('--data_dir', type=str, default='./data',
+                        help='数据文件夹路径 (默认: ./data)')
+    parser.add_argument('--output_dir', type=str, default='./output_data',
+                        help='输出文件夹路径 (默认: ./output_data)')
+    parser.add_argument('--max_files', type=int, default=None,
+                        help='最大处理文件数量 (默认: 处理所有文件)')
+    parser.add_argument('--threads', type=int, default=16,
+                        help='线程数量 (默认: 4)')
+    parser.add_argument('--single_thread', action='store_true',
+                        help='使用单线程模式 (默认: 使用多线程)')
+    
+    args = parser.parse_args()
+    
+    # 设置路径
+    images_dir = os.path.join(args.data_dir, 'images')
+    depth_dir = os.path.join(args.data_dir, 'depthpng')
+    output_dir = os.path.join(args.output_dir, f"{args.sbr}_{args.meanSigDetect}")
+    
+    print(f"图像目录: {images_dir}")
+    print(f"深度目录: {depth_dir}")
+    print(f"输出目录: {output_dir}")
+    
+    # 验证线程数设置
+    if args.threads < 1:
+        print("错误: 线程数必须大于0")
+        return
+    
+    # 显示处理模式
+    if args.single_thread:
+        print("使用单线程模式")
+        max_workers = 1
+    else:
+        max_workers = args.threads
+        print(f"使用多线程模式，线程数: {max_workers}")
+    
+    # 创建输出目录
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 获取匹配的文件对
+    try:
+        matched_files = get_matching_files(images_dir, depth_dir)
+    except FileNotFoundError as e:
+        print(f"错误: {e}")
+        return
+    
+    if not matched_files:
+        print("未找到匹配的文件对")
+        return
+    
+    # 限制处理文件数量
+    if args.max_files:
+        matched_files = matched_files[:args.max_files]
+        print(f"限制处理文件数量为: {args.max_files}")
+    
+    # 记录开始时间
+    start_time = time.time()
+    
+    # 选择处理模式
+    if args.single_thread or max_workers == 1:
+        # 单线程模式（原始逻辑）
+        success_count = 0
+        error_count = 0
+        error_files = []
+        
+        for image_path, depth_path, base_name in tqdm(matched_files, desc="单线程处理进度"):
+            output_path = os.path.join(output_dir, f"{base_name}.npz")
+            
+            # 跳过已存在的文件
+            if os.path.exists(output_path):
+                print(f"跳过已存在的文件: {base_name}")
+                continue
+            
+            try:
+                generate_sim_data_from_png(
+                    image_path, depth_path, 
+                    args.sbr, args.meanSigDetect, 
+                    output_path
+                )
+                success_count += 1
+                
+            except Exception as e:
+                print(f"处理 {base_name} 时发生错误: {str(e)}")
+                error_count += 1
+                error_files.append((base_name, str(e)))
+                torch.cuda.empty_cache()  # 清理GPU内存
+    else:
+        # 多线程模式
+        success_count, error_count, error_files = process_files_multithread(
+            matched_files, output_dir, args.sbr, args.meanSigDetect, max_workers
+        )
+    
+    # 计算处理时间
+    end_time = time.time()
+    total_time = end_time - start_time
+    
+    print(f"\n处理完成!")
+    print(f"成功处理: {success_count} 个文件")
+    print(f"处理失败: {error_count} 个文件")
+    print(f"总处理时间: {total_time:.2f} 秒")
+    print(f"平均每文件: {total_time/len(matched_files):.2f} 秒")
+    print(f"输出目录: {output_dir}")
+    
+    # 显示错误文件详情
+    if error_files:
+        print(f"\n错误文件详情:")
+        for base_name, error_msg in error_files[:10]:  # 只显示前10个错误
+            print(f"  {base_name}: {error_msg}")
+        if len(error_files) > 10:
+            print(f"  ... 还有 {len(error_files) - 10} 个错误文件")
+
+
+if __name__ == "__main__":
+    main()

codes/simulator/include/simsp.py

@@ -0,0 +1,324 @@
+import numpy as np
+import cv2
+import os
+from scipy.sparse import csc_matrix
+from include.singlephoton import SinglePhotonImaging
+
+
+# import os
+def fcn_PoissonRV(lambda_, ni=None, nj=None):
+    """
+    生成泊松分布随机数矩阵 (向量化实现)
+
+    参数:
+        lambda_ (float/array): 泊松分布参数λ（标量或二维数组）
+        ni (int): 输出矩阵的行数（当lambda为标量时必填）
+        nj (int): 输出矩阵的列数（当lambda为标量时必填）
+
+    返回:
+        np.ndarray: 生成的泊松随机数矩阵[ni, nj]
+
+    异常:
+        ValueError: 输入参数不符合要求时抛出
+    """
+    # ========================= 参数验证 =========================
+    # 情况1：未指定ni/nj时，lambda必须是二维数组
+    if ni is None and nj is None:
+        if not isinstance(lambda_, np.ndarray) or lambda_.ndim != 2:
+            raise ValueError("当未指定ni/nj时，lambda必须是二维数组!")
+        ni, nj = lambda_.shape
+
+    # 情况2：指定了ni/nj
+    elif ni is not None and nj is not None:
+        # 如果lambda是标量，扩展为指定大小的矩阵
+        if np.isscalar(lambda_):
+            lambda_ = np.full((ni, nj), lambda_)
+        # 如果lambda是数组，验证形状是否匹配
+        elif isinstance(lambda_, np.ndarray) and lambda_.shape != (ni, nj):
+            raise ValueError(f"lambda形状{lambda_.shape}与({ni},{nj})不匹配!")
+
+    # 情况3：参数不完整
+    else:
+        raise ValueError("必须同时指定ni和nj，或都不指定!")
+
+    # ========================= 初始化 =========================
+    ks1 = np.zeros((ni, nj), dtype=int)  # 结果矩阵
+    ks2 = np.ones((ni, nj), dtype=int)  # 比较矩阵
+    produ = np.ones((ni, nj))  # 乘积累加器
+
+    # ========================= 主循环 =========================
+    while np.any(ks1 != ks2):
+        # 更新乘积（向量化操作）
+        produ *= np.random.rand(ni, nj)
+
+        # 保存当前状态
+        ks2 = ks1.copy()
+
+        # 找出需要增加计数的位置（向量化掩码操作）
+        mask = produ >= np.exp(-lambda_)
+        ks1[mask] += 1
+
+    return ks1
+
+
+def tof2spad(tof, binnum):
+    h, w = tof.shape
+
+    # 将 data_processed 重塑为列向量
+    tof = tof.T
+    data = tof.reshape(h * w)
+
+    # 创建一个大小为 h * w 行，10000 列的零矩阵
+    spad = np.zeros((h * w, int(binnum)), dtype=float)
+
+    # 遍历 data
+    for i in range(h * w):
+        d = data[i]
+        for j in range(len(d)):
+            if int(d[j] - 1) < binnum:
+                spad[i, int(d[j] - 1)] += 1
+
+    spad = csc_matrix(spad)
+    return spad
+
+
+def generate_simdata(
+    Z_true,
+    Alpha_true,
+    SBR=0.2,
+    meanSigDetect=2,
+    save_path=None,
+    zMax=15,
+    binDuration=8e-12,
+):
+    """
+    生成单光子数据集仿真数据（Python版本）
+
+    参数:
+        Z_true (array): 深度真值
+        Alpha_true (array): 反射率真值
+        SBR (float): 信号背景比 (默认0.2)
+        meanSigDetect (int): 每像素平均信号光子数 (推荐值2/3/4)
+        save_path (str): 数据保存路径 (.mat文件)
+
+    返回:
+        tuple: (tBinMax, binDuration, sigDetect, totDetect)
+            tBinMax (int): 最大时间bin数
+            binDuration (float): 单个时间bin持续时间 (秒)
+            sigDetect (np.ndarray): 信号光子
+            totDetect (np.ndarray): 检测事件对象数组 [H,W] (每个元素包含时间bin序列)
+    """
+    # 第一阶段: 物理参数配置
+    # 场景参数
+    # zMax = 15.0  # 最大探测距离(米)
+    # binDuration = 8e-12  # 单个时间bin持续时间(秒)
+    pulseRMS = 270 / 8  # 脉冲RMS宽度(时间bin数)
+
+    # 计算衍生参数
+    ttd = 3e8 * binDuration / 2  # 时间到距离转换因子 (米/bin)
+    tBinMax = int(round(zMax / ttd))  # 最大时间bin数
+    pulseSTD = pulseRMS / 2  # 高斯脉冲标准差
+
+    # print("tBinMax:",tBinMax)
+
+    # 第二阶段: 信号光子生成
+    # 计算时间维度真实值
+    T_true = np.floor(Z_true / ttd).astype(int)
+
+    # 计算总帧数
+    numFrames = int(meanSigDetect * 500)
+
+    # 标准化反射率参数
+    Lr, Lc = Alpha_true.shape
+    Alpha_true = meanSigDetect * Alpha_true / np.mean(Alpha_true) / numFrames
+
+    # 生成信号光子数（泊松分布）
+    numSigDetect = fcn_PoissonRV(numFrames * Alpha_true)
+    actual_mean = np.mean(numSigDetect)
+    sigDetect = np.empty((Lr, Lc), dtype=object)
+    sampMean = np.zeros((Lr, Lc))
+
+    # 遍历每个像素生成时间分布
+    for i in range(Lr):
+        for j in range(Lc):
+            mu = T_true[i, j]
+            n = numSigDetect[i, j]
+            # 生成高斯分布时间偏移
+            tempVect = np.round(mu + pulseSTD * np.random.randn(n)).astype(int)
+            sampMean[i, j] = np.mean(tempVect) if n > 0 else 0
+            sigDetect[i, j] = tempVect
+
+    # 第三阶段: 背景噪声生成
+    # 计算背景光子率
+    bgndRate = actual_mean / numFrames / SBR
+
+    # 生成背景光子数
+    numBgndDetect = fcn_PoissonRV(numFrames * bgndRate, Lr, Lc)
+    bgndDetect = np.empty((Lr, Lc), dtype=object)
+
+    # 生成均匀分布时间
+    for i in range(Lr):
+        for j in range(Lc):
+            n = numBgndDetect[i, j]
+            bgndDetect[i, j] = np.random.randint(0, tBinMax, n)
+
+    # 第四阶段: 数据合并与后处理
+    totDetect = np.empty((Lr, Lc), dtype=object)
+    for i in range(Lr):
+        for j in range(Lc):
+            combined = np.concatenate((sigDetect[i, j], bgndDetect[i, j]))
+            combined = np.sort(combined)
+            combined = combined[combined > 0]  # 移除非法时间bin
+            totDetect[i, j] = combined
+
+    spad = tof2spad(totDetect, tBinMax)
+    sigDetect = tof2spad(sigDetect, tBinMax)
+
+    return tBinMax, sigDetect, spad
+
+# 补充泊松生成函数（原型实现）
+def fcn_PoissonRV(lamda, *shape):
+    if not shape:
+        return np.random.poisson(lamda)
+    else:
+        return np.random.poisson(lamda, shape)
+
+
+import cv2
+import numpy as np
+import os
+from scipy.io import savemat
+from pathlib import Path
+
+
+
+def generate_sim_imageNet(
+    depth_path, rgb_path, SBR=0.2, meanSigDetect=4, save_path=None
+):
+    """
+    生成cityscapes数据集仿真数据（Python版本）
+
+    参数:
+        depth_path (str): 深度图文件路径 (npz)
+        rgb_path (str): RGB图像文件路径
+        SBR (float): 信号背景比 (默认0.2)
+        meanSigDetect (int): 每像素平均信号光子数 (推荐值2/3/4)
+        save_path (str): 数据保存路径 (.npz文件)
+
+    返回:
+        tuple: (Z_true, totDetect, tBinMax, binDuration)
+            Z_true (np.ndarray): 真实深度图矩阵 [H,W] (单位:米)
+            totDetect (np.ndarray): 检测事件对象数组 [H,W] (每个元素包含时间bin序列)
+            tBinMax (int): 最大时间bin数
+            binDuration (float): 单个时间bin持续时间 (秒)
+
+    PS:
+        由于使用DepthAnything数据生成的深度图,是三通道的,所以在处理前需要先将其转换为单通道的
+        为了保证数据兼容性，所以统一提取第一个通道作为深度数据
+    """
+    # 第一阶段: 基础数据加载与参数初始化
+    # 读取深度图并转换为米单位
+    # 读取深度图的最大深度
+    
+    # binDuration = 4e-10
+    # zMax = 15
+    # binDuration = zMax/1.5e11
+
+    # 读取深度数据
+    Z_true = np.load(depth_path, allow_pickle=True).astype(np.float64)
+    if Z_true.ndim == 3:
+        Z_true = Z_true[:, :, 0]
+
+    # 1. 避免除零和过小值
+    threshold = 1e-10
+    Z_affine_safe = np.clip(Z_true, threshold, None)
+
+    # 2. 取倒数得到缩放深度
+    Z_scaled = 1 / Z_affine_safe
+    max_value = np.max(Z_scaled)
+    min_value = np.min(Z_scaled)
+
+    # # 3. 截断离群值（可选）
+    # lower, upper = np.percentile(Z_scaled, [1, 99])
+    # Z_clipped = np.clip(Z_scaled, lower, upper)
+
+    # 4. 归一化到[0,1]
+    Z_normalized = (Z_scaled - min_value) / (max_value - min_value)
+
+    # 5. 反转方向：近处亮，远处暗
+    Z_depth = (1 - Z_normalized)*max_value
+
+    # zMax = np.max(Z_true)
+    zMax = int(np.max(Z_true)*1.5)
+    binDuration = zMax / 2e11
+    
+    # 验证时间箱数量
+    ttd = 3e8 * binDuration / 2  # 时间到距离转换因子 (米/bin)
+    tBinMax = int(round(zMax / ttd))  # 最大时间bin数
+    print(f"tBinMax: {tBinMax}")
+
+    # 计算深度范围 (必须在缩放前获取原始深度最大值)
+    # zMax = int(np.max(Z_true) + 1)
+    # zMax = 15
+    # binDuration = 10e-11
+
+
+    # 计算目标尺寸（保持长宽比）
+    target_size = 64
+    height, width = Z_true.shape
+    scale = target_size / min(height, width)
+    new_width = int(width * scale)
+    new_height = int(height * scale)
+
+    # 缩放深度图（使用INTER_AREA保持精度）
+    Z_true = cv2.resize(
+        Z_true, 
+        (new_width, new_height),
+        interpolation=cv2.INTER_AREA
+    )
+
+    # 读取并处理RGB图像
+    rgb_img = cv2.imread(rgb_path)
+    Alpha_true = cv2.cvtColor(rgb_img, cv2.COLOR_BGR2GRAY).astype(np.float64)
+
+    # 以相同比例缩放灰度图
+    Alpha_true = cv2.resize(
+        Alpha_true,
+        (new_width, new_height),
+        interpolation=cv2.INTER_AREA
+    )
+
+    # # 输出最终尺寸信息
+    # print(f"深度图最终尺寸: {Z_true.shape}")
+    # print(f"反射率图最终尺寸: {Alpha_true.shape}")
+    #     # 动态计算zMax（忽略深度为0的无效点）
+    # valid_depths = Z_true[Z_true > 0]  # 筛选有效深度点（>0）
+    # if valid_depths.size > 0:
+    #     zMax = np.max(valid_depths) * 2  # 取最大值并增加10%余量
+    # else:
+    #     zMax = 15  # 默认值（无有效点时使用）
+
+    tBinMax, sigDetect, spad = generate_simdata(
+        Z_true, Alpha_true, SBR, meanSigDetect, save_path, zMax, binDuration
+    )
+
+    lr, lc = Z_true.shape
+
+    sp = SinglePhotonImaging(lr, lc, binDuration)
+    depth = sp.ssp(spad)
+
+    if save_path:
+        # 创建保存目录（如果不存在）
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        dic_data = {}
+        dic_data["depth_ssp"] = depth
+        dic_data["Z_true"] = Z_true
+        dic_data["tBinMax"] = tBinMax
+        dic_data["binDuration"] = binDuration
+        dic_data["spad_data"] = spad.data
+        dic_data["spad_indices"] = spad.indices
+        dic_data["spad_indptr"] = spad.indptr
+        dic_data["spad_shape"] = spad.shape
+        dic_data["sigDetect_data"] = sigDetect
+        # scipy.io.savemat(save_path, dic_data)
+        np.savez_compressed(save_path, **dic_data)

codes/simulator/include/singlephoton.py

@@ -0,0 +1,195 @@
+import numpy as np
+# import matlab.engine
+from .SSP.ssp import get_ssp_depth
+
+c = 3e8
+
+
+class SinglePhotonImaging:
+    def __init__(self, lr: int, lc: int, tp: float):
+        """
+        初始化深度估计器
+
+        参数:
+            lr: 图像行数
+            lc: 图像列数
+            tp: 时间bin持续时间 (秒)
+        """
+        self.lr = lr
+        self.lc = lc
+        self.tp = tp
+
+    def _spad2tof(self, spad: np.ndarray) -> np.ndarray:
+        """
+        将稀疏SPAD数据转换为时间飞行(TOF)对象数组 [内部方法]
+
+        参数:
+            spad: 稀疏SPAD数据矩阵 [N, M]
+
+        返回:
+            np.ndarray: TOF对象数组 [lr, lc]，每个元素为时间bin数组
+        """
+        rows, cols = spad.nonzero()
+        values = spad.data
+        tof = np.empty((self.lr, self.lc), dtype=np.ndarray)
+
+        for i in range(self.lr * self.lc):
+            indices = np.where(rows == i)[0]
+            ph = []
+            for j in indices:
+                ph += [int(cols[j])] * int(values[j])
+
+            ph = np.array([ph]).T
+
+            x = i % self.lc
+            y = i // self.lc
+
+            tof[x, y] = ph
+
+        return tof
+
+    def _time_to_depth(self, time_data: np.ndarray, time_bin: float) -> np.ndarray:
+        """统一时间到深度转换"""
+        return time_data * c / 2 * time_bin
+
+    def max_hist(self, spads: np.ndarray) -> np.ndarray:
+        """
+        通过滑动窗口均值法获取深度图
+
+        参数:
+            spads: 稀疏SPAD数据矩阵 [N, T]
+
+        返回:
+            np.ndarray: 深度图矩阵 [lc, lr] (单位:米)
+        """
+        print("Max Hist Processing...")
+
+        spads_dense = spads.todense()
+        max_histogram_mean = np.empty(self.lr * self.lc, dtype=float)
+
+        for i in range(self.lr * self.lc):
+            data = np.ascontiguousarray(spads_dense[i, :]).ravel()
+            max_index = np.argmax(data)
+            max_histogram_mean[i] = max_index
+
+        depth = self._time_to_depth(
+            max_histogram_mean.reshape(self.lr, self.lc).T, self.tp
+        )
+
+        return depth
+
+    # def shin(self, spads: np.ndarray) -> np.ndarray:
+    #     """
+    #     使用Shin算法估计深度图
+
+    #     参数:
+    #         spads: 稀疏SPAD数据矩阵 [N, T]
+
+    #     返回:
+    #         np.ndarray: 深度图矩阵 [lc, lr] (单位:米)
+    #     """
+    #     print("Shin Processing...")
+
+    #     tofs = self._spad2tof(spads)
+    #     eng = matlab.engine.start_matlab()
+    #     eng.addpath(r"matlab\fcns_Shin")
+    #     matlab_tofs = eng.eval("cell(1, 3136)", nargout=1)
+    #     matlab_tofs = [tof for row in tofs for tof in row]
+
+    #     tof_shin = np.array(eng.cal_Shin(matlab_tofs))
+    #     eng.quit()
+
+    #     depth = self._time_to_depth(tof_shin, self.tp)
+    #     return depth
+
+    # def rapp(
+    #     self, spads: np.ndarray, signal_per_pixel: float, frame_num: int
+    # ) -> np.ndarray:
+    #     """
+    #     使用Rapp算法估计深度图
+
+    #     参数:
+    #         spads: 稀疏SPAD数据矩阵 [N, T]
+    #         signal_per_pixel: 每像素平均信号光子数
+    #         frame_num: 总帧数
+
+    #     返回:
+    #         np.ndarray: 深度图矩阵 [lc, lr] (单位:米)
+    #     """
+    #     print("Rapp Processing...")
+
+    #     binnum = spads.shape[1]
+    #     tofs = self._spad2tof(spads)
+
+    #     sbr = 0.2
+    #     perframenum = 50.0
+    #     numFrames = perframenum * frame_num
+    #     eng = matlab.engine.start_matlab()
+    #     eng.addpath(r"matlab\fcns_Rapp")
+
+    #     matlab_tofs = eng.eval("cell(1, 3136)", nargout=1)
+    #     matlab_tofs = [tof for row in tofs for tof in row]
+
+    #     tof_rapp = np.array(
+    #         eng.cal_Rapp_py(
+    #             matlab_tofs,
+    #             signal_per_pixel,
+    #             numFrames,
+    #             sbr,
+    #             float(self.tp),
+    #             float(binnum),
+    #         )
+    #     )
+
+    #     eng.quit()
+
+    #     depth = self._time_to_depth(tof_rapp, self.tp)
+
+    #     return depth
+
+    # def li(self, spads: np.ndarray) -> np.ndarray:
+    #     """
+    #     使用Li算法估计深度图
+
+    #     参数:
+    #         spads: 稀疏SPAD数据矩阵 [N, T]
+
+    #     返回:
+    #         np.ndarray: 深度图矩阵 [lc, lr] (单位:米)
+    #     """
+    #     print("Li Processing...")
+    #     eng = matlab.engine.start_matlab()
+    #     eng.addpath(r"matlab\fcns_Li", nargout=0)
+
+    #     # 直接使用原始SPAD数据
+    #     spads = spads.todense()
+    #     tof_li = np.array(
+    #         eng.cal_Li_py(
+    #             spads,
+    #             float(self.tp),
+    #             float(spads.shape[1]),
+    #             nargout=1,
+    #         )
+    #     )
+    #     eng.quit()
+
+    #     depth = self._time_to_depth(tof_li, self.tp)
+
+    #     return depth
+
+    def ssp(self, spads: np.ndarray) -> np.ndarray:
+        """
+        使用SSP算法估计深度图
+
+        参数:
+            spads: 稀疏SPAD数据矩阵 [N, T]
+
+        返回:
+            np.ndarray: 深度图矩阵 [lc, lr] (单位:米)
+        """
+        # print("SSP Processing...")
+        tp = self.tp
+        tr = spads.shape[1]
+        depth = get_ssp_depth(spads, tr, tp, self.lr, self.lc)
+
+        return depth