diffct 1.2.10__tar.gz → 1.2.11__tar.gz

diffct-1.2.11/CHANGELOG.md

@@ -0,0 +1,225 @@
+# Changelog
+
+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]
+
+## [1.2.11] - 2026-04-14
+
+### Added
+- **Parker short-scan demos** in `examples/fdk_cone.py` and `examples/fbp_fan.py`.
+  Both examples now expose an `apply_parker` switch that not only multiplies
+  by `parker_weights` but also samples angles on the minimal short-scan range
+  `pi + 2*gamma_max`, where `gamma_max` is computed from the detector half-width
+  and `sdd`. (Before this change the `apply_parker` flag in `fbp_fan.py` was
+  silently a no-op because the angular range stayed at `2*pi`.)
+- **`tests/test_gradcheck.py`** — `torch.autograd.gradcheck` coverage for
+  `ParallelProjectorFunction`, `FanProjectorFunction`, and `ConeProjectorFunction`.
+  Compares the analytical backward Jacobian to a finite-difference numerical
+  Jacobian over small inputs with float32-calibrated tolerances. Strongest
+  autograd-correctness guard beyond the existing inner-product adjoint tests.
+- **`tests/test_ramp_filter_windows.py`** — 27 parametrised tests covering every
+  `ramp_filter_1d` window option (`None`/`"ram-lak"`, `"hann"`, `"hanning"`,
+  `"hamming"`, `"cosine"`, `"shepp-logan"`) at three layers: direct `_ramp_window`
+  helper (DC gain, Nyquist value, monotonicity), full `ramp_filter_1d` end-to-end
+  (shape, DC annihilation, pad correctness, rfft vs complex-fft parity,
+  `sample_spacing` scaling), and a high-frequency attenuation sanity check on a
+  step input.
+- **`CHANGELOG.md`** — new Keep-a-Changelog file at the repo root.
+- **`tests/benchmarks/`** — opt-in `pytest-benchmark` suite covering every CUDA
+  kernel in the library (forward projector, pure-adjoint backprojector, and
+  analytical FBP/FDK pipeline) across three sizes for each of the three
+  geometries. 27 benchmarks total. Excluded from the default `pytest tests/`
+  run via `--ignore=tests/benchmarks` in `pytest.ini` so the normal test suite
+  stays fast; run explicitly with `pytest tests/benchmarks/ --benchmark-only`.
+  Enables before/after perf comparisons via `--benchmark-save=` /
+  `--benchmark-compare=`.
+
+### Changed
+- **`_cone_3d_fdk_backproject_kernel`** memory-access layout. The kernel now
+  unpacks `cuda.grid(3)` as `(iz, iy, ix)` instead of `(ix, iy, iz)`, and
+  `cone_weighted_backproject` launches the grid as `_grid_3d(D, H, W)` instead
+  of `_grid_3d(W, H, D)`. This makes `iz` warp-adjacent, which matches the
+  innermost stride-1 axis of the WHD output buffer, so the final `d_vol` write
+  becomes coalesced. Measured speedup on a 64^3–160^3 sweep: 1.0x–1.14x,
+  within run-to-run noise (the kernel is read-bound on the sinogram bilinear
+  samples, not write-bound, so L2 absorbed the old uncoalesced writes). The
+  fix is kept as the right default and future-proofs the kernel against
+  edits that shift work toward the write path. Matching coalescing comments
+  were added to the 2D `_parallel_2d_fbp_backproject_kernel` and
+  `_fan_2d_fbp_backproject_kernel` kernels, which were already coalesced
+  (their first grid index is also warp-adjacent and matches the `Nx` innermost
+  axis of their `(Ny, Nx)` output buffers).
+
+### Notes
+- No public-API changes. Pure-adjoint kernels and autograd Function classes
+  are untouched, so the autograd and iterative-reconstruction paths are
+  byte-for-byte equivalent to 1.2.10.
+
+## [1.2.10] - 2026-04-14
+
+This release is a correctness overhaul of every analytical reconstruction path
+(parallel / fan / cone) **and** of the autograd adjoint path shared by the
+iterative examples. It also ships a unified architecture where each geometry
+has its own dedicated voxel-driven FBP/FDK gather kernel, separate from the
+pure Siddon adjoint used by autograd.
+
+### Fixed
+
+#### Analytical FBP / FDK amplitude bugs
+
+Prior to this release, all three analytical reconstruction examples produced
+results that were off by large constant factors:
+
+| Example | Pre-fix reco range | Post-fix reco range | MSE improvement |
+|---|---|---|---|
+| `fbp_parallel.py` | [0, 6.52] | [−0.02, 1.01] | ~580× |
+| `fbp_fan.py` | [0, 6.33] | [−0.08, 1.01] | ~900× |
+| `fdk_cone.py` | [0, 10.08] | [−0.08, 1.00] | ~600× |
+
+Root causes:
+- Cone and fan used `(sdd/U)^2` with `U = sdd + x·sin − y·cos` instead of
+  the correct FDK weight `(sid/U)^2` with `U = sid + x·sin − y·cos`.
+- All three geometries were missing the `1/(2π)` Fourier-convention
+  constant from the FBP/FDK reconstruction formula.
+- Cone and fan used a Siddon ray-driven scatter for the analytical path,
+  which is neither a true adjoint nor a classical FBP/FDK gather.
+
+#### Autograd adjoint bug (cone + fan)
+
+`ConeProjectorFunction.backward`, `ConeBackprojectorFunction.forward`,
+`FanProjectorFunction.backward` and `FanBackprojectorFunction.forward`
+were all passing `distance_weight=1.0` to the shared Siddon backward
+kernel. This meant the autograd backward was **not the true adjoint** `P^T`
+of the forward projector — it had a `(sdd/U)^2` per-voxel factor baked in,
+biasing the gradient by ~2–3× depending on voxel position. Any iterative
+reconstruction that relied on autograd (including `iterative_reco_cone.py`
+and `iterative_reco_fan.py`) was running on a biased gradient flow.
+
+Parallel beam was unaffected (its backward kernel had no `distance_weight`
+parameter to begin with).
+
+This release removes the `distance_weight` parameter from both
+`_cone_3d_backward_kernel` and `_fan_2d_backward_kernel` entirely, so the
+dead code path cannot be accidentally reintroduced, and fixes the four
+autograd call sites to use the pure adjoint.
+
+### Added
+
+#### Voxel-driven gather kernels for every geometry
+
+Three new CUDA kernels, all under a dedicated `fastmath=False` decorator
+for FDK-grade accuracy:
+
+- `_parallel_2d_fbp_backproject_kernel` — no distance weighting (no source).
+- `_fan_2d_fbp_backproject_kernel` — `(sid/U)^2` + linear detector interp.
+- `_cone_3d_fdk_backproject_kernel` — `(sid/U)^2` + bilinear detector interp.
+
+Each kernel is voxel-driven: one thread per output pixel/voxel, loops over
+views, computes the projected detector coordinate, interpolates the filtered
+sinogram, weights and accumulates.
+
+#### `parallel_weighted_backproject` (new public helper)
+
+Mirrors `fan_weighted_backproject` and `cone_weighted_backproject`. Applies
+the `1/(2π)` Fourier-convention constant so a unit-density disk reconstructs
+to amplitude 1. Exported from `diffct`.
+
+#### `ramp_filter_1d` — new backward-compatible kwargs
+
+- `sample_spacing` (default `1.0`): physical detector cell pitch. Output is
+  rescaled by `1/sample_spacing` for physical-unit correctness.
+- `pad_factor` (default `1`): zero-pad to `pad_factor * N` before the FFT to
+  suppress circular-convolution wrap-around. `2` is recommended for FBP/FDK.
+- `window` (default `None`): frequency-domain apodization. Options: `None` /
+  `"ram-lak"`, `"hann"`, `"hamming"`, `"cosine"`, `"shepp-logan"`.
+- `use_rfft` (default `True`): faster real-FFT path for real-valued inputs.
+
+Existing `ramp_filter_1d(sino, dim=1)` calls keep working unchanged.
+
+#### Analytical FBP / FDK scale factors
+
+Each analytical helper now applies the correct analytical constant
+automatically so reconstructions are already amplitude-calibrated:
+
+- `parallel_weighted_backproject`: `1 / (2π)`.
+- `fan_weighted_backproject`: `sdd / (2π · sid)`.
+- `cone_weighted_backproject`: `sdd / (2π · sid)`.
+
+### Tests
+
+Test suite expanded from 6 to **27 tests**:
+
+- `tests/test_adjoint_inner_product.py` — the definitive check. For random `x`
+  and `y`, asserts `⟨A x, y⟩ = ⟨x, A^T y⟩` for parallel, fan and cone autograd
+  pairs. Permanently guards against any regression that would reintroduce the
+  `distance_weight=1.0` bug.
+- `tests/test_fdk_cone_accuracy.py` — 128³ Shepp-Logan RMSE / amplitude bounds.
+- `tests/test_fdk_cone_offsets.py` — detector, center and combined offsets with
+  amplitude assertions.
+- `tests/test_cone_projector_autograd.py` — gradient finiteness and non-zero
+  sanity.
+- `tests/test_fbp_fan_accuracy.py` — 256×256 Shepp-Logan RMSE.
+- `tests/test_fbp_fan_offsets.py` — three offset configurations.
+- `tests/test_fbp_parallel_accuracy.py` — parallel FBP RMSE + offset.
+
+### Examples
+
+`examples/fdk_cone.py`, `examples/fbp_fan.py` and `examples/fbp_parallel.py`
+have been rewritten with a consistent 8-step layout and detailed inline
+comments documenting every geometry variable (what it is, units, typical
+values, available options). Each example prints raw MSE, clamped MSE, and the
+reconstruction / phantom data ranges.
+
+The iterative reconstruction examples (`iterative_reco_parallel.py`,
+`iterative_reco_fan.py`, `iterative_reco_cone.py`) are unchanged — they
+silently benefit from the fixed autograd adjoint.
+
+### Documentation
+
+- `docs/source/api.rst`: adds autofunction entries for
+  `parallel_weighted_backproject`, documents the new `ramp_filter_1d`
+  options, and adds an "Analytical FBP / FDK architecture" section
+  explaining the scale-factor derivation.
+- `docs/source/fdk_cone_example.rst`: formula updated to reflect the
+  voxel-gather kernel and `(sid/U)^2` weight.
+- `docs/source/fbp_fan_example.rst` and `fbp_parallel_example.rst`: completely
+  rewritten to reference the new analytical helpers and fix a sign-convention
+  inconsistency in the math section.
+
+### Compatibility
+
+This release is source-compatible with 1.2.9 for every public entry point. The
+`distance_weight` parameter was internal and is removed from the private
+backward kernels; no public API touched that argument.
+
+## [1.2.9] - 2026-02-14
+
+Restored `main` to the state of 1.2.9 by reverting an accidental merge.
+See [GitHub release v1.2.9](https://github.com/sypsyp97/diffct/releases/tag/v1.2.9).
+
+## [1.2.8] - 2026-02-14
+
+See [GitHub release v1.2.8](https://github.com/sypsyp97/diffct/releases/tag/v1.2.8)
+and the commit history for details.
+
+## [1.2.7] - 2025-08-05
+
+See [GitHub release v1.2.7](https://github.com/sypsyp97/diffct/releases/tag/v1.2.7).
+
+## Earlier versions
+
+Releases 1.2.0 through 1.2.6 and the 1.1.x / 1.0.x lines are tracked on
+[GitHub releases](https://github.com/sypsyp97/diffct/releases). This CHANGELOG
+was introduced in 1.2.10 and does not back-fill detailed notes for earlier
+versions beyond pointers to the GitHub release pages.
+
+[Unreleased]: https://github.com/sypsyp97/diffct/compare/v1.2.11...HEAD
+[1.2.11]: https://github.com/sypsyp97/diffct/releases/tag/v1.2.11
+[1.2.10]: https://github.com/sypsyp97/diffct/releases/tag/v1.2.10
+[1.2.9]: https://github.com/sypsyp97/diffct/releases/tag/v1.2.9
+[1.2.8]: https://github.com/sypsyp97/diffct/releases/tag/v1.2.8
+[1.2.7]: https://github.com/sypsyp97/diffct/releases/tag/v1.2.7

{diffct-1.2.10 → diffct-1.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffct
-Version: 1.2.10
+Version: 1.2.11
 Summary: A CUDA-based library for computed tomography (CT) projection and reconstruction with differentiable operators
 Project-URL: Homepage, https://github.com/sypsyp97/diffct
 Author-email: Yipeng Sun <yipeng.sun@fau.de>

{diffct-1.2.10 → diffct-1.2.11}/diffct/differentiable.py

@@ -1570,8 +1570,35 @@ def _cone_3d_fdk_backproject_kernel(
     the central ray, and all ``*_offset_*`` values are already in voxel
     units at call time. Indices follow the existing permuted layout where
     ``ix`` marches along the W axis, ``iy`` along H and ``iz`` along D.
+
+    Memory-access layout note
+    -------------------------
+    Numba ``cuda.grid(3)`` returns ``(threadIdx.x+..., threadIdx.y+...,
+    threadIdx.z+...)`` in that order, so the FIRST element is the
+    warp-adjacent axis (lanes 0..31 span the first index). We deliberately
+    unpack as ``(iz, iy, ix)`` - not ``(ix, iy, iz)`` - so that ``iz``
+    becomes warp-adjacent. The output buffer ``d_vol`` has WHD layout
+    ``(W, H, D)``, row-major, which means its innermost stride-1 axis is
+    ``D`` (== ``iz``). With ``iz`` warp-adjacent, the 32 threads of a warp
+    write to ``d_vol[ix, iy, iz..iz+31]`` - 32 consecutive float32 cells,
+    one coalesced transaction per warp. The sinogram reads
+    ``d_sino[iview, iu, iv]`` are also coalesced because ``iv`` varies
+    linearly with ``iz`` (``v_det = z_v * sdd/U``) and ``d_sino`` has its
+    innermost stride-1 axis on ``iv``, so a warp's ``fv`` values span a
+    handful of adjacent ``iv`` bins. Matching this ordering, the Python
+    wrapper launches the grid as ``_grid_3d(D, H, W)``.
+
+    Expected performance impact of this layout is *small*: the kernel
+    does ~4 sinogram loads per view per output voxel but only ONE write
+    at the end, so total memory traffic is overwhelmingly read-bound and
+    the L2 easily absorbs any stray write transactions. An A/B
+    benchmark of the old ``ix``-first layout versus this ``iz``-first
+    layout measured ~1.0x to 1.14x speedup on 64^3..160^3 volumes - well
+    within run-to-run noise. We keep the coalesced layout anyway because
+    it is the right default and future kernel edits that shift work
+    toward the write path will benefit immediately without re-auditing.
     """
-    ix, iy, iz = cuda.grid(3)
+    iz, iy, ix = cuda.grid(3)
     if ix >= Nx or iy >= Ny or iz >= Nz:
         return
 
@@ -1681,6 +1708,17 @@ def _parallel_2d_fbp_backproject_kernel(
     filtered sinogram at that position, and accumulate. Cosine
     pre-weighting, ramp filtering and per-view integration weights are
     expected to already be baked into ``d_sino`` by the Python wrapper.
+
+    Memory-access layout note
+    -------------------------
+    Numba ``cuda.grid(2)`` returns ``(threadIdx.x+..., threadIdx.y+...)``
+    in that order, so the FIRST element is the warp-adjacent axis. We
+    unpack as ``(ix, iy)``, which puts ``ix`` on ``threadIdx.x``. The
+    output buffer has shape ``(Ny, Nx)`` row-major, whose innermost
+    stride-1 axis is ``Nx`` (== ``ix``). Writing ``d_image[iy, ix]`` is
+    therefore coalesced: the 32 threads of a warp write 32 consecutive
+    float32 cells in one transaction. The grid is launched as
+    ``_grid_2d(Nx, Ny)`` to match this ordering.
     """
     ix, iy = cuda.grid(2)
     if ix >= Nx or iy >= Ny:
@@ -1750,6 +1788,17 @@ def _fan_2d_fbp_backproject_kernel(
     geometry: source at ``(-sid_v*sin_a, sid_v*cos_a)`` relative to the
     isocenter, detector at distance SDD from the source perpendicular
     to the central ray, ``u`` on the detector is in-plane.
+
+    Memory-access layout note
+    -------------------------
+    Same coalescing pattern as the parallel FBP gather kernel above:
+    ``ix`` is on ``threadIdx.x`` (warp-adjacent), and the output buffer
+    ``(Ny, Nx)`` has ``Nx`` as its innermost stride-1 axis, so
+    ``d_image[iy, ix]`` writes 32 consecutive float32 cells per warp.
+    Sinogram reads ``d_sino[iang, idet0..idet0+1]`` also sweep through
+    a small span of the stride-1 detector axis as ``ix`` varies across
+    a warp, so they are approximately coalesced as well. Launch grid is
+    ``_grid_2d(Nx, Ny)``.
     """
     ix, iy = cuda.grid(2)
     if ix >= Nx or iy >= Ny:
@@ -3173,7 +3222,13 @@ def cone_weighted_backproject(
     d_cos_arr = TorchCUDABridge.tensor_to_cuda_array(d_cos)
     d_sin_arr = TorchCUDABridge.tensor_to_cuda_array(d_sin)
 
-    grid, tpb = _grid_3d(W, H, D)
+    # Launch grid is (D, H, W) to match the kernel's ``iz, iy, ix = cuda.grid(3)``
+    # unpack order. Numba puts the first grid dimension on ``threadIdx.x``
+    # (the warp-adjacent axis), so by putting D first we make ``iz``
+    # warp-adjacent, which matches the innermost stride-1 axis of the WHD
+    # output buffer - coalesced writes. See the memory-access note in the
+    # kernel docstring.
+    grid, tpb = _grid_3d(D, H, W)
     cx, cy, cz = _DTYPE(W * 0.5), _DTYPE(H * 0.5), _DTYPE(D * 0.5)
     det_offset_u_v = _DTYPE(detector_offset_u / voxel_spacing)
     det_offset_v_v = _DTYPE(detector_offset_v / voxel_spacing)

{diffct-1.2.10 → diffct-1.2.11}/examples/fbp_fan.py

@@ -78,21 +78,11 @@ def main():
     voxel_spacing = 1.0
 
     # ------------------------------------------------------------------
-    # 2. Source trajectory (circular orbit)
-    # ------------------------------------------------------------------
-    # ``num_angles`` samples on the circular orbit. This example uses a
-    # full 2*pi scan, uniformly sampled, with ``endpoint=False`` to
-    # avoid duplicating angle 0. For a short-scan geometry you would
-    # use an interval of length ``pi + 2*gamma_max`` and set
-    # ``apply_parker=True`` to enable Parker redundancy weighting.
-    num_angles = 360
-    angles_np = np.linspace(
-        0.0, 2.0 * math.pi, num_angles, endpoint=False
-    ).astype(np.float32)
-
-    # ------------------------------------------------------------------
-    # 3. Detector geometry
+    # 2. Detector geometry
     # ------------------------------------------------------------------
+    # (Listed before the trajectory so the short-scan coverage below can
+    # use the detector fan angle to compute ``pi + 2*gamma_max``.)
+    #
     # ``num_detectors`` is the number of detector cells along the
     # detector axis. ``detector_spacing`` is their physical pitch.
     # Make sure the detector is wide enough that no ray that intersects
@@ -114,14 +104,34 @@ def main():
     sdd = 800.0
     sid = 500.0
 
-    # Set to ``True`` for short-scan trajectories. When ``True``, the
-    # Parker weights are multiplied onto the raw sinogram before the
-    # cosine pre-weight, and ``redundant_full_scan=False`` is passed
-    # to the angular integration weights (the FBP 1/2 factor that
-    # corrects for 2*pi redundancy is dropped since Parker already
-    # handles redundancy).
+    # ------------------------------------------------------------------
+    # 3. Source trajectory (circular orbit)
+    # ------------------------------------------------------------------
+    # ``apply_parker`` selects between two supported trajectories:
+    #
+    #   False -> full 2*pi scan, 1/2 FBP redundancy factor absorbed
+    #            inside ``redundant_full_scan=True``.
+    #
+    #   True  -> minimal short scan ``pi + 2*gamma_max`` with Parker
+    #            redundancy weighting. ``gamma_max`` is computed from
+    #            the detector half-width and ``sdd``.
+    #
+    # Both branches reuse the same ``num_angles`` so reconstruction
+    # runtime stays identical - only the angular *range* changes.
     apply_parker = False
 
+    if apply_parker:
+        u_max = ((num_detectors - 1) * 0.5) * detector_spacing + abs(detector_offset)
+        gamma_max = math.atan(u_max / sdd)
+        scan_range = math.pi + 2.0 * gamma_max
+    else:
+        scan_range = 2.0 * math.pi
+
+    num_angles = 360
+    angles_np = np.linspace(
+        0.0, scan_range, num_angles, endpoint=False
+    ).astype(np.float32)
+
     # ------------------------------------------------------------------
     # 4. Move everything to CUDA
     # ------------------------------------------------------------------
@@ -229,7 +239,8 @@ def main():
     raw_loss = torch.mean((reconstruction_raw - image_torch) ** 2)
     clamped_loss = torch.mean((reconstruction - image_torch) ** 2)
 
-    print("Fan Beam FBP example (circular full scan):")
+    scan_label = "Parker short scan" if apply_parker else "full 2*pi scan"
+    print(f"Fan Beam FBP example ({scan_label}):")
     print(f"  Raw MSE:              {raw_loss.item():.6f}")
     print(f"  Clamped MSE:          {clamped_loss.item():.6f}")
     print(f"  Reconstruction shape: {tuple(reconstruction.shape)}")

{diffct-1.2.10 → diffct-1.2.11}/examples/fdk_cone.py

@@ -27,6 +27,7 @@ from diffct.differentiable import (
     angular_integration_weights,
     cone_cosine_weights,
     cone_weighted_backproject,
+    parker_weights,
     ramp_filter_1d,
 )
 
@@ -115,26 +116,11 @@ def main():
     voxel_spacing = 1.0
 
     # ------------------------------------------------------------------
-    # 2. Source trajectory (circular orbit)
-    # ------------------------------------------------------------------
-    # ``num_views`` is the number of projection angles sampled on the
-    # circular orbit. More views generally mean smaller angular
-    # aliasing and a cleaner FDK reconstruction, at the cost of memory
-    # and runtime linear in ``num_views``.
-    num_views = 360
-
-    # Angles in radians. This example uses a full 2*pi scan sampled
-    # uniformly (``endpoint=False`` avoids duplicating angle 0). For a
-    # short-scan geometry you would use an interval of length
-    # ``pi + 2*gamma_max`` and feed the result through ``parker_weights``
-    # before the ramp filter.
-    angles_np = np.linspace(
-        0.0, 2.0 * math.pi, num_views, endpoint=False
-    ).astype(np.float32)
-
-    # ------------------------------------------------------------------
-    # 3. Detector geometry
+    # 2. Detector geometry
     # ------------------------------------------------------------------
+    # (Listed before the trajectory so the short-scan coverage below can
+    # use the detector fan angle to compute ``pi + 2*gamma_max``.)
+    #
     # ``det_u`` / ``det_v`` are the number of detector cells along the
     # u (in-plane / horizontal) and v (axial / vertical) directions.
     # ``du`` / ``dv`` are their physical spacings. Together they define
@@ -163,6 +149,50 @@ def main():
     sdd = 900.0
     sid = 600.0
 
+    # ------------------------------------------------------------------
+    # 3. Source trajectory (circular orbit)
+    # ------------------------------------------------------------------
+    # ``apply_parker`` selects between two supported trajectories:
+    #
+    #   False -> full 2*pi circular scan. Each ray is sampled twice
+    #            (once going one way, once the opposite), so the FDK
+    #            formula carries a 1/2 redundancy factor which is
+    #            absorbed by ``redundant_full_scan=True`` inside the
+    #            angular integration weights.
+    #
+    #   True  -> minimal short scan of length ``pi + 2*gamma_max``
+    #            where ``gamma_max = atan(u_max / sdd)`` is the maximum
+    #            fan angle. Every ray is sampled *at least once*, some
+    #            rays twice; the standard Parker window smoothly tapers
+    #            the duplicate regions so each ray's total contribution
+    #            integrates to pi (the same effective weight as the
+    #            full-scan case after the 1/2 redundancy factor), and
+    #            the angular weights use plain trapezoidal rule
+    #            (``redundant_full_scan=False``).
+    #
+    # Short scans are common on clinical C-arm and cone-beam systems
+    # where a full 2*pi rotation is mechanically impossible.
+    apply_parker = False
+
+    if apply_parker:
+        u_max = ((det_u - 1) * 0.5) * du + abs(detector_offset_u)
+        gamma_max = math.atan(u_max / sdd)
+        scan_range = math.pi + 2.0 * gamma_max
+    else:
+        scan_range = 2.0 * math.pi
+
+    # ``num_views`` is the number of projection angles sampled on the
+    # orbit. More views generally mean smaller angular aliasing and a
+    # cleaner FDK reconstruction, at the cost of memory and runtime
+    # linear in ``num_views``.
+    num_views = 360
+
+    # Angles in radians. ``endpoint=False`` avoids duplicating the start
+    # angle at the end of the sweep.
+    angles_np = np.linspace(
+        0.0, scan_range, num_views, endpoint=False
+    ).astype(np.float32)
+
     # ------------------------------------------------------------------
     # 4. Move everything to CUDA
     # ------------------------------------------------------------------
@@ -196,6 +226,25 @@ def main():
     # 6. FDK analytical reconstruction
     # ==================================================================
 
+    # --- 6.0  Optional Parker redundancy weighting -------------------
+    # ``parker_weights`` returns a ``(num_views, det_u)`` tensor that
+    # tapers rays in the redundantly-sampled regions of a short scan.
+    # For a full 2*pi scan it detects the coverage and returns all
+    # ones (no-op), so this branch is safe to run unconditionally; we
+    # gate it on ``apply_parker`` just for clarity.
+    #
+    # The returned weight depends on the in-plane fan angle only, so
+    # we broadcast it across the v (axial) direction via ``unsqueeze(-1)``.
+    if apply_parker:
+        parker = parker_weights(
+            angles_torch,
+            det_u,
+            du,
+            sdd,
+            detector_offset=detector_offset_u,
+        )
+        sinogram = sinogram * parker.unsqueeze(-1)
+
     # --- 6.1  Cosine pre-weight --------------------------------------
     # Multiplies each detector pixel by ``sdd / sqrt(sdd^2 + u^2 + v^2)``,
     # i.e. the cosine of the cone angle. This compensates for the
@@ -262,14 +311,15 @@ def main():
     ).contiguous()
 
     # --- 6.3  Per-view angular integration weights -------------------
-    # For a circular full-scan sampled uniformly, each view contributes
-    # ``pi / num_views`` to the FDK integral (the ``1/2`` redundancy
-    # factor of the FDK formula is absorbed inside ``redundant_full_scan``).
-    # For a short scan you would pass ``redundant_full_scan=False`` and
-    # typically combine this with Parker weights earlier in the
-    # pipeline.
+    # For a full 2*pi scan each view contributes ``pi / num_views`` to
+    # the FDK integral: the ``1/2`` redundancy factor of the FDK
+    # formula is absorbed inside ``redundant_full_scan=True``. For a
+    # Parker short scan the redundancy has already been handled by the
+    # Parker window above, so we fall back to a plain trapezoidal rule
+    # with ``redundant_full_scan=False`` (the 1/2 factor would then be
+    # incorrect).
     d_beta = angular_integration_weights(
-        angles_torch, redundant_full_scan=True
+        angles_torch, redundant_full_scan=(not apply_parker)
     ).view(-1, 1, 1)
     sinogram_filt = sinogram_filt * d_beta
 
@@ -311,7 +361,8 @@ def main():
     raw_loss = torch.mean((reconstruction_raw - phantom_torch) ** 2)
     clamped_loss = torch.mean((reconstruction - phantom_torch) ** 2)
 
-    print("Cone Beam FDK example (circular full scan):")
+    scan_label = "Parker short scan" if apply_parker else "full 2*pi scan"
+    print(f"Cone Beam FDK example ({scan_label}):")
     print(f"  Raw MSE:             {raw_loss.item():.6f}")
     print(f"  Clamped MSE:         {clamped_loss.item():.6f}")
     print(f"  Reconstruction shape: {tuple(reconstruction.shape)}")

{diffct-1.2.10 → diffct-1.2.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "diffct"
-version = "1.2.10"
+version = "1.2.11"
 description = "A CUDA-based library for computed tomography (CT) projection and reconstruction with differentiable operators"
 readme = "README.md"
 authors = [

diffct-1.2.11/pytest.ini

@@ -0,0 +1,14 @@
+[pytest]
+markers =
+    cuda: CUDA-dependent smoke tests
+    benchmark: Performance benchmarks (opt-in, excluded from default runs)
+# Default run excludes the benchmarks directory entirely. Use
+#     pytest tests/benchmarks/
+# explicitly to run them. This keeps `pytest tests/ -q` fast.
+addopts = --ignore=tests/benchmarks
+# Disable the timer/timings column noise from pytest-benchmark when not
+# running it (so default runs stay quiet).
+benchmark_disable_gc = true
+benchmark_warmup = true
+benchmark_min_rounds = 3
+benchmark_max_time = 2.0

diffct-1.2.11/tests/benchmarks/README.md

@@ -0,0 +1,60 @@
+# diffct benchmarks
+
+Performance benchmarks for every CUDA kernel in `diffct`, built on
+`pytest-benchmark`. These are **opt-in** — they are excluded from the
+default `pytest tests/` run by `--ignore=tests/benchmarks` in
+`pytest.ini`, so the regular test suite stays fast.
+
+## Running
+
+Run everything:
+
+```bash
+/c/Users/sun/miniconda3/envs/cuda12/python.exe -m pytest tests/benchmarks/ \
+    --benchmark-only --benchmark-columns=min,mean,median,stddev,rounds
+```
+
+Run a single geometry:
+
+```bash
+pytest tests/benchmarks/test_bench_cone.py --benchmark-only
+```
+
+Compare against a saved baseline (useful for before/after perf work):
+
+```bash
+# first, save a baseline
+pytest tests/benchmarks/ --benchmark-only --benchmark-save=baseline
+
+# ... make your changes ...
+
+# then compare
+pytest tests/benchmarks/ --benchmark-only --benchmark-compare=baseline
+```
+
+## What gets benchmarked
+
+Each geometry has a matching benchmark file that covers three kernels
+at three sizes (small / medium / large). All benchmarks run on CUDA
+and `pytest.skip` automatically when CUDA is unavailable.
+
+| File | Kernel under test |
+|---|---|
+| `test_bench_parallel.py` | `ParallelProjectorFunction`, `ParallelBackprojectorFunction`, `parallel_weighted_backproject` |
+| `test_bench_fan.py` | `FanProjectorFunction`, `FanBackprojectorFunction`, `fan_weighted_backproject` |
+| `test_bench_cone.py` | `ConeProjectorFunction`, `ConeBackprojectorFunction`, `cone_weighted_backproject` |
+
+For the weighted-backproject helpers the benchmark times the full
+analytical FBP / FDK pipeline (cosine pre-weight + ramp filter +
+angular weights + voxel-gather kernel), because that is what a user
+actually pays for when reconstructing.
+
+## How it works
+
+`pytest-benchmark` re-runs the target callable many times and reports
+the statistics (min / mean / median / stddev / rounds). CUDA streams
+are synchronised inside every call so we measure real GPU time rather
+than async kernel launch latency. The `pytest.ini` defaults
+(`benchmark_disable_gc`, `benchmark_warmup`,
+`benchmark_min_rounds=3`, `benchmark_max_time=2.0`) keep each
+benchmark under a couple of seconds while still averaging out noise.