diffct 2.2.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

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/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/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/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)

diffct/reconstruction.py

@@ -0,0 +1,399 @@
+"""Composable analytical reconstruction APIs for fixed, flat-detector geometry."""
+
+import math
+import numbers
+
+import torch
+import torch.nn.functional as F
+
+from .analytical import (
+    _analytical_geometry, angular_integration_weights, cone_weighted_backproject,
+    fan_weighted_backproject, parallel_weighted_backproject,
+    parker_weights, ramp_filter_1d,
+)
+from .operators import _detector_spacing, _positive_float, _shape, _validate_trajectory
+
+
+def _fixed(value, name):
+    if isinstance(value, torch.Tensor) and value.requires_grad:
+        raise ValueError(f"{name} gradients are not supported by analytical reconstruction")
+
+
+def _prepare(sinogram, trajectory, volume_shape, beam, detector_spacing, voxel_spacing, isocenter):
+    if not isinstance(sinogram, torch.Tensor) or not sinogram.is_cuda:
+        raise ValueError("Analytical reconstruction requires a CUDA sinogram tensor")
+    if not torch.is_floating_point(sinogram):
+        raise ValueError("sinogram must have a real floating-point dtype")
+    # FFT and geometric checks need at least float32 precision. The native
+    # cast keeps gradients connected to low-precision input/parameter leaves.
+    if sinogram.dtype not in (torch.float32, torch.float64):
+        sinogram = sinogram.float()
+    rank = 3 if beam == "cone" else 2
+    if sinogram.ndim != rank or min(sinogram.shape[1:]) < 2:
+        raise ValueError("sinogram rank must match the beam and detector axes need at least two bins")
+    for component in trajectory:
+        _fixed(component, "trajectory")
+    _fixed(isocenter, "isocenter")
+    geometry, views = _validate_trajectory(trajectory, beam)
+    if sinogram.shape[0] != views:
+        raise ValueError("sinogram and trajectory must have the same number of views")
+    shape = _shape(volume_shape, rank, "volume_shape")
+    pitch = _detector_spacing(detector_spacing, beam)
+    spacing = _positive_float(voxel_spacing, "voxel_spacing")
+    geometry = tuple(t.to(device=sinogram.device, dtype=sinogram.dtype) for t in geometry)
+    return sinogram, geometry, shape, pitch, spacing
+
+
+def _angles(angles, views, device):
+    _fixed(angles, "angles")
+    value = torch.as_tensor(angles, device=device)
+    if not torch.is_floating_point(value) or value.shape != (views,) or not torch.isfinite(value).all():
+        raise ValueError("angles must be a finite real vector with one unwrapped radian angle per view")
+    return value
+
+
+def _weights(value, sinogram, name, shape=None):
+    value = torch.as_tensor(value, device=sinogram.device, dtype=sinogram.dtype)
+    if not torch.isfinite(value).all():
+        raise ValueError(f"{name} must contain finite values")
+    if shape is not None:
+        if value.shape != shape:
+            raise ValueError(f"{name} must have shape {shape}")
+    else:
+        try:
+            if torch.broadcast_shapes(value.shape, sinogram.shape) != sinogram.shape:
+                raise ValueError
+        except (RuntimeError, ValueError) as error:
+            raise ValueError(f"{name} must broadcast to the sinogram shape") from error
+    return value
+
+
+def _cosine(sinogram, geometry, pitch):
+    """Detector-normal cosine from actual per-view rays, including offsets."""
+    source, detector, axis_u = geometry[:3]
+    vector = detector - source
+    if sinogram.ndim == 2:
+        normal = torch.stack((-axis_u[:, 1], axis_u[:, 0]), dim=1)
+    else:
+        normal = torch.linalg.cross(axis_u, geometry[3], dim=1)
+    normal = F.normalize(normal, dim=1)
+    distance = (vector * normal).sum(1).abs()
+    u = (torch.arange(sinogram.shape[1], device=sinogram.device, dtype=sinogram.dtype)
+         - (sinogram.shape[1] - 1) / 2) * pitch[0]
+    offset_u = (vector * axis_u).sum(1)
+    u = u[None, :] + offset_u[:, None]
+    if sinogram.ndim == 2:
+        return distance[:, None] / torch.sqrt(distance[:, None].square() + u.square())
+    v = (torch.arange(sinogram.shape[2], device=sinogram.device, dtype=sinogram.dtype)
+         - (sinogram.shape[2] - 1) / 2) * pitch[1]
+    offset_v = (vector * geometry[3]).sum(1)
+    v = v[None, :] + offset_v[:, None]
+    return distance[:, None, None] / torch.sqrt(
+        distance[:, None, None].square() + u[:, :, None].square() + v[:, None, :].square())
+
+
+def _filter(sinogram, pitch, window, pad_factor, response):
+    if isinstance(pad_factor, bool) or not isinstance(pad_factor, numbers.Integral) or pad_factor < 2:
+        raise ValueError("pad_factor must be an integer >=2 for analytical reconstruction")
+    if response is None:
+        return ramp_filter_1d(sinogram, dim=1, sample_spacing=pitch,
+                              pad_factor=pad_factor, window=window)
+    n_u = sinogram.shape[1]
+    fft_size = pad_factor * n_u
+    response = _weights(response, sinogram, "filter_response", (fft_size // 2 + 1,))
+    left = (fft_size - n_u) // 2
+    right = fft_size - n_u - left
+    padded = F.pad(sinogram, (0, 0, left, right) if sinogram.ndim == 3 else (left, right))
+    broadcast = (1, len(response)) + (1,) * (sinogram.ndim - 2)
+    filtered = torch.fft.irfft(torch.fft.rfft(padded, dim=1) * response.reshape(broadcast),
+                               n=fft_size, dim=1)
+    return filtered.narrow(1, left, n_u)
+
+
+def _parker(angles, sinogram, geometry, pitch, isocenter, geometry_eps):
+    source, detector, u = geometry[:3]
+    vector = detector - source
+    normal = (torch.stack((-u[:, 1], u[:, 0]), dim=1) if sinogram.ndim == 2
+              else torch.linalg.cross(u, geometry[3], dim=1))
+    normal = F.normalize(normal, dim=1)
+    normal = torch.where(((vector * normal).sum(1) < 0)[:, None], -normal, normal)
+    distance = (vector * normal).sum(1).abs()
+    offset = (vector * u).sum(1)
+    # Preserve each input's quantization after _prepare promotes the geometry.
+    # Eight eps covers coordinate rounding, subtraction, projection and a
+    # comparison between two views; its physical scale also covers translation.
+    coordinate_scale = float(torch.linalg.vector_norm(
+        source.double().abs() + detector.double().abs(), dim=1).max())
+    arithmetic_eps = torch.finfo(source.dtype).eps
+    # V participates in the cone normal/distance, but never the U-offset dot.
+    distance_precision = max((arithmetic_eps, *geometry_eps))
+    offset_precision = max((arithmetic_eps, *geometry_eps[:3]))
+    distance_tolerance = max(1e-5, 8 * distance_precision * coordinate_scale)
+    offset_tolerance = max(1e-5, 8 * offset_precision * coordinate_scale)
+    if not (torch.allclose(distance, distance[:1].expand_as(distance), rtol=1e-4, atol=distance_tolerance)
+            and torch.allclose(offset, offset[:1].expand_as(offset), rtol=1e-4, atol=offset_tolerance)):
+        raise ValueError("Parker short-scan weighting requires constant detector distance and offset")
+    sdd, offset_u = float(distance[0]), float(offset[0])
+    gamma_max = math.atan(((sinogram.shape[1] - 1) * pitch[0] / 2 + abs(offset_u)) / sdd)
+    span = float(angles.max() - angles.min())
+    if span < math.pi + 2 * gamma_max - 1e-5:
+        raise ValueError("short scan must cover at least pi + twice the maximum fan angle")
+    if not (torch.all(angles[1:] > angles[:-1]) or torch.all(angles[1:] < angles[:-1])):
+        raise ValueError("Parker short-scan angles must be strictly monotone")
+
+    center, _, _ = _analytical_geometry(source, detector, normal, isocenter)
+    radial = (source - center).double()
+    radius = torch.linalg.vector_norm(radial, dim=1)
+    if (not torch.allclose(radius, radius[:1].expand_as(radius), rtol=1e-4, atol=1e-5)
+            or not torch.allclose(normal.double(), -F.normalize(radial, dim=1), rtol=1e-4, atol=1e-5)):
+        raise ValueError("Parker weighting requires a circular orbit with radial detector normals")
+    delta = angles.double() - angles[0].double()
+    cosine, sine = delta.cos(), delta.sin()
+    index = int(sine.abs().argmax())
+    if abs(float(sine[index])) < 1e-4:
+        raise ValueError("Parker weighting needs circular views that define the orbit orientation")
+    tangent = (radial[index] - radial[0] * cosine[index]) / sine[index]
+    predicted = radial[0] * cosine[:, None] + tangent * sine[:, None]
+    if (not torch.allclose(predicted, radial, rtol=1e-4, atol=1e-5)
+            or not torch.allclose(tangent.norm(), radius[0], rtol=1e-4, atol=1e-5)):
+        raise ValueError("Parker weighting requires angles matching a circular orbit")
+    # The detector u axis points opposite the source tangent for the scalar
+    # Parker helper's convention. Derive its sign from the actual orbit, so a
+    # detector-axis mirror plus a data-bin mirror leaves reconstruction intact.
+    expected_u = F.normalize(radial[0] * sine[:, None] - tangent * cosine[:, None], dim=1)
+    handedness = (expected_u * u.double()).sum(1)
+    if not torch.allclose(handedness.abs(), torch.ones_like(handedness), rtol=1e-4, atol=1e-5):
+        raise ValueError("Parker weighting requires detector u tangent to the circular orbit")
+    if not (torch.all(handedness > 0) or torch.all(handedness < 0)):
+        raise ValueError("Parker weighting requires consistent detector-u orientation")
+    direction = 1 if angles[-1] > angles[0] else -1
+    fan_sign = direction * (1 if handedness[0] > 0 else -1)
+    weights = parker_weights(delta * direction, sinogram.shape[1], pitch[0], sdd,
+                              detector_offset=fan_sign * offset_u)
+    if fan_sign < 0:
+        weights = weights.flip(1)
+    return weights[..., None] if sinogram.ndim == 3 else weights
+
+
+def _pipeline(sinogram, geometry, angles, beam, pitch, window, pad_factor,
+              projection_weights, angular_weights, filter_response, short_scan, isocenter,
+              geometry_eps):
+    if short_scan and beam == "parallel":
+        raise ValueError("Parker short-scan weights apply to fan or cone beams, not parallel")
+    if projection_weights is None:
+        weighted = sinogram if beam == "parallel" else sinogram * _cosine(sinogram, geometry, pitch)
+    else:
+        weighted = sinogram * _weights(projection_weights, sinogram, "projection_weights")
+    if short_scan:
+        weighted = weighted * _parker(angles, sinogram, geometry, pitch, isocenter, geometry_eps)
+    filtered = _filter(weighted, pitch[0], window, pad_factor, filter_response)
+    relative_angles = angles.double() - angles[0].double()
+    angular = (angular_integration_weights(relative_angles) if angular_weights is None
+               else _weights(angular_weights, sinogram, "angular_weights", (len(angles),)))
+    return filtered * angular.reshape((len(angles),) + (1,) * (sinogram.ndim - 1))
+
+
+def fbp(sinogram, trajectory, volume_shape, angles, *, beam="parallel",
+        detector_spacing=1.0, voxel_spacing=1.0, window="ram-lak", pad_factor=2,
+        projection_weights=None, angular_weights=None, filter_response=None,
+        short_scan=False, isocenter=None):
+    """Differentiable parallel/fan FBP for fixed flat-detector geometry.
+
+    ``sinogram`` is a CUDA tensor ``(views, bins)``; ``volume_shape`` is ``(H,W)``.
+    ``angles`` are explicit unwrapped radians. Detector/voxel spacings share the
+    trajectory's physical unit. ``projection_weights`` and ``angular_weights``
+    replace the default cosine and angular quadrature, respectively.
+    ``filter_response`` replaces the complete real rFFT multiplier, including
+    its physical units; length is ``pad_factor*bins//2+1``. Its use ignores
+    ``window``. These tensors retain autograd. ``short_scan=True`` adds Parker
+    weighting before filtering for a circular fan scan with sufficient coverage.
+    Low-precision inputs are promoted to float32 for reconstruction, retaining
+    gradients to their original dtype. Output is signed float32; geometry
+    gradients are rejected.
+    """
+    if beam not in ("parallel", "fan"):
+        raise ValueError("fbp beam must be 'parallel' or 'fan'; use fdk for cone data")
+    sinogram, geometry, shape, pitch, spacing = _prepare(
+        sinogram, trajectory, volume_shape, beam, detector_spacing, voxel_spacing, isocenter)
+    angles = _angles(angles, len(geometry[0]), sinogram.device)
+    filtered = _pipeline(sinogram, geometry, angles, beam, pitch, window, pad_factor,
+                         projection_weights, angular_weights, filter_response, short_scan, isocenter,
+                         tuple(torch.finfo(component.dtype).eps for component in trajectory))
+    if beam == "parallel":
+        return parallel_weighted_backproject(filtered, *geometry, pitch[0], *shape, spacing)
+    return fan_weighted_backproject(filtered, *geometry, pitch[0], *shape, spacing, isocenter=isocenter)
+
+
+def fdk(sinogram, trajectory, volume_shape, angles, *, detector_spacing=1.0,
+        voxel_spacing=1.0, window="ram-lak", pad_factor=2,
+        projection_weights=None, angular_weights=None, filter_response=None,
+        short_scan=False, isocenter=None):
+    """Differentiable flat-detector FDK; fixed geometry, approximate inversion.
+
+    ``sinogram`` is ``(views,U,V)`` on CUDA; ``volume_shape`` is ``(D,H,W)``.
+    Filtering runs along U. ``detector_spacing`` is a scalar or ``(du,dv)``.
+    The explicit weight/filter overrides and ``short_scan`` follow :func:`fbp`.
+    Returns signed float32 without clamping. The backward pass is the precise
+    discrete interpolation transpose; it does not make FDK an exact inverse.
+    Use :func:`helical_fdk` for slice-centered integration of an axial helix.
+    """
+    sinogram, geometry, shape, pitch, spacing = _prepare(
+        sinogram, trajectory, volume_shape, "cone", detector_spacing, voxel_spacing, isocenter)
+    angles = _angles(angles, len(geometry[0]), sinogram.device)
+    filtered = _pipeline(sinogram, geometry, angles, "cone", pitch, window, pad_factor,
+                         projection_weights, angular_weights, filter_response, short_scan, isocenter,
+                         tuple(torch.finfo(component.dtype).eps for component in trajectory))
+    return cone_weighted_backproject(filtered, *geometry, *shape, *pitch, spacing, isocenter=isocenter)
+
+
+def helical_view_weights(angles, source_z, slice_z):
+    """Return ``(slices,views)`` weights for complete slice-centered turns.
+
+    ``angles`` are strictly monotone, unwrapped radians; ``source_z`` is the
+    corresponding strictly monotone source height, with at least two samples.
+    ``slice_z`` holds physical slice centers. Reversed acquisitions are valid.
+    Interpolate the angle at each height, then integrate angular sample cells
+    over the centered ``2*pi`` interval. Weights include the half redundancy
+    factor and sum to pi. Missing coverage raises instead of renormalizing.
+    These acquisition coordinates are fixed; learn replacement weights instead.
+    """
+    for value, name in ((angles, "angles"), (source_z, "source_z"), (slice_z, "slice_z")):
+        _fixed(value, name)
+    angles = torch.as_tensor(angles)
+    if not torch.is_floating_point(angles) or angles.ndim != 1 or len(angles) < 2:
+        raise ValueError("angles must be a real vector with at least two views")
+    output_dtype = angles.dtype
+    source_z = torch.as_tensor(source_z, device=angles.device, dtype=torch.float64)
+    slice_z = torch.as_tensor(slice_z, device=angles.device, dtype=torch.float64)
+    if (source_z.shape != angles.shape or slice_z.ndim != 1 or len(slice_z) == 0
+            or not all(torch.isfinite(t).all() for t in (angles, source_z, slice_z))):
+        raise ValueError("angles/source_z must match and slice_z must be a finite vector")
+    for value, name in ((angles, "angles"), (source_z, "source_z")):
+        differences = value[1:] - value[:-1]
+        if not (torch.all(differences > 0) or torch.all(differences < 0)):
+            raise ValueError(f"{name} must be strictly monotone; use circular fdk for zero pitch")
+    # Compute interval arithmetic relative to the first angle in float64. A
+    # large absolute angle must neither erase pi nor widen the coverage guard.
+    angles = angles.double() - angles[0].double()
+    source_z, slice_z = source_z.double(), slice_z.double()
+    ordered, order = angles.sort()
+    heights = source_z[order]
+    heights, z_order = heights.sort()
+    angle_at_z = ordered[z_order]
+    if torch.any(slice_z < heights[0]) or torch.any(slice_z > heights[-1]):
+        raise ValueError("Source heights do not cover the requested slices")
+    upper = torch.searchsorted(heights, slice_z).clamp(1, len(heights) - 1)
+    fraction = (slice_z - heights[upper - 1]) / (heights[upper] - heights[upper - 1])
+    center = angle_at_z[upper - 1] + fraction * (angle_at_z[upper] - angle_at_z[upper - 1])
+    lower, upper_angle = center - math.pi, center + math.pi
+    # Output rounding must not relax the acquired-window coverage contract.
+    precision = min(torch.finfo(output_dtype).eps, torch.finfo(torch.float32).eps)
+    tolerance = 8 * precision * max(1.0, float(ordered[-1] - ordered[0]))
+    if torch.any(lower < ordered[0] - tolerance) or torch.any(upper_angle > ordered[-1] + tolerance):
+        raise ValueError("Every reconstructed slice needs a fully acquired 2*pi angular window")
+    # Clip Voronoi integration cells, including fractional boundary cells.
+    # Their union is the acquired interval. Missing views are never normalized.
+    edges = torch.cat((ordered[:1], (ordered[:-1] + ordered[1:]) / 2, ordered[-1:]))
+    overlap = (torch.minimum(edges[1:][None, :], upper_angle[:, None])
+               - torch.maximum(edges[:-1][None, :], lower[:, None])).clamp_min(0) * 0.5
+    weights = torch.empty_like(overlap)
+    weights[:, order] = overlap
+    return weights.to(output_dtype)
+
+
+def _axial_helix(geometry, isocenter):
+    _fixed(isocenter, "isocenter")
+    source, detector, u, v = geometry
+    center = torch.as_tensor(isocenter, device=source.device, dtype=source.dtype)
+    if center.shape != (3,) or not torch.isfinite(center).all():
+        raise ValueError("isocenter must be a finite physical (x,y,z) vector")
+    radial = source[:, :2] - center[:2]
+    radius = torch.linalg.vector_norm(radial, dim=1)
+    if torch.any(radius <= 0) or not torch.allclose(radius, radius[:1].expand_as(radius), rtol=1e-4, atol=1e-5):
+        raise ValueError("helical FDK requires a constant source radius about isocenter")
+    if (not torch.allclose(u[:, 2], torch.zeros_like(u[:, 2]), atol=1e-5)
+            or not torch.allclose(v[:, :2], torch.zeros_like(v[:, :2]), atol=1e-5)
+            or not torch.allclose(source[:, 2], detector[:, 2], rtol=1e-4, atol=1e-5)):
+        raise ValueError("helical FDK requires an axial helix and an untilted vertical detector")
+    normal = F.normalize(torch.linalg.cross(u, v), dim=1)
+    align = ((detector - source) * normal).sum(1)
+    normal = torch.where(align[:, None] < 0, -normal, normal)
+    if not torch.allclose(normal[:, :2], -radial / radius[:, None], rtol=1e-4, atol=1e-5):
+        raise ValueError("helical FDK requires radial detector normals")
+    dz = source[1:, 2] - source[:-1, 2]
+    if len(dz) == 0 or not (torch.all(dz > 0) or torch.all(dz < 0)):
+        raise ValueError("helical source heights must be strictly monotone; use circular fdk for zero pitch")
+    return center
+
+
+def helical_weighted_backproject(sinogram, trajectory, volume_shape, view_weights,
+                                *, isocenter, detector_spacing=1.0,
+                                voxel_spacing=1.0):
+    """Gather filtered cone data using replaceable ``(D,views)`` weights.
+
+    ``sinogram`` is a filtered CUDA ``(views,U,V)`` tensor. ``view_weights``
+    includes angular quadrature and redundancy and is applied AFTER filtering.
+    Gradients flow to both tensors through the discrete cone-gather transpose.
+    Fixed axial geometry, constant source radius and radial flat detectors are
+    required. Caller-supplied weights own their angular coverage and truncation.
+    One slice is processed per launch, avoiding a views-by-volume weight array;
+    a fused slice-weight kernel can replace this if launch overhead dominates.
+    """
+    sinogram, geometry, shape, pitch, spacing = _prepare(
+        sinogram, trajectory, volume_shape, "cone", detector_spacing, voxel_spacing, isocenter)
+    center = _axial_helix(geometry, isocenter)
+    weights = _weights(view_weights, sinogram, "view_weights", (shape[0], len(geometry[0])))
+    slices = []
+    # One launch per slice; fuse slice weights if measured launch overhead
+    # dominates. Preserve ordinary PyTorch weight gradients here.
+    for index in range(shape[0]):
+        z = (index + 0.5 - shape[0] / 2) * spacing
+        shift = sinogram.new_tensor((0, 0, z))
+        source, detector, u, v = geometry
+        weighted = sinogram * weights[index, :, None, None]
+        plane = cone_weighted_backproject(
+            weighted, source - shift, detector - shift, u, v,
+            1, shape[1], shape[2], *pitch, spacing, isocenter=center - shift)
+        slices.append(plane[0])
+    return torch.stack(slices)
+
+
+def helical_fdk(sinogram, trajectory, volume_shape, angles, *, isocenter,
+                detector_spacing=1.0, voxel_spacing=1.0, window="ram-lak",
+                pad_factor=2, projection_weights=None, view_weights=None,
+                filter_response=None):
+    """Approximate axial helical FDK with one complete angular turn per slice.
+
+    Filters detector U once, then applies :func:`helical_view_weights` inside
+    the analytical gather. ``isocenter`` is required in physical coordinates.
+    Source heights and unwrapped ``angles`` must agree with the actual helix;
+    finite scans must cover a full turn around every requested slice.
+    ``view_weights`` replaces the complete ``(D,views)`` window/quadrature stage.
+    Projection/filter replacements follow :func:`fbp`. Custom tensors retain
+    autograd and are not normalized or clamped. Detector truncation is not
+    corrected. This native-cone approximation does not implement cone-parallel
+    rebinning, 3D conjugate weights or exact Katsevich inversion.
+    """
+    sinogram, geometry, shape, pitch, spacing = _prepare(
+        sinogram, trajectory, volume_shape, "cone", detector_spacing, voxel_spacing, isocenter)
+    center = _axial_helix(geometry, isocenter)
+    angles = _angles(angles, len(geometry[0]), sinogram.device)
+    relative = geometry[0][:, :2] - center[:2]
+    observed = torch.atan2(-relative[:, 0], relative[:, 1])
+    phase = observed.double() - angles.double()
+    if not torch.allclose(torch.cos(phase - phase[0]), torch.ones_like(phase), rtol=0, atol=1e-5):
+        raise ValueError("angles must describe the source's actual unwrapped rotation")
+    if view_weights is None:
+        z = (torch.arange(shape[0], device=sinogram.device, dtype=torch.float64)
+             + 0.5 - shape[0] / 2) * spacing
+        view_weights = helical_view_weights(angles, geometry[0][:, 2], z)
+    else:
+        # Still validate the acquired order when a caller replaces the windows.
+        difference = angles[1:] - angles[:-1]
+        if not (torch.all(difference > 0) or torch.all(difference < 0)):
+            raise ValueError("helical angles must be strictly monotone")
+    weighted = (sinogram * _cosine(sinogram, geometry, pitch) if projection_weights is None
+                else sinogram * _weights(projection_weights, sinogram, "projection_weights"))
+    filtered = _filter(weighted, pitch[0], window, pad_factor, filter_response)
+    return helical_weighted_backproject(filtered, geometry, shape, view_weights,
+                                        isocenter=center, detector_spacing=pitch, voxel_spacing=spacing)

{diffct-2.2.0.dist-info → diffct-2.2.1.dist-info}/METADATA

@@ -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.dist-info → diffct-2.2.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-diffct/__init__.py,sha256=iK4fsfSPKVumWh4UviojwgMYg0Jav_Ha8t6j3LUCx20,2340
-diffct/analytical.py,sha256=cDJFMJOYzSaHLr9TUkiKtu5R6TR2d9b7GPZnCI48-VY,25206
+diffct/__init__.py,sha256=megkY4RH88JkBLvG24tSJizwAfyCSoO_Qb3ZLsR1o8g,2572
+diffct/analytical.py,sha256=_utt7n9dxR-D11NJuQ2wjI-9Fd5J62rm9AzMyB-fTpk,32318
 diffct/chunking.py,sha256=Ny7_QCGQDpNlQQAJQ_Y8XnTK3dvVWLt-U0GUozqC2Wg,9485
 diffct/constants.py,sha256=IKC_0u9aoNCG4M13KcRrl2plO0dTiokac-2aCYJJMb4,3060
 diffct/differentiable.py,sha256=cFirhqXRpUemL7y7Sl_0uqZKGJNj__ptQEcTwYNKzys,1879
@@ -7,17 +7,19 @@ diffct/geometry.py,sha256=ZFXqrn2b1kmwzlXqDFGHPVOhHkuAsjRuFbUF8slnOYQ,38154
 diffct/operators.py,sha256=Ia-WCK1L6O77bIcOiuLFXnq10jWoMvb5LbyivmWHViQ,118162
 diffct/pipeline.py,sha256=jp7AvDeQQOME3OPkO9XTcjWFLvOLrv8wczhAf1jcklM,10891
 diffct/projectors.py,sha256=xrPtQWQwVCrUovAXZX82q4J_RxCURZffF4GQ0ua_2sY,42520
+diffct/reconstruction.py,sha256=I546L5bNigSb39oOHSJtRZeslI8fleNSBv7w-iGd994,23484
 diffct/storage.py,sha256=EdcFTzRtEAPRvAZhRPrSf8gRNF5o_JVbPLE8eKPhNdY,4153
 diffct/streaming.py,sha256=EjHOQd5RECMl2QLYyqEARwUzzrUAyEaFsCv5UFUjWSo,2380
 diffct/surfaces.py,sha256=OYVju0urcF8SzTkbGF-BJQrYZw1YjieYwCWH5ziypn8,5155
 diffct/utils.py,sha256=S-87F7z4AcxajtLbxIXlkLd7esE5ISncsBEwAFDIxQs,14648
-diffct/kernels/__init__.py,sha256=PhdgiZEyPzdnJ6tVmX6zzUvQH4EESwW8rfC_jCTlzhU,1106
+diffct/kernels/__init__.py,sha256=QPA-d6Mg1ZAaOiqjLYGxuRyPtt9C5IhN0kyyxC739_w,1366
+diffct/kernels/analytical_transpose.py,sha256=D4vr_ZFPrjFeQyhoDqTyijbkTY-g-sHJet52ho-cbkQ,9187
 diffct/kernels/cone_beam.py,sha256=Y17Yeb8qhUXDoiRPk6s3xQJChG4uHk7L7aBVf5VQXo8,25400
 diffct/kernels/fan_beam.py,sha256=J3Oj3LXEOcTSaB0pBf7tne_itqBJSgAPH3CmRtgCOCg,17068
 diffct/kernels/geometry_vjp.py,sha256=rv2v8QqCDEtMollYAOBiyVA6w8BhUV9Wl0UBsQnmNCk,20907
 diffct/kernels/parallel_beam.py,sha256=tCiSx9W8nO4mn8DVyRuK4E0Ry8q38g3pAUACab0UYVU,17143
-diffct-2.2.0.dist-info/METADATA,sha256=pWkEDbnmptbrtZH1XlgS6Zv0F6uvD83Y-VQ-1sljOZE,15638
-diffct-2.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-diffct-2.2.0.dist-info/licenses/LICENSE,sha256=a1fjzGs44LpDnV_LmA2Tzp8z-eJKoNVVdLOnh-F6J6E,11344
-diffct-2.2.0.dist-info/licenses/NOTICE,sha256=du9I2sDF5IDfiY9vF64WWzMJh-MarpVXyLfWQmhbvmI,714
-diffct-2.2.0.dist-info/RECORD,,
+diffct-2.2.1.dist-info/METADATA,sha256=gwqjaVILUAR3Mh90hHrg9s7Y4GdlGbFwW4xWpo1htP8,15905
+diffct-2.2.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+diffct-2.2.1.dist-info/licenses/LICENSE,sha256=a1fjzGs44LpDnV_LmA2Tzp8z-eJKoNVVdLOnh-F6J6E,11344
+diffct-2.2.1.dist-info/licenses/NOTICE,sha256=du9I2sDF5IDfiY9vF64WWzMJh-MarpVXyLfWQmhbvmI,714
+diffct-2.2.1.dist-info/RECORD,,