diffct 2.2.0__tar.gz → 2.2.1__tar.gz

{diffct-2.2.0 → diffct-2.2.1}/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.2.1] - 2026-10-13
+
+### Added
+
+- Public differentiable `fbp`, `fdk` and approximate slice-windowed `helical_fdk`
+  pipelines, with replaceable projection, angular and frequency-response tensors.
+  Low-precision measurements run in float32 and keep gradients in their own dtype.
+- Dedicated CUDA transposes of the analytical parallel/fan/cone gathers,
+  including sinogram gradients and higher derivatives with fixed geometry.
+- Circular short-scan checks for `short_scan=True`: orbit, detector-u handedness,
+  angular span, and constant detector distance and offset. Tolerances follow the
+  physical geometry scale and the original trajectory precision.
+- Public helical view weights and weighted gather. Slice centers and angular
+  quadrature use float64, so large angle or height offsets keep full-turn coverage.
+- Examples `learnable_reconstruction.py` and `helical_fdk.py`, and the
+  analytical learning guide.
+
+### Changed
+
+- `parallel_weighted_backproject`, `fan_weighted_backproject` and
+  `cone_weighted_backproject` support sinogram autograd. Geometry and isocenter
+  gradients raise an error.
+- The FDK baselines in `examples/_common.py` and `walnut_reconstruction.py` call `fdk`.
+
 ## [2.2.0] - 2026-10-11
 
 ### Added

{diffct-2.2.0 → diffct-2.2.1}/CITATION.cff

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

