diffct 2.0.2__tar.gz → 2.1.0__tar.gz

{diffct-2.0.2 → diffct-2.1.0}/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [2.1.0] - 2026-10-10
+
+### Added
+
+- `Projector(..., detector_surface=surface)` samples local parameterized surfaces
+  into per-pixel world positions for native parallel, fan and cone projection
+  and matched backprojection. Shared or per-view surfaces can contain trainable
+  PyTorch parameters. Flat detectors remain the default; analytical helpers
+  retain their flat-detector assumptions.
+- CUDA regression tests and CPU formal verification for detector
+  surfaces, including bounded production-kernel checks against cell intersections.
+- Automatic CPU-backed spatial tiles and view batches for native `Projector`
+  projection, matched backprojection, data autograd/Hessians and first-order
+  geometry gradients. CUDA inputs retain the full-volume path when its estimated
+  working set fits. Optional `volume_chunk_shape` and `view_chunk_size` override
+  automatic limits; full CPU arrays are not staged on CUDA. Several local
+  devices compute their view batches concurrently.
+- A CPU-backed CGLS example and chunk-boundary, CUDA memory and
+  formal partition/translation/adjoint checks.
+
+### Fixed
+
+- The exit-time cleanup hook returns early under the CUDA simulator
+  (``NUMBA_ENABLE_CUDASIM=1``). Before, each simulator process printed an
+  ``ImportError`` for ``_PendingDeallocs`` at exit. The simulator loads no
+  CUDA modules, so it needs no cleanup.
+
 ## [2.0.2] - 2026-10-09
 
 ### Fixed

{diffct-2.0.2 → diffct-2.1.0}/CITATION.cff

@@ -13,8 +13,8 @@ authors:
     given-names: Yipeng
     email: yipeng.sun@fau.de
     alias: sypsyp97
-version: 2.0.2
-date-released: "2026-10-09"
+version: 2.1.0
+date-released: "2026-10-10"
 license: Apache-2.0
 repository-code: "https://github.com/sypsyp97/diffct"
 url: "https://sypsyp97.github.io/diffct/"