{diffct-2.2.0 → diffct-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: diffct
-Version: 2.2.0
+Version: 2.2.1
 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/
@@ -77,7 +77,7 @@ To our knowledge, diffct is the only open-source GPU CT library that combines ar
 - **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.
 - **Large volumes.** Automatic spatial, view and pixel blocks with bounded transfer buffers control working memory. `project_into`/`backproject_into` accept caller-owned tensor or disk stores; tensor autograd keeps complete data on its input device. 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 torchrun and NCCL across ranks. Default `partition="views"` shards projections and replicates volumes. `partition="space"` gives each rank an owned volume slab and combines ray contributions. 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.
+- **Differentiable FBP and FDK.** `fbp`, `fdk` and approximate `helical_fdk` compose the public filters, weights and analytical backprojectors. Their backward kernels transpose the actual interpolation stencil; custom filters and weights can be learned. See the [analytical guide](docs/source/analytical_learning.rst).
 
 Capabilities, limits and isocenter rules: [docs/REFERENCE.md](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#capabilities-and-limits).
 
@@ -220,7 +220,7 @@ Walnut data: Meaney 2022, Zenodo 6986012, CC BY 4.0; see [examples/data/NOTICE](
 
 ## Examples
 
-`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).
+`quickstart.py`, `curved_detector.py`, `chunked_reconstruction.py`, `disk_reconstruction.py`, `benchmark_execution.py`, `analytical_reconstruction.py`, `learnable_reconstruction.py`, `helical_fdk.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `benchmark_scaling.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.2.0 → diffct-2.2.1}/README.md

@@ -46,7 +46,7 @@ To our knowledge, diffct is the only open-source GPU CT library that combines ar
 - **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.
 - **Large volumes.** Automatic spatial, view and pixel blocks with bounded transfer buffers control working memory. `project_into`/`backproject_into` accept caller-owned tensor or disk stores; tensor autograd keeps complete data on its input device. 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 torchrun and NCCL across ranks. Default `partition="views"` shards projections and replicates volumes. `partition="space"` gives each rank an owned volume slab and combines ray contributions. 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.
+- **Differentiable FBP and FDK.** `fbp`, `fdk` and approximate `helical_fdk` compose the public filters, weights and analytical backprojectors. Their backward kernels transpose the actual interpolation stencil; custom filters and weights can be learned. See the [analytical guide](docs/source/analytical_learning.rst).
 
 Capabilities, limits and isocenter rules: [docs/REFERENCE.md](https://github.com/sypsyp97/diffct/blob/main/docs/REFERENCE.md#capabilities-and-limits).
 
@@ -189,7 +189,7 @@ Walnut data: Meaney 2022, Zenodo 6986012, CC BY 4.0; see [examples/data/NOTICE](
 
 ## Examples
 
-`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).
+`quickstart.py`, `curved_detector.py`, `chunked_reconstruction.py`, `disk_reconstruction.py`, `benchmark_execution.py`, `analytical_reconstruction.py`, `learnable_reconstruction.py`, `helical_fdk.py`, `iterative_reconstruction.py`, `walnut_reconstruction.py`, `geometry_calibration.py`, `benchmark_projector.py`, `benchmark_scaling.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.2.0 → diffct-2.2.1}/diffct/__init__.py

@@ -17,6 +17,13 @@ from .projectors import (
 from .operators import Projector
 from .storage import TensorStore, NpyStore
 from .surfaces import ParameterizedSurface
+from .reconstruction import (
+    fbp,
+    fdk,
+    helical_fdk,
+    helical_view_weights,
+    helical_weighted_backproject,
+)
 
 from .geometry import (
     circular_trajectory_3d,
@@ -51,13 +58,18 @@ try:
 except ImportError:
     pass
 
-__version__ = '2.2.0'
+__version__ = '2.2.1'
 
 __all__ = [
     'Projector',
     'TensorStore',
     'NpyStore',
     'ParameterizedSurface',
+    'fbp',
+    'fdk',
+    'helical_fdk',
+    'helical_view_weights',
+    'helical_weighted_backproject',
     'ParallelProjectorFunction',
     'ParallelBackprojectorFunction',
     'FanProjectorFunction',

{diffct-2.2.0 → diffct-2.2.1}/diffct/analytical.py

@@ -40,6 +40,9 @@ from .kernels import (
     _parallel_2d_fbp_backproject_kernel,
     _fan_2d_fbp_backproject_kernel,
     _cone_3d_fdk_backproject_kernel,
+    _parallel_2d_fbp_transpose_kernel,
+    _fan_2d_fbp_transpose_kernel,
+    _cone_3d_fdk_transpose_kernel,
 )
 
 
@@ -367,8 +370,8 @@ def _as_contig_f32(t, device):
 
 
 @_on_device_of("sinogram")
-def parallel_weighted_backproject(sinogram, ray_dir, det_origin, det_u_vec,
-                                  detector_spacing, H, W, voxel_spacing=1.0):
+def _parallel_weighted_backproject_raw(sinogram, ray_dir, det_origin, det_u_vec,
+                                      detector_spacing, H, W, voxel_spacing=1.0):
     """Voxel-driven parallel-beam FBP backprojection with analytical constant.
 
     Runs the dedicated parallel-beam FBP gather kernel (one thread per
@@ -451,8 +454,8 @@ def _analytical_geometry(src_pos, det_center, n, isocenter):
 
 
 @_on_device_of("sinogram")
-def fan_weighted_backproject(sinogram, src_pos, det_center, det_u_vec,
-                             detector_spacing, H, W, voxel_spacing=1.0, *, isocenter=None):
+def _fan_weighted_backproject_raw(sinogram, src_pos, det_center, det_u_vec,
+                                 detector_spacing, H, W, voxel_spacing=1.0, *, isocenter=None):
     """Voxel-driven fan-beam FBP backprojection with analytical constant.
 
     Runs the dedicated fan-beam FBP gather kernel (one thread per output
@@ -507,8 +510,8 @@ def fan_weighted_backproject(sinogram, src_pos, det_center, det_u_vec,
 
 
 @_on_device_of("sinogram")
-def cone_weighted_backproject(sinogram, src_pos, det_center, det_u_vec, det_v_vec,
-                              D, H, W, du, dv, voxel_spacing=1.0, *, isocenter=None):
+def _cone_weighted_backproject_raw(sinogram, src_pos, det_center, det_u_vec, det_v_vec,
+                                  D, H, W, du, dv, voxel_spacing=1.0, *, isocenter=None):
     """Voxel-driven cone-beam FDK backprojection with analytical constant.
 
     Runs the dedicated cone-beam FDK gather kernel (one thread per output
@@ -571,3 +574,145 @@ def cone_weighted_backproject(sinogram, src_pos, det_center, det_u_vec, det_v_ve
     # Convert back to (D, H, W) layout for the user.
     reco = reco_perm.permute(2, 1, 0).contiguous() * scale
     return reco
+
+
+def _validate_analytical_inputs(sinogram, geometry, ndim, isocenter=None):
+    if not isinstance(sinogram, torch.Tensor) or sinogram.ndim != ndim:
+        raise ValueError(f"sinogram must have rank {ndim}")
+    if min(sinogram.shape[1:]) < 2:
+        raise ValueError("Analytical backprojection requires at least two detector bins on each axis")
+    for component in geometry:
+        if not isinstance(component, torch.Tensor) or component.shape != (sinogram.shape[0], ndim):
+            raise ValueError(f"Every geometry tensor must have shape (n_views, {ndim})")
+        if component.requires_grad:
+            raise ValueError("Analytical backprojection does not support geometry gradients")
+    if isinstance(isocenter, torch.Tensor) and isocenter.requires_grad:
+        raise ValueError("Analytical backprojection does not support isocenter gradients")
+    if not sinogram.is_cuda:
+        raise ValueError("sinogram must be on a CUDA device")
+
+
+def _analytical_gather_raw(sinogram, beam, geometry, parameters, isocenter):
+    if beam == "parallel":
+        return _parallel_weighted_backproject_raw(sinogram, *geometry, *parameters)
+    if beam == "fan":
+        return _fan_weighted_backproject_raw(sinogram, *geometry, *parameters, isocenter=isocenter)
+    return _cone_weighted_backproject_raw(sinogram, *geometry, *parameters, isocenter=isocenter)
+
+
+@_on_device_of("image")
+def _analytical_transpose_raw(image, beam, geometry, parameters, isocenter, sinogram_shape):
+    device = image.device
+    geometry = tuple(_as_contig_f32(component, device) for component in geometry)
+    image = _as_contig_f32(image, device)
+    sinogram = torch.zeros(sinogram_shape, device=device, dtype=torch.float32)
+    d_sino = TorchCUDABridge.tensor_to_cuda_array(sinogram)
+    d_geometry = tuple(TorchCUDABridge.tensor_to_cuda_array(component) for component in geometry)
+    stream = _get_numba_external_stream_for(torch.cuda.current_stream())
+
+    scale = 1.0 / (2.0 * math.pi)
+    iso = ()
+    if beam != "parallel":
+        source, detector, u = geometry[:3]
+        normal = (torch.stack((-u[:, 1], u[:, 0]), dim=1) if beam == "fan"
+                  else torch.cross(u, geometry[3], dim=1))
+        isocenter, sid_mean, sdd_mean = _analytical_geometry(source, detector, normal, isocenter)
+        scale = sdd_mean / (2.0 * math.pi * sid_mean)
+        iso = tuple(_DTYPE(value.item() / parameters[-1]) for value in isocenter)
+    image = image * scale
+
+    if beam == "cone":
+        D, H, W, du, dv, spacing = parameters
+        image = image.permute(2, 1, 0).contiguous()
+        d_image = TorchCUDABridge.tensor_to_cuda_array(image)
+        grid, tpb = _grid_3d(D, H, W)
+        _cone_3d_fdk_transpose_kernel[grid, tpb, stream](
+            d_sino, *sinogram_shape, d_image, W, H, D, _DTYPE(du), _DTYPE(dv),
+            *d_geometry, _DTYPE(W * 0.5), _DTYPE(H * 0.5), _DTYPE(D * 0.5),
+            _DTYPE(spacing), *iso,
+        )
+    else:
+        pitch, H, W, spacing = parameters
+        d_image = TorchCUDABridge.tensor_to_cuda_array(image)
+        grid, tpb = _grid_2d(W, H)
+        kernel = (_parallel_2d_fbp_transpose_kernel if beam == "parallel"
+                  else _fan_2d_fbp_transpose_kernel)
+        kernel[grid, tpb, stream](
+            d_sino, *sinogram_shape, d_image, W, H, _DTYPE(pitch), *d_geometry,
+            _DTYPE(W * 0.5), _DTYPE(H * 0.5), _DTYPE(spacing), *iso,
+        )
+    return sinogram
+
+
+class _AnalyticalGather(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, sinogram, beam, geometry, parameters, isocenter):
+        # Backward uses the exact geometry observed by forward, even if the
+        # caller edits its fixed trajectory or isocenter afterwards.
+        geometry = tuple(component.detach().clone() for component in geometry)
+        if isocenter is not None:
+            isocenter = torch.as_tensor(isocenter, device=sinogram.device,
+                                        dtype=torch.float32).detach().clone()
+        ctx.save_for_backward(*geometry, isocenter)
+        ctx.beam, ctx.parameters = beam, parameters
+        ctx.input_shape, ctx.input_dtype, ctx.input_device = sinogram.shape, sinogram.dtype, sinogram.device
+        return _analytical_gather_raw(sinogram, beam, geometry, parameters, isocenter)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        *geometry, isocenter = ctx.saved_tensors
+        grad_input = _AnalyticalTranspose.apply(
+            grad_output, ctx.beam, tuple(geometry), ctx.parameters, isocenter, ctx.input_shape,
+        ).to(device=ctx.input_device, dtype=ctx.input_dtype)
+        return grad_input, None, None, None, None
+
+
+class _AnalyticalTranspose(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, image, beam, geometry, parameters, isocenter, sinogram_shape):
+        ctx.beam, ctx.geometry, ctx.parameters, ctx.isocenter = beam, geometry, parameters, isocenter
+        ctx.input_dtype, ctx.input_device = image.dtype, image.device
+        return _analytical_transpose_raw(image, beam, geometry, parameters, isocenter, sinogram_shape)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        grad_input = _AnalyticalGather.apply(
+            grad_output, ctx.beam, ctx.geometry, ctx.parameters, ctx.isocenter,
+        ).to(device=ctx.input_device, dtype=ctx.input_dtype)
+        return grad_input, None, None, None, None, None
+
+
+def _analytical_backproject(sinogram, beam, geometry, parameters, isocenter=None):
+    _validate_analytical_inputs(sinogram, geometry, 3 if beam == "cone" else 2, isocenter)
+    if torch.is_grad_enabled() and sinogram.requires_grad:
+        return _AnalyticalGather.apply(sinogram, beam, geometry, parameters, isocenter)
+    return _analytical_gather_raw(sinogram, beam, geometry, parameters, isocenter)
+
+
+def parallel_weighted_backproject(sinogram, ray_dir, det_origin, det_u_vec,
+                                  detector_spacing, H, W, voxel_spacing=1.0):
+    return _analytical_backproject(
+        sinogram, "parallel", (ray_dir, det_origin, det_u_vec),
+        (detector_spacing, H, W, voxel_spacing),
+    )
+
+
+def fan_weighted_backproject(sinogram, src_pos, det_center, det_u_vec,
+                             detector_spacing, H, W, voxel_spacing=1.0, *, isocenter=None):
+    return _analytical_backproject(
+        sinogram, "fan", (src_pos, det_center, det_u_vec),
+        (detector_spacing, H, W, voxel_spacing), isocenter,
+    )
+
+
+def cone_weighted_backproject(sinogram, src_pos, det_center, det_u_vec, det_v_vec,
+                              D, H, W, du, dv, voxel_spacing=1.0, *, isocenter=None):
+    return _analytical_backproject(
+        sinogram, "cone", (src_pos, det_center, det_u_vec, det_v_vec),
+        (D, H, W, du, dv, voxel_spacing), isocenter,
+    )
+
+
+parallel_weighted_backproject.__doc__ = _parallel_weighted_backproject_raw.__doc__
+fan_weighted_backproject.__doc__ = _fan_weighted_backproject_raw.__doc__
+cone_weighted_backproject.__doc__ = _cone_weighted_backproject_raw.__doc__

{diffct-2.2.0 → diffct-2.2.1}/diffct/kernels/__init__.py

@@ -26,6 +26,11 @@ from .geometry_vjp import (
     _fan_2d_geometry_vjp_kernel,
     _cone_3d_geometry_vjp_kernel,
 )
+from .analytical_transpose import (
+    _parallel_2d_fbp_transpose_kernel,
+    _fan_2d_fbp_transpose_kernel,
+    _cone_3d_fdk_transpose_kernel,
+)
 
 __all__ = [
     '_parallel_2d_forward_kernel',
@@ -40,4 +45,7 @@ __all__ = [
     '_parallel_2d_geometry_vjp_kernel',
     '_fan_2d_geometry_vjp_kernel',
     '_cone_3d_geometry_vjp_kernel',
+    '_parallel_2d_fbp_transpose_kernel',
+    '_fan_2d_fbp_transpose_kernel',
+    '_cone_3d_fdk_transpose_kernel',
 ]

diffct-2.2.1/diffct/kernels/analytical_transpose.py

@@ -0,0 +1,295 @@
+"""Discrete transposes of the analytical FBP/FDK gather kernels.
+
+Geometry arithmetic and interpolation bounds mirror the gather kernels;
+only the final sample operation changes to an atomic detector-bin scatter.
+"""
+
+import math
+
+import numpy as np
+from numba import cuda
+
+from ..constants import _EPSILON, _FDK_ACCURACY_DECORATOR, _HALF, _ONE, _ZERO
+
+
+@_FDK_ACCURACY_DECORATOR
+def _parallel_2d_fbp_transpose_kernel(
+    d_sino, n_views, n_det,
+    d_image, Nx, Ny,
+    det_spacing, d_ray_dir, d_det_origin, d_det_u_vec,
+    cx, cy, voxel_spacing
+):
+    """Scatter image cotangents through the parallel analytical gather stencil."""
+    ix, iy = cuda.grid(2)
+    if ix >= Nx or iy >= Ny:
+        return
+    if n_det < 2:
+        return
+
+    # Sample at voxel centres, matching the cell-constant Siddon projector.
+    x_v = np.float32(ix) + _HALF - cx
+    y_v = np.float32(iy) + _HALF - cy
+
+    det_spacing_v = det_spacing / voxel_spacing
+    half_u = (np.float32(n_det) - _ONE) * _HALF
+
+    for iview in range(n_views):
+        dox = d_det_origin[iview, 0] / voxel_spacing
+        doy = d_det_origin[iview, 1] / voxel_spacing
+
+        ux = d_det_u_vec[iview, 0]
+        uy = d_det_u_vec[iview, 1]
+
+        rx = x_v - dox
+        ry = y_v - doy
+
+        u_det = rx * ux + ry * uy
+
+        fu = u_det / det_spacing_v + half_u
+        if fu < _ZERO or fu > (np.float32(n_det) - _ONE):
+            continue
+
+        iu0 = int(math.floor(fu))
+        if iu0 >= n_det - 1:
+            iu0 = n_det - 2
+        if iu0 < 0:
+            iu0 = 0
+        tu = fu - np.float32(iu0)
+        if tu < _ZERO:
+            tu = _ZERO
+        elif tu > _ONE:
+            tu = _ONE
+
+        value = d_image[iy, ix]
+        cuda.atomic.add(d_sino, (iview, iu0), value * (_ONE - tu))
+        cuda.atomic.add(d_sino, (iview, iu0 + 1), value * tu)
+
+
+@_FDK_ACCURACY_DECORATOR
+def _fan_2d_fbp_transpose_kernel(
+    d_sino, n_views, n_det,
+    d_image, Nx, Ny,
+    det_spacing, d_src_pos, d_det_center, d_det_u_vec,
+    cx, cy, voxel_spacing, iso_x, iso_y
+):
+    """Scatter image cotangents through the fan analytical gather stencil."""
+    ix, iy = cuda.grid(2)
+    if ix >= Nx or iy >= Ny:
+        return
+    if n_det < 2:
+        return
+
+    # Sample at voxel centres, matching the cell-constant Siddon projector.
+    x_v = np.float32(ix) + _HALF - cx
+    y_v = np.float32(iy) + _HALF - cy
+
+    det_spacing_v = det_spacing / voxel_spacing
+    half_u = (np.float32(n_det) - _ONE) * _HALF
+
+    for iview in range(n_views):
+        sx = d_src_pos[iview, 0] / voxel_spacing
+        sy = d_src_pos[iview, 1] / voxel_spacing
+
+        dcx = d_det_center[iview, 0] / voxel_spacing
+        dcy = d_det_center[iview, 1] / voxel_spacing
+
+        ux = d_det_u_vec[iview, 0]
+        uy = d_det_u_vec[iview, 1]
+
+        # Detector normal in 2D: rotate u_vec 90 degrees. Choose the
+        # orientation that points from the source toward the detector,
+        # so that ``U_n`` is positive for voxels on the detector side.
+        nx = -uy
+        ny = ux
+        # Align normal so that (det_center - src) . n > 0.
+        align = (dcx - sx) * nx + (dcy - sy) * ny
+        if align < _ZERO:
+            nx = -nx
+            ny = -ny
+
+        # Perpendicular distance from source to voxel along normal.
+        px = x_v - sx
+        py = y_v - sy
+        U_n = px * nx + py * ny
+        if U_n <= _EPSILON:
+            continue
+
+        sdd_n = (dcx - sx) * nx + (dcy - sy) * ny
+        if sdd_n <= _EPSILON:
+            continue
+        mag = sdd_n / U_n
+
+        # Source-to-isocenter distance, independent of coordinate origin.
+        sid_n = (iso_x - sx) * nx + (iso_y - sy) * ny
+        if sid_n <= _EPSILON:
+            continue
+
+        hx = sx + mag * px
+        hy = sy + mag * py
+
+        rx = hx - dcx
+        ry = hy - dcy
+        u_det = rx * ux + ry * uy
+
+        fu = u_det / det_spacing_v + half_u
+        if fu < _ZERO or fu > (np.float32(n_det) - _ONE):
+            continue
+
+        iu0 = int(math.floor(fu))
+        if iu0 >= n_det - 1:
+            iu0 = n_det - 2
+        if iu0 < 0:
+            iu0 = 0
+        tu = fu - np.float32(iu0)
+        if tu < _ZERO:
+            tu = _ZERO
+        elif tu > _ONE:
+            tu = _ONE
+
+        w_ratio = sid_n / U_n
+        w = w_ratio * w_ratio
+        value = d_image[iy, ix] * w
+        cuda.atomic.add(d_sino, (iview, iu0), value * (_ONE - tu))
+        cuda.atomic.add(d_sino, (iview, iu0 + 1), value * tu)
+
+
+@_FDK_ACCURACY_DECORATOR
+def _cone_3d_fdk_transpose_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, iso_x, iso_y, iso_z
+):
+    """Scatter image cotangents through the cone analytical gather stencil."""
+    iz, iy, ix = cuda.grid(3)
+    if ix >= Nx or iy >= Ny or iz >= Nz:
+        return
+    if n_u < 2 or n_v < 2:
+        return
+
+    # Voxel position in voxel-unit, origin-centred coordinates.
+    # Sample at voxel centres, matching the cell-constant Siddon projector.
+    x_v = np.float32(ix) + _HALF - cx
+    y_v = np.float32(iy) + _HALF - cy
+    z_v = np.float32(iz) + _HALF - cz
+
+    du_v = du / voxel_spacing
+    dv_v = dv / voxel_spacing
+
+    half_u = (np.float32(n_u) - _ONE) * _HALF
+    half_v = (np.float32(n_v) - _ONE) * _HALF
+
+    for iview in range(n_views):
+        # Source position in voxel units.
+        sx = d_src_pos[iview, 0] / voxel_spacing
+        sy = d_src_pos[iview, 1] / voxel_spacing
+        sz = d_src_pos[iview, 2] / voxel_spacing
+
+        # Detector centre in voxel units.
+        dcx = d_det_center[iview, 0] / voxel_spacing
+        dcy = d_det_center[iview, 1] / voxel_spacing
+        dcz = d_det_center[iview, 2] / voxel_spacing
+
+        # Detector orientation (unit vectors, ratio-free).
+        ux = d_det_u_vec[iview, 0]
+        uy = d_det_u_vec[iview, 1]
+        uz = d_det_u_vec[iview, 2]
+        vx = d_det_v_vec[iview, 0]
+        vy = d_det_v_vec[iview, 1]
+        vz = d_det_v_vec[iview, 2]
+
+        # Detector normal n = u x v. Normalized defensively in case the
+        # caller supplied non-orthonormal u/v axes.
+        nx = uy * vz - uz * vy
+        ny = uz * vx - ux * vz
+        nz = ux * vy - uy * vx
+        n_len = math.sqrt(nx * nx + ny * ny + nz * nz)
+        if n_len < _EPSILON:
+            continue
+        nx /= n_len
+        ny /= n_len
+        nz /= n_len
+
+        # Orient the normal so it points from the source toward the
+        # detector. Without this flip, user-supplied (u_vec, v_vec) pairs
+        # whose cross product happens to point the other way would make
+        # every voxel's U_n negative and get silently skipped, producing
+        # a zero reconstruction. The circular_trajectory_3d helper already
+        # produces the right-handed convention so this is a no-op there.
+        align = (dcx - sx) * nx + (dcy - sy) * ny + (dcz - sz) * nz
+        if align < _ZERO:
+            nx = -nx
+            ny = -ny
+            nz = -nz
+
+        # Signed distance from source to voxel along the detector normal
+        # (this is the U in the (sid/U)^2 FDK weight).
+        px = x_v - sx
+        py = y_v - sy
+        pz = z_v - sz
+        U_n = px * nx + py * ny + pz * nz
+        if U_n <= _EPSILON:
+            continue
+
+        # Source-to-detector distance along the normal.
+        sdd_n = (dcx - sx) * nx + (dcy - sy) * ny + (dcz - sz) * nz
+        if sdd_n <= _EPSILON:
+            continue
+
+        # Source-to-isocenter distance, independent of coordinate origin.
+        sid_n = (iso_x - sx) * nx + (iso_y - sy) * ny + (iso_z - sz) * nz
+        if sid_n <= _EPSILON:
+            continue
+
+        mag = sdd_n / U_n
+
+        # Hit point on the detector plane.
+        hx = sx + mag * px
+        hy = sy + mag * py
+        hz = sz + mag * pz
+
+        # Detector coordinates relative to detector centre.
+        rx = hx - dcx
+        ry = hy - dcy
+        rz = hz - dcz
+
+        u_det = rx * ux + ry * uy + rz * uz
+        v_det = rx * vx + ry * vy + rz * vz
+
+        # Convert (u, v) to fractional bin index.
+        fu = u_det / du_v + half_u
+        fv = v_det / dv_v + half_v
+
+        if fu < _ZERO or fu > (np.float32(n_u) - _ONE) or fv < _ZERO or fv > (np.float32(n_v) - _ONE):
+            continue
+
+        iu0 = int(math.floor(fu))
+        iv0 = int(math.floor(fv))
+        if iu0 >= n_u - 1:
+            iu0 = n_u - 2
+        if iv0 >= n_v - 1:
+            iv0 = n_v - 2
+        if iu0 < 0:
+            iu0 = 0
+        if iv0 < 0:
+            iv0 = 0
+        tu = fu - np.float32(iu0)
+        tv = fv - np.float32(iv0)
+        if tu < _ZERO:
+            tu = _ZERO
+        elif tu > _ONE:
+            tu = _ONE
+        if tv < _ZERO:
+            tv = _ZERO
+        elif tv > _ONE:
+            tv = _ONE
+
+        omtu = _ONE - tu
+        omtv = _ONE - tv
+        w_ratio = sid_n / U_n
+        w = w_ratio * w_ratio
+        value = d_vol[ix, iy, iz] * w
+        cuda.atomic.add(d_sino, (iview, iu0, iv0), value * omtu * omtv)
+        cuda.atomic.add(d_sino, (iview, iu0 + 1, iv0), value * tu * omtv)
+        cuda.atomic.add(d_sino, (iview, iu0, iv0 + 1), value * omtu * tv)
+        cuda.atomic.add(d_sino, (iview, iu0 + 1, iv0 + 1), value * tu * tv)