{diffct-2.0.2 → diffct-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: diffct
-Version: 2.0.2
+Version: 2.1.0
 Summary: Differentiable CUDA projectors for CT: arbitrary trajectories, multi-GPU and multi-node execution, geometry gradients
 Project-URL: Homepage, https://github.com/sypsyp97/diffct
 Project-URL: Documentation, https://sypsyp97.github.io/diffct/
@@ -47,11 +47,11 @@ Description-Content-Type: text/markdown
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/diffct_intro.gif" width="100%" alt="diffct intro: projection, sinogram, trajectories, multi-GPU split, reconstruction and geometry calibration">
+  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/edf7c52227ec2cc14c988918faa7313f8ee0fe03/docs/assets/diffct_intro.gif" width="100%" alt="diffct intro: projection, sinogram, trajectories, multi-GPU split, reconstruction and geometry calibration">
 </p>
 
 <p align="center">
-  <a href="https://github.com/sypsyp97/diffct/blob/main/docs/assets/diffct_intro.mp4">Intro video (MP4)</a> ·
+  <a href="https://github.com/sypsyp97/diffct/blob/edf7c52227ec2cc14c988918faa7313f8ee0fe03/docs/assets/diffct_intro.mp4">Intro video (MP4)</a> ·
   <a href="https://www.preprints.org/manuscript/202605.1446/v1">Technical report</a> ·
   <a href="https://doi.org/10.20944/preprints202605.1446.v1">DOI</a>
 </p>
@@ -75,8 +75,10 @@ Description-Content-Type: text/markdown
 To our knowledge, diffct is the only open-source GPU CT library that combines arbitrary per-view trajectories, autograd through the volume, first-order gradients through the acquisition geometry, and built-in multi-GPU and multi-node execution. We compared it with LEAP, TIGRE, ASTRA/tomosipo, DiffDRR and others in October 2026.
 
 - **Arbitrary trajectories.** Each view has its own source, detector centre and detector axes. Circular, helical, saddle, sinusoidal, random and calibrated scans use the same code. Trajectory tensors with `requires_grad=True` receive geometry gradients for calibration.
+- **Curved detectors.** A `detector_surface(u, v)` callback defines each pixel's position for arc, cylindrical or other parameterized surfaces. Projection and matched backprojection support first-order surface gradients. See [the surface API](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#parameterized-detector-surfaces).
 - **Matched operators.** `project()` and `backproject()` form an exact adjoint pair for the cell-constant Siddon model. Both support PyTorch autograd, with volume/sinogram gradients and Hessian-vector products.
-- **Multi-GPU and multi-node.** Use `devices=[0, 1, 2, 3]` in one process, or one process per GPU with torchrun and NCCL. Views are partitioned and the volume is replicated. Speedup depends on workload and communication costs.
+- **Large volumes.** CPU volumes and sinograms automatically stream spatial tiles and view batches through CUDA. Full arrays and data gradients stay on CPU; tile sizes follow the available device memory and can be overridden. See [chunked execution](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#chunked-execution).
+- **Multi-GPU and multi-node.** Use `devices=[0, 1, 2, 3]` in one process, or one process per GPU with torchrun and NCCL. Views are partitioned. CPU-backed volumes stay in host RAM while GPUs compute tiles; distributed ranks retain replicated-volume semantics. Speedup depends on workload and communication costs.
 - **Analytical helpers.** `diffct.analytical` provides ramp filters (ram-lak, shepp-logan, cosine, hamming, hann), fan, cone and Parker weights, and FBP and FDK backprojection.
 
 Capabilities, limits and isocenter rules: [docs/REFERENCE.md](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#capabilities-and-limits).
@@ -144,6 +146,23 @@ loss.backward()                     # x.grad = A^T (A x - y)
 A = Projector(trajectory, (128, 128, 128), (384, 256), detector_spacing=0.8, devices=[0, 1, 2, 3])
 ```
 
+**Volumes larger than GPU memory.** Keep the arrays on CPU. The same calls use
+CUDA tiles automatically; CUDA inputs retain the full-volume path when its
+estimated working set fits. Explicit limits are optional:
+
+```python
+A = Projector(trajectory, (128, 128, 128), (384, 256), detector_spacing=0.8)
+volume = torch.ones(A.volume_shape, device="cpu", requires_grad=True)
+sinogram = A.project(volume)                 # CPU output, CUDA computation
+sinogram.square().mean().backward()          # CPU volume.grad
+# Optional: volume_chunk_shape=(32, 64, 64), view_chunk_size=16
+```
+
+Run `python examples/chunked_reconstruction.py` for CPU-backed CGLS and measured
+CUDA allocation. Chunking preserves the Siddon model, with float32 summation
+differences; smaller blocks can increase transfer and launch overhead. Full
+arrays and iterative state still need enough host RAM.
+
 ## Performance
 
 <p align="center">
@@ -169,10 +188,12 @@ python examples/benchmark_projector.py --devices 0 1
 
 ## Gallery
 
+TV denotes TV-regularized iterative reconstruction; Adam is the optimizer. Figure labels distinguish the method from its optimizer.
+
 **Measured walnut.** 240 measured views, circular cone beam, 256³: FDK (Hann window), SIRT (200 iterations), CGLS (20), TV (300, weight 0.3); axial and coronal centre slices.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_measured.png" width="100%" alt="Measured walnut: FDK, SIRT, CGLS and TV reconstructions">
+  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_measured.png?v=e0092c4" width="100%" alt="Measured walnut: FDK, SIRT, CGLS and TV reconstructions">
 </p>
 
 ```bash
@@ -182,7 +203,7 @@ python examples/walnut_reconstruction.py --figure out.png
 **Simulated helical scan of the walnut.** The FDK walnut volume as ground truth, 720 views, 1% noise, 256³. PSNR: FDK 26.67 dB, CGLS (30 iterations) 34.13 dB, SIRT (200) 34.52 dB, TV (200, weight 1.0) 37.77 dB.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_helical.png" width="100%" alt="Simulated helical scan of the walnut: FDK, CGLS, SIRT and TV reconstructions">
+  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_helical.png?v=e0092c4" width="100%" alt="Simulated helical scan of the walnut: FDK, CGLS, SIRT and TV reconstructions">
 </p>
 
 ```bash
@@ -194,7 +215,7 @@ Walnut data: Meaney 2022, Zenodo 6986012, CC BY 4.0; see [examples/data/NOTICE](
 
 ## Examples
 
-`quickstart.py`, `analytical_reconstruction.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `plot_trajectory.py`, and the Slurm template `slurm/multi_node.sbatch`. Launch modes and distributed-loss rules are in [examples/README.md](https://github.com/sypsyp97/diffct/blob/main/examples/README.md).
+`quickstart.py`, `curved_detector.py`, `chunked_reconstruction.py`, `analytical_reconstruction.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `plot_trajectory.py`, and the Slurm template `slurm/multi_node.sbatch`. Launch modes and distributed-loss rules are in [examples/README.md](https://github.com/sypsyp97/diffct/blob/main/examples/README.md).
 
 ## Documentation
 

{diffct-2.0.2 → diffct-2.1.0}/README.md

@@ -16,11 +16,11 @@
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/diffct_intro.gif" width="100%" alt="diffct intro: projection, sinogram, trajectories, multi-GPU split, reconstruction and geometry calibration">
+  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/edf7c52227ec2cc14c988918faa7313f8ee0fe03/docs/assets/diffct_intro.gif" width="100%" alt="diffct intro: projection, sinogram, trajectories, multi-GPU split, reconstruction and geometry calibration">
 </p>
 
 <p align="center">
-  <a href="https://github.com/sypsyp97/diffct/blob/main/docs/assets/diffct_intro.mp4">Intro video (MP4)</a> ·
+  <a href="https://github.com/sypsyp97/diffct/blob/edf7c52227ec2cc14c988918faa7313f8ee0fe03/docs/assets/diffct_intro.mp4">Intro video (MP4)</a> ·
   <a href="https://www.preprints.org/manuscript/202605.1446/v1">Technical report</a> ·
   <a href="https://doi.org/10.20944/preprints202605.1446.v1">DOI</a>
 </p>
@@ -44,8 +44,10 @@
 To our knowledge, diffct is the only open-source GPU CT library that combines arbitrary per-view trajectories, autograd through the volume, first-order gradients through the acquisition geometry, and built-in multi-GPU and multi-node execution. We compared it with LEAP, TIGRE, ASTRA/tomosipo, DiffDRR and others in October 2026.
 
 - **Arbitrary trajectories.** Each view has its own source, detector centre and detector axes. Circular, helical, saddle, sinusoidal, random and calibrated scans use the same code. Trajectory tensors with `requires_grad=True` receive geometry gradients for calibration.
+- **Curved detectors.** A `detector_surface(u, v)` callback defines each pixel's position for arc, cylindrical or other parameterized surfaces. Projection and matched backprojection support first-order surface gradients. See [the surface API](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#parameterized-detector-surfaces).
 - **Matched operators.** `project()` and `backproject()` form an exact adjoint pair for the cell-constant Siddon model. Both support PyTorch autograd, with volume/sinogram gradients and Hessian-vector products.
-- **Multi-GPU and multi-node.** Use `devices=[0, 1, 2, 3]` in one process, or one process per GPU with torchrun and NCCL. Views are partitioned and the volume is replicated. Speedup depends on workload and communication costs.
+- **Large volumes.** CPU volumes and sinograms automatically stream spatial tiles and view batches through CUDA. Full arrays and data gradients stay on CPU; tile sizes follow the available device memory and can be overridden. See [chunked execution](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#chunked-execution).
+- **Multi-GPU and multi-node.** Use `devices=[0, 1, 2, 3]` in one process, or one process per GPU with torchrun and NCCL. Views are partitioned. CPU-backed volumes stay in host RAM while GPUs compute tiles; distributed ranks retain replicated-volume semantics. Speedup depends on workload and communication costs.
 - **Analytical helpers.** `diffct.analytical` provides ramp filters (ram-lak, shepp-logan, cosine, hamming, hann), fan, cone and Parker weights, and FBP and FDK backprojection.
 
 Capabilities, limits and isocenter rules: [docs/REFERENCE.md](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#capabilities-and-limits).
@@ -113,6 +115,23 @@ loss.backward()                     # x.grad = A^T (A x - y)
 A = Projector(trajectory, (128, 128, 128), (384, 256), detector_spacing=0.8, devices=[0, 1, 2, 3])
 ```
 
+**Volumes larger than GPU memory.** Keep the arrays on CPU. The same calls use
+CUDA tiles automatically; CUDA inputs retain the full-volume path when its
+estimated working set fits. Explicit limits are optional:
+
+```python
+A = Projector(trajectory, (128, 128, 128), (384, 256), detector_spacing=0.8)
+volume = torch.ones(A.volume_shape, device="cpu", requires_grad=True)
+sinogram = A.project(volume)                 # CPU output, CUDA computation
+sinogram.square().mean().backward()          # CPU volume.grad
+# Optional: volume_chunk_shape=(32, 64, 64), view_chunk_size=16
+```
+
+Run `python examples/chunked_reconstruction.py` for CPU-backed CGLS and measured
+CUDA allocation. Chunking preserves the Siddon model, with float32 summation
+differences; smaller blocks can increase transfer and launch overhead. Full
+arrays and iterative state still need enough host RAM.
+
 ## Performance
 
 <p align="center">
@@ -138,10 +157,12 @@ python examples/benchmark_projector.py --devices 0 1
 
 ## Gallery
 
+TV denotes TV-regularized iterative reconstruction; Adam is the optimizer. Figure labels distinguish the method from its optimizer.
+
 **Measured walnut.** 240 measured views, circular cone beam, 256³: FDK (Hann window), SIRT (200 iterations), CGLS (20), TV (300, weight 0.3); axial and coronal centre slices.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_measured.png" width="100%" alt="Measured walnut: FDK, SIRT, CGLS and TV reconstructions">
+  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_measured.png?v=e0092c4" width="100%" alt="Measured walnut: FDK, SIRT, CGLS and TV reconstructions">
 </p>
 
 ```bash
@@ -151,7 +172,7 @@ python examples/walnut_reconstruction.py --figure out.png
 **Simulated helical scan of the walnut.** The FDK walnut volume as ground truth, 720 views, 1% noise, 256³. PSNR: FDK 26.67 dB, CGLS (30 iterations) 34.13 dB, SIRT (200) 34.52 dB, TV (200, weight 1.0) 37.77 dB.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_helical.png" width="100%" alt="Simulated helical scan of the walnut: FDK, CGLS, SIRT and TV reconstructions">
+  <img src="https://raw.githubusercontent.com/sypsyp97/diffct/main/docs/assets/walnut_helical.png?v=e0092c4" width="100%" alt="Simulated helical scan of the walnut: FDK, CGLS, SIRT and TV reconstructions">
 </p>
 
 ```bash
@@ -163,7 +184,7 @@ Walnut data: Meaney 2022, Zenodo 6986012, CC BY 4.0; see [examples/data/NOTICE](
 
 ## Examples
 
-`quickstart.py`, `analytical_reconstruction.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `plot_trajectory.py`, and the Slurm template `slurm/multi_node.sbatch`. Launch modes and distributed-loss rules are in [examples/README.md](https://github.com/sypsyp97/diffct/blob/main/examples/README.md).
+`quickstart.py`, `curved_detector.py`, `chunked_reconstruction.py`, `analytical_reconstruction.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `plot_trajectory.py`, and the Slurm template `slurm/multi_node.sbatch`. Launch modes and distributed-loss rules are in [examples/README.md](https://github.com/sypsyp97/diffct/blob/main/examples/README.md).
 
 ## Documentation
 

{diffct-2.0.2 → diffct-2.1.0}/diffct/__init__.py

@@ -49,7 +49,7 @@ try:
 except ImportError:
     pass
 
-__version__ = '2.0.2'
+__version__ = '2.1.0'
 
 __all__ = [
     'Projector',

diffct-2.1.0/diffct/chunking.py

@@ -0,0 +1,73 @@
+"""Spatial slices and immutable execution limits for streamed projectors."""
+
+from dataclasses import dataclass
+from itertools import product
+import math
+
+import torch
+
+
+@dataclass(frozen=True)
+class _ChunkPlan:
+    chunk_shape: tuple
+    view_chunk_size: int
+    devices: tuple
+
+
+def _memory_budget(device):
+    """Usable allocator bytes, retaining 25% headroom for allocation overhead.
+
+    Reusable reserved blocks count as available, but never bypass the process
+    fraction ceiling. Older PyTorch without its public fraction getter can
+    only observe driver/allocator memory; explicit limits remain available.
+    """
+    free, total = torch.cuda.mem_get_info(device)
+    allocated = torch.cuda.memory_allocated(device)
+    reusable = max(0, torch.cuda.memory_reserved(device) - allocated)
+    getter = getattr(torch.cuda, "get_per_process_memory_fraction", None)
+    fraction = getter(device) if getter is not None else 1.0
+    allocator_room = max(0, int(total * fraction) - allocated)
+    available = max(0, min(free + reusable, allocator_room))
+    budget = available * 3 // 4
+    allocation_limit = (1 << 63) - 1  # Unbounded limit in scalar int64 agreement.
+    backend = getattr(torch.cuda, "get_allocator_backend", lambda: "native")()
+    # Native requests >1 MiB and <10 MiB reserve a 20 MiB segment. A smaller
+    # current available room must use the <=1 MiB small pool, whose segments are 2 MiB.
+    # Source: pytorch/c10/cuda/CUDACachingAllocator.cpp (Native allocator notes).
+    if backend == "native" and available < 20 * 1024 ** 2:
+        allocation_limit = 1024 ** 2
+    return budget, allocation_limit
+
+
+def _working_set_bytes(beam, shape, views, detector_shape, surface):
+    """Conservative native staging/layout, cotangent, geometry and VJP scratch."""
+    rank = len(shape)
+    voxels = math.prod(shape)
+    rays = views * math.prod(detector_shape)
+    geometry = (rank * (views + rays) if surface
+                else rank * (4 if beam == "cone" else 3) * views)
+    # Cone permuted layout and its returned tensor can coexist with staging.
+    # Two ray buffers cover native output/cotangent and transfer scratch; two
+    # geometry buffers cover staged values and their first-order VJP/reduction.
+    tile_buffers = 3 if beam == "cone" else 2
+    return 4 * (tile_buffers * voxels + 2 * rays + 2 * geometry)
+
+
+def _largest_buffer_bytes(beam, shape, views, detector_shape, surface):
+    rank = len(shape)
+    rays = views * math.prod(detector_shape)
+    geometry = (rank * (views + rays) if surface
+                else rank * (4 if beam == "cone" else 3) * views)
+    return 4 * max(math.prod(shape), rays, geometry)
+
+
+def _tiles(shape, chunk_shape, spacing):
+    """Yield tensor slices, clipped shapes and physical centres in xyz order."""
+    starts = (range(0, size, chunk) for size, chunk in zip(shape, chunk_shape))
+    for start in product(*starts):
+        tile_shape = tuple(min(chunk, size - first)
+                           for size, chunk, first in zip(shape, chunk_shape, start))
+        slices = tuple(slice(first, first + size) for first, size in zip(start, tile_shape))
+        centre = tuple((first + size / 2 - full / 2) * spacing
+                       for first, size, full in zip(start, tile_shape, shape))
+        yield slices, tile_shape, centre[::-1]

{diffct-2.0.2 → diffct-2.1.0}/diffct/kernels/cone_beam.py

@@ -30,7 +30,7 @@ def _cone_3d_forward_kernel(
     d_vol, Nx, Ny, Nz,
     d_sino, n_views, n_u, n_v,
     du, dv, d_src_pos, d_det_center, d_det_u_vec, d_det_v_vec,
-    cx, cy, cz, voxel_spacing
+    cx, cy, cz, voxel_spacing, d_detector_positions=None,
 ):
     """Compute the 3D cone-beam forward projection with arbitrary source-detector trajectories.
 
@@ -93,27 +93,32 @@ def _cone_3d_forward_kernel(
     src_y = d_src_pos[iview, 1] / voxel_spacing
     src_z = d_src_pos[iview, 2] / voxel_spacing
 
-    # Read detector center and orientation vectors
-    det_cx = d_det_center[iview, 0] / voxel_spacing
-    det_cy = d_det_center[iview, 1] / voxel_spacing
-    det_cz = d_det_center[iview, 2] / voxel_spacing
+    if d_detector_positions is None or d_detector_positions.size == 0:
+        # Read detector center and orientation vectors
+        det_cx = d_det_center[iview, 0] / voxel_spacing
+        det_cy = d_det_center[iview, 1] / voxel_spacing
+        det_cz = d_det_center[iview, 2] / voxel_spacing
 
-    u_vec_x = d_det_u_vec[iview, 0]
-    u_vec_y = d_det_u_vec[iview, 1]
-    u_vec_z = d_det_u_vec[iview, 2]
+        u_vec_x = d_det_u_vec[iview, 0]
+        u_vec_y = d_det_u_vec[iview, 1]
+        u_vec_z = d_det_u_vec[iview, 2]
 
-    v_vec_x = d_det_v_vec[iview, 0]
-    v_vec_y = d_det_v_vec[iview, 1]
-    v_vec_z = d_det_v_vec[iview, 2]
+        v_vec_x = d_det_v_vec[iview, 0]
+        v_vec_y = d_det_v_vec[iview, 1]
+        v_vec_z = d_det_v_vec[iview, 2]
 
-    # Calculate detector element offset from center
-    u_offset = (np.float32(iu) + _HALF - np.float32(n_u) * _HALF) * du / voxel_spacing
-    v_offset = (np.float32(iv) + _HALF - np.float32(n_v) * _HALF) * dv / voxel_spacing
+        # Calculate detector element offset from center
+        u_offset = (np.float32(iu) + _HALF - np.float32(n_u) * _HALF) * du / voxel_spacing
+        v_offset = (np.float32(iv) + _HALF - np.float32(n_v) * _HALF) * dv / voxel_spacing
 
-    # Calculate 3D detector element position using center + u*u_vec + v*v_vec
-    det_x = det_cx + u_offset * u_vec_x + v_offset * v_vec_x
-    det_y = det_cy + u_offset * u_vec_y + v_offset * v_vec_y
-    det_z = det_cz + u_offset * u_vec_z + v_offset * v_vec_z
+        # Calculate 3D detector element position using center + u*u_vec + v*v_vec
+        det_x = det_cx + u_offset * u_vec_x + v_offset * v_vec_x
+        det_y = det_cy + u_offset * u_vec_y + v_offset * v_vec_y
+        det_z = det_cz + u_offset * u_vec_z + v_offset * v_vec_z
+    else:
+        det_x = d_detector_positions[iview, iu, iv, 0] / voxel_spacing
+        det_y = d_detector_positions[iview, iu, iv, 1] / voxel_spacing
+        det_z = d_detector_positions[iview, iu, iv, 2] / voxel_spacing
 
     # === 3D RAY DIRECTION CALCULATION ===
     # Ray direction vector from source to detector element in 3D space
@@ -238,7 +243,7 @@ def _cone_3d_backward_kernel(
     d_sino, n_views, n_u, n_v,
     d_vol, Nx, Ny, Nz,
     du, dv, d_src_pos, d_det_center, d_det_u_vec, d_det_v_vec,
-    cx, cy, cz, voxel_spacing
+    cx, cy, cz, voxel_spacing, d_detector_positions=None,
 ):
     """Compute the 3D cone-beam backprojection with arbitrary source-detector trajectories.
 
@@ -305,27 +310,32 @@ def _cone_3d_backward_kernel(
     src_y = d_src_pos[iview, 1] / voxel_spacing
     src_z = d_src_pos[iview, 2] / voxel_spacing
 
-    # Read detector center and orientation vectors
-    det_cx = d_det_center[iview, 0] / voxel_spacing
-    det_cy = d_det_center[iview, 1] / voxel_spacing
-    det_cz = d_det_center[iview, 2] / voxel_spacing
+    if d_detector_positions is None or d_detector_positions.size == 0:
+        # Read detector center and orientation vectors
+        det_cx = d_det_center[iview, 0] / voxel_spacing
+        det_cy = d_det_center[iview, 1] / voxel_spacing
+        det_cz = d_det_center[iview, 2] / voxel_spacing
 
-    u_vec_x = d_det_u_vec[iview, 0]
-    u_vec_y = d_det_u_vec[iview, 1]
-    u_vec_z = d_det_u_vec[iview, 2]
+        u_vec_x = d_det_u_vec[iview, 0]
+        u_vec_y = d_det_u_vec[iview, 1]
+        u_vec_z = d_det_u_vec[iview, 2]
 
-    v_vec_x = d_det_v_vec[iview, 0]
-    v_vec_y = d_det_v_vec[iview, 1]
-    v_vec_z = d_det_v_vec[iview, 2]
+        v_vec_x = d_det_v_vec[iview, 0]
+        v_vec_y = d_det_v_vec[iview, 1]
+        v_vec_z = d_det_v_vec[iview, 2]
 
-    # Calculate detector element offset from center
-    u_offset = (np.float32(iu) + _HALF - np.float32(n_u) * _HALF) * du / voxel_spacing
-    v_offset = (np.float32(iv) + _HALF - np.float32(n_v) * _HALF) * dv / voxel_spacing
+        # Calculate detector element offset from center
+        u_offset = (np.float32(iu) + _HALF - np.float32(n_u) * _HALF) * du / voxel_spacing
+        v_offset = (np.float32(iv) + _HALF - np.float32(n_v) * _HALF) * dv / voxel_spacing
 
-    # Calculate 3D detector element position using center + u*u_vec + v*v_vec
-    det_x = det_cx + u_offset * u_vec_x + v_offset * v_vec_x
-    det_y = det_cy + u_offset * u_vec_y + v_offset * v_vec_y
-    det_z = det_cz + u_offset * u_vec_z + v_offset * v_vec_z
+        # Calculate 3D detector element position using center + u*u_vec + v*v_vec
+        det_x = det_cx + u_offset * u_vec_x + v_offset * v_vec_x
+        det_y = det_cy + u_offset * u_vec_y + v_offset * v_vec_y
+        det_z = det_cz + u_offset * u_vec_z + v_offset * v_vec_z
+    else:
+        det_x = d_detector_positions[iview, iu, iv, 0] / voxel_spacing
+        det_y = d_detector_positions[iview, iu, iv, 1] / voxel_spacing
+        det_z = d_detector_positions[iview, iu, iv, 2] / voxel_spacing
 
     # === 3D RAY DIRECTION CALCULATION ===
     # Ray direction vector from source to detector element in 3D space

{diffct-2.0.2 → diffct-2.1.0}/diffct/kernels/fan_beam.py

@@ -30,7 +30,7 @@ def _fan_2d_forward_kernel(
     d_image, Nx, Ny,
     d_sino, n_ang, n_det,
     det_spacing, d_src_pos, d_det_center, d_det_u_vec,
-    cx, cy, voxel_spacing
+    cx, cy, voxel_spacing, d_detector_positions=None,
 ):
     """Compute the 2D fan beam forward projection with arbitrary source-detector trajectories.
 
@@ -82,19 +82,23 @@ def _fan_2d_forward_kernel(
     src_x = d_src_pos[iang, 0] / voxel_spacing
     src_y = d_src_pos[iang, 1] / voxel_spacing
 
-    # Read detector center and orientation vector
-    det_cx = d_det_center[iang, 0] / voxel_spacing
-    det_cy = d_det_center[iang, 1] / voxel_spacing
+    if d_detector_positions is None or d_detector_positions.size == 0:
+        # Read detector center and orientation vector
+        det_cx = d_det_center[iang, 0] / voxel_spacing
+        det_cy = d_det_center[iang, 1] / voxel_spacing
 
-    u_vec_x = d_det_u_vec[iang, 0]
-    u_vec_y = d_det_u_vec[iang, 1]
+        u_vec_x = d_det_u_vec[iang, 0]
+        u_vec_y = d_det_u_vec[iang, 1]
 
-    # Calculate detector element offset from center
-    u_offset = (np.float32(idet) + _HALF - np.float32(n_det) * _HALF) * det_spacing / voxel_spacing
+        # Calculate detector element offset from center
+        u_offset = (np.float32(idet) + _HALF - np.float32(n_det) * _HALF) * det_spacing / voxel_spacing
 
-    # Calculate 2D detector element position using center + u*u_vec
-    det_x = det_cx + u_offset * u_vec_x
-    det_y = det_cy + u_offset * u_vec_y
+        # Calculate 2D detector element position using center + u*u_vec
+        det_x = det_cx + u_offset * u_vec_x
+        det_y = det_cy + u_offset * u_vec_y
+    else:
+        det_x = d_detector_positions[iang, idet, 0] / voxel_spacing
+        det_y = d_detector_positions[iang, idet, 1] / voxel_spacing
 
     # === RAY DIRECTION CALCULATION ===
     # Ray direction vector from source to detector element
@@ -192,7 +196,7 @@ def _fan_2d_backward_kernel(
     d_sino, n_ang, n_det,
     d_image, Nx, Ny,
     det_spacing, d_src_pos, d_det_center, d_det_u_vec,
-    cx, cy, voxel_spacing
+    cx, cy, voxel_spacing, d_detector_positions=None,
 ):
     """Compute the 2D fan beam backprojection with arbitrary source-detector trajectories.
 
@@ -248,19 +252,23 @@ def _fan_2d_backward_kernel(
     src_x = d_src_pos[iang, 0] / voxel_spacing
     src_y = d_src_pos[iang, 1] / voxel_spacing
 
-    # Read detector center and orientation vector
-    det_cx = d_det_center[iang, 0] / voxel_spacing
-    det_cy = d_det_center[iang, 1] / voxel_spacing
+    if d_detector_positions is None or d_detector_positions.size == 0:
+        # Read detector center and orientation vector
+        det_cx = d_det_center[iang, 0] / voxel_spacing
+        det_cy = d_det_center[iang, 1] / voxel_spacing
 
-    u_vec_x = d_det_u_vec[iang, 0]
-    u_vec_y = d_det_u_vec[iang, 1]
+        u_vec_x = d_det_u_vec[iang, 0]
+        u_vec_y = d_det_u_vec[iang, 1]
 
-    # Calculate detector element offset from center
-    u_offset = (np.float32(idet) + _HALF - np.float32(n_det) * _HALF) * det_spacing / voxel_spacing
+        # Calculate detector element offset from center
+        u_offset = (np.float32(idet) + _HALF - np.float32(n_det) * _HALF) * det_spacing / voxel_spacing
 
-    # Calculate 2D detector element position using center + u*u_vec
-    det_x = det_cx + u_offset * u_vec_x
-    det_y = det_cy + u_offset * u_vec_y
+        # Calculate 2D detector element position using center + u*u_vec
+        det_x = det_cx + u_offset * u_vec_x
+        det_y = det_cy + u_offset * u_vec_y
+    else:
+        det_x = d_detector_positions[iang, idet, 0] / voxel_spacing
+        det_y = d_detector_positions[iang, idet, 1] / voxel_spacing
 
     # === RAY DIRECTION CALCULATION ===
     # Ray direction vector from source to detector element