tomorecon 0.1.0__tar.gz

tomorecon-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+.ipynb_checkpoints/
+.pytest_cache/
+build/
+dist/
+*.egg-info/
+.venv/
+venv/

tomorecon-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 GivralNguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tomorecon-0.1.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.5
+Name: tomorecon
+Version: 0.1.0
+Summary: Analytical tomographic image reconstruction: Radon transform, Fourier gridding, filtered backprojection, backproject-filter and convolve-backproject.
+Project-URL: Homepage, https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction
+Author: GivralNguyen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: computed tomography,filtered backprojection,image reconstruction,radon transform,tomography
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Requires-Dist: imageio>=2.16
+Requires-Dist: numpy>=1.21
+Requires-Dist: scikit-image>=0.19
+Requires-Dist: scipy>=1.8
+Provides-Extra: notebook
+Requires-Dist: jupyter; extra == 'notebook'
+Requires-Dist: matplotlib; extra == 'notebook'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Analytical Tomographic Image Reconstruction
+
+Welcome to the Analytical Tomographic Image Reconstruction repository! This collection of Python code provides implementations for various analytical tomographic image reconstruction algorithms. These algorithms play a crucial role in transforming projection data into detailed images, making them valuable tools in medical imaging, materials science, and more. Included are **Fourier Gridding**, **Backproject Filter**, **Filtered Backprojection** and **Convolve Backproject**.
+
+![Reconstructions of the Shepp-Logan phantom with each method](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/overview.png)
+
+## Installation
+
+```bash
+pip install git+https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction.git
+```
+
+Or from a local clone (editable, with the extras for the notebook and tests):
+
+```bash
+git clone https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction.git
+cd Python-Medical-Analytical-Tomographic-Image-Reconstruction
+pip install -e ".[notebook,test]"
+```
+
+Requires Python ≥ 3.9; dependencies (numpy, scipy, scikit-image, imageio) are installed automatically.
+
+## Quick Start
+
+```python
+import numpy as np
+import tomorecon as tr
+
+phantom = tr.shepp_logan()             # 256 x 256, bundled with the package
+theta = np.arange(180)                 # projection angles in degrees
+sinogram = tr.radon(phantom, theta)    # shape (256, 180): one projection per column
+
+image = tr.fbp(sinogram, theta)                         # filtered backprojection
+image = tr.fbp(sinogram, theta, filter="hann")          # 'ramp', 'shepp-logan', 'cosine', 'hamming', 'hann'
+image = tr.cbp(sinogram, theta)                         # convolve-backproject (spatial-domain filtering)
+image = tr.bpf(sinogram, theta)                         # backproject-filter (2-D cone filter)
+image = tr.fourier_gridding(sinogram, theta)            # direct Fourier reconstruction
+image = tr.backproject(sinogram, theta)                 # unfiltered backprojection (blurred)
+```
+
+Every step is also available on its own, e.g. `tr.filter_sinogram`, `tr.convolve_sinogram`, `tr.spatial_kernel`, `tr.cone_filter`, `tr.projection_spectra`, `tr.polar_to_cartesian` and `tr.inverse_fft2`. See the [tutorial](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/tutorial.ipynb) for how they fit together.
+
+### API
+
+| Function | Description |
+|---|---|
+| `shepp_logan(size=256)`, `disk(...)`, `load_image(path, size=256)` | Test objects |
+| `radon(image, theta=None, circle=True)` | Sinogram, shape `(n_detectors, n_angles)` |
+| `backproject(sinogram, theta=None, output_size=None, interval=1)` | Unfiltered backprojection |
+| `fbp(sinogram, theta=None, filter="ramp", output_size=None)` | Filtered backprojection |
+| `cbp(sinogram, theta=None, filter="ramp", output_size=None)` | Convolve-backproject |
+| `bpf(sinogram, theta=None, filter="ramp", output_size=None, grid_factor=2)` | Backproject-filter |
+| `fourier_gridding(sinogram, theta=None, output_size=None, oversample=4)` | Direct Fourier reconstruction |
+
+Angles are in degrees; if `theta` is omitted, the projections are assumed equally spaced over [0°, 180°).
+
+## Sample Results
+
+All images below are produced from the 256×256 Shepp-Logan phantom with 180 projections (0°–179°), using the code in this repository. See [tutorial.ipynb](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/tutorial.ipynb) for the full walkthrough.
+
+### Radon Transform
+
+Each column of the sinogram is one projection: the line integrals of the object along parallel rays at angle θ.
+
+![Phantom and its sinogram](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/radon.png)
+
+### Fourier Gridding
+
+By the Fourier slice theorem, the 1-D Fourier transform of a projection at angle θ is a radial line through the 2-D Fourier transform of the object. The slices are interpolated from the polar grid onto a Cartesian grid, and an inverse 2-D FFT gives the image. The projections are zero-padded 4× first (oversampling), which keeps the interpolation error small.
+
+![Fourier gridding: 1-D FT of projections, interpolated 2-D spectrum, reconstruction](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/fourier_gridding.png)
+
+### Backprojection
+
+Smearing every projection back across the image plane. With few angles the streaks are obvious; with all 180 angles the result is the object blurred by 1/r.
+
+![Unfiltered backprojection with 1, 2, 10, 45 and 180 projections](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/backprojection.png)
+
+### Backproject Filter
+
+The 1/r blur of the backprojection is removed afterwards in 2-D: multiply its spectrum by the cone filter |ρ| and transform back. The backprojection is computed on a 2× larger grid, since the blur extends far outside the object.
+
+![Backproject-filter: backprojection, spectrum before and after the cone filter, result](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/backproject_filter.png)
+
+### Filtered Backprojection
+
+Each projection is filtered with a 1-D ramp filter |ω| (optionally apodized) before backprojection. Smoother windows trade resolution for less noise.
+
+![Filter responses, filtered sinogram, and FBP with each filter](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/filtered_backprojection.png)
+
+### Convolve Backproject
+
+The same filtering as FBP, but done in the spatial domain by convolving each projection with the inverse Fourier transform of the filter. The result is identical to FBP up to floating-point error.
+
+![Spatial kernels, convolved sinogram, CBP reconstruction](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/convolve_backproject.png)
+
+## Code Structure
+
+The package lives in `src/tomorecon/`:
+
+| Module | Contents |
+|---|---|
+| `phantoms.py` | `shepp_logan`, `disk`, `load_image` |
+| `projection.py` | `radon`: the forward model |
+| `backprojection.py` | `backproject`, `fbp`, `cbp`, `bpf` |
+| `filters.py` | Ramp-type filters (`fourier_filter`), their spatial kernels (`spatial_kernel`), `filter_sinogram`, `convolve_sinogram` and the 2-D `cone_filter` |
+| `gridding.py` | `fourier_gridding` and its steps: `projection_spectra`, `polar_to_cartesian`, `inverse_fft2`, `polar_grid`, `cartesian_grid` |
+
+Outside the package:
+
+- **tutorial.ipynb**: Jupyter notebook demonstrating the usage of all reconstruction methods with examples and visualizations.
+- **tests/**: checks that every method reconstructs the phantom accurately (run `pytest`).
+- **data/**: extra sample images for `load_image`.
+
+## Tutorial
+
+After installing with the `notebook` extra, explore the provided [tutorial.ipynb](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/tutorial.ipynb) notebook for comprehensive examples and visualizations of each reconstruction method. You can experiment with different data sources and filters to see how these algorithms perform under various conditions.
+
+## Contributing
+
+We welcome contributions to enhance and expand this repository. If you have improvements, additional algorithms, or new features to suggest, please feel free to open an issue or submit a pull request.
+
+## Acknowledgments
+
+Special thanks to me for writing this and Prof. Lasser for the wonderful Seminar course
+
+## License
+
+This code is released under the [MIT License](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/LICENSE). Feel free to use, modify, and distribute the code in accordance with the terms of the license.
+
+Happy reconstructing! 🌐🖼️

tomorecon-0.1.0/README.md

@@ -0,0 +1,131 @@
+# Analytical Tomographic Image Reconstruction
+
+Welcome to the Analytical Tomographic Image Reconstruction repository! This collection of Python code provides implementations for various analytical tomographic image reconstruction algorithms. These algorithms play a crucial role in transforming projection data into detailed images, making them valuable tools in medical imaging, materials science, and more. Included are **Fourier Gridding**, **Backproject Filter**, **Filtered Backprojection** and **Convolve Backproject**.
+
+![Reconstructions of the Shepp-Logan phantom with each method](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/overview.png)
+
+## Installation
+
+```bash
+pip install git+https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction.git
+```
+
+Or from a local clone (editable, with the extras for the notebook and tests):
+
+```bash
+git clone https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction.git
+cd Python-Medical-Analytical-Tomographic-Image-Reconstruction
+pip install -e ".[notebook,test]"
+```
+
+Requires Python ≥ 3.9; dependencies (numpy, scipy, scikit-image, imageio) are installed automatically.
+
+## Quick Start
+
+```python
+import numpy as np
+import tomorecon as tr
+
+phantom = tr.shepp_logan()             # 256 x 256, bundled with the package
+theta = np.arange(180)                 # projection angles in degrees
+sinogram = tr.radon(phantom, theta)    # shape (256, 180): one projection per column
+
+image = tr.fbp(sinogram, theta)                         # filtered backprojection
+image = tr.fbp(sinogram, theta, filter="hann")          # 'ramp', 'shepp-logan', 'cosine', 'hamming', 'hann'
+image = tr.cbp(sinogram, theta)                         # convolve-backproject (spatial-domain filtering)
+image = tr.bpf(sinogram, theta)                         # backproject-filter (2-D cone filter)
+image = tr.fourier_gridding(sinogram, theta)            # direct Fourier reconstruction
+image = tr.backproject(sinogram, theta)                 # unfiltered backprojection (blurred)
+```
+
+Every step is also available on its own, e.g. `tr.filter_sinogram`, `tr.convolve_sinogram`, `tr.spatial_kernel`, `tr.cone_filter`, `tr.projection_spectra`, `tr.polar_to_cartesian` and `tr.inverse_fft2`. See the [tutorial](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/tutorial.ipynb) for how they fit together.
+
+### API
+
+| Function | Description |
+|---|---|
+| `shepp_logan(size=256)`, `disk(...)`, `load_image(path, size=256)` | Test objects |
+| `radon(image, theta=None, circle=True)` | Sinogram, shape `(n_detectors, n_angles)` |
+| `backproject(sinogram, theta=None, output_size=None, interval=1)` | Unfiltered backprojection |
+| `fbp(sinogram, theta=None, filter="ramp", output_size=None)` | Filtered backprojection |
+| `cbp(sinogram, theta=None, filter="ramp", output_size=None)` | Convolve-backproject |
+| `bpf(sinogram, theta=None, filter="ramp", output_size=None, grid_factor=2)` | Backproject-filter |
+| `fourier_gridding(sinogram, theta=None, output_size=None, oversample=4)` | Direct Fourier reconstruction |
+
+Angles are in degrees; if `theta` is omitted, the projections are assumed equally spaced over [0°, 180°).
+
+## Sample Results
+
+All images below are produced from the 256×256 Shepp-Logan phantom with 180 projections (0°–179°), using the code in this repository. See [tutorial.ipynb](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/tutorial.ipynb) for the full walkthrough.
+
+### Radon Transform
+
+Each column of the sinogram is one projection: the line integrals of the object along parallel rays at angle θ.
+
+![Phantom and its sinogram](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/radon.png)
+
+### Fourier Gridding
+
+By the Fourier slice theorem, the 1-D Fourier transform of a projection at angle θ is a radial line through the 2-D Fourier transform of the object. The slices are interpolated from the polar grid onto a Cartesian grid, and an inverse 2-D FFT gives the image. The projections are zero-padded 4× first (oversampling), which keeps the interpolation error small.
+
+![Fourier gridding: 1-D FT of projections, interpolated 2-D spectrum, reconstruction](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/fourier_gridding.png)
+
+### Backprojection
+
+Smearing every projection back across the image plane. With few angles the streaks are obvious; with all 180 angles the result is the object blurred by 1/r.
+
+![Unfiltered backprojection with 1, 2, 10, 45 and 180 projections](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/backprojection.png)
+
+### Backproject Filter
+
+The 1/r blur of the backprojection is removed afterwards in 2-D: multiply its spectrum by the cone filter |ρ| and transform back. The backprojection is computed on a 2× larger grid, since the blur extends far outside the object.
+
+![Backproject-filter: backprojection, spectrum before and after the cone filter, result](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/backproject_filter.png)
+
+### Filtered Backprojection
+
+Each projection is filtered with a 1-D ramp filter |ω| (optionally apodized) before backprojection. Smoother windows trade resolution for less noise.
+
+![Filter responses, filtered sinogram, and FBP with each filter](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/filtered_backprojection.png)
+
+### Convolve Backproject
+
+The same filtering as FBP, but done in the spatial domain by convolving each projection with the inverse Fourier transform of the filter. The result is identical to FBP up to floating-point error.
+
+![Spatial kernels, convolved sinogram, CBP reconstruction](https://raw.githubusercontent.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/main/images/convolve_backproject.png)
+
+## Code Structure
+
+The package lives in `src/tomorecon/`:
+
+| Module | Contents |
+|---|---|
+| `phantoms.py` | `shepp_logan`, `disk`, `load_image` |
+| `projection.py` | `radon`: the forward model |
+| `backprojection.py` | `backproject`, `fbp`, `cbp`, `bpf` |
+| `filters.py` | Ramp-type filters (`fourier_filter`), their spatial kernels (`spatial_kernel`), `filter_sinogram`, `convolve_sinogram` and the 2-D `cone_filter` |
+| `gridding.py` | `fourier_gridding` and its steps: `projection_spectra`, `polar_to_cartesian`, `inverse_fft2`, `polar_grid`, `cartesian_grid` |
+
+Outside the package:
+
+- **tutorial.ipynb**: Jupyter notebook demonstrating the usage of all reconstruction methods with examples and visualizations.
+- **tests/**: checks that every method reconstructs the phantom accurately (run `pytest`).
+- **data/**: extra sample images for `load_image`.
+
+## Tutorial
+
+After installing with the `notebook` extra, explore the provided [tutorial.ipynb](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/tutorial.ipynb) notebook for comprehensive examples and visualizations of each reconstruction method. You can experiment with different data sources and filters to see how these algorithms perform under various conditions.
+
+## Contributing
+
+We welcome contributions to enhance and expand this repository. If you have improvements, additional algorithms, or new features to suggest, please feel free to open an issue or submit a pull request.
+
+## Acknowledgments
+
+Special thanks to me for writing this and Prof. Lasser for the wonderful Seminar course
+
+## License
+
+This code is released under the [MIT License](https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction/blob/main/LICENSE). Feel free to use, modify, and distribute the code in accordance with the terms of the license.
+
+Happy reconstructing! 🌐🖼️

tomorecon-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tomorecon"
+version = "0.1.0"
+description = "Analytical tomographic image reconstruction: Radon transform, Fourier gridding, filtered backprojection, backproject-filter and convolve-backproject."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "GivralNguyen" }]
+keywords = ["tomography", "computed tomography", "image reconstruction", "radon transform", "filtered backprojection"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "Topic :: Scientific/Engineering :: Image Processing",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+dependencies = [
+    "numpy>=1.21",
+    "scipy>=1.8",
+    "scikit-image>=0.19",
+    "imageio>=2.16",
+]
+
+[project.optional-dependencies]
+notebook = ["matplotlib", "jupyter"]
+test = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/GivralNguyen/Python-Medical-Analytical-Tomographic-Image-Reconstruction"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tomorecon"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/tomorecon", "tests", "README.md", "LICENSE", "pyproject.toml"]

tomorecon-0.1.0/src/tomorecon/__init__.py

@@ -0,0 +1,52 @@
+"""
+tomorecon: analytical tomographic image reconstruction.
+
+Radon transform, Fourier gridding, (filtered) backprojection, backproject-filter
+and convolve-backproject for 2-D parallel-beam tomography.
+
+Example
+-------
+>>> import tomorecon as tr
+>>> phantom = tr.shepp_logan()
+>>> sinogram = tr.radon(phantom)          # 180 angles, 0..179 degrees
+>>> image = tr.fbp(sinogram)              # ramp-filtered backprojection
+"""
+
+from .backprojection import backproject, bpf, cbp, fbp
+from .filters import (
+    FILTERS,
+    cone_filter,
+    convolve_sinogram,
+    filter_sinogram,
+    fourier_filter,
+    padded_size,
+    spatial_kernel,
+)
+from .gridding import (
+    cartesian_grid,
+    fourier_gridding,
+    frequency_axis,
+    inverse_fft2,
+    polar_grid,
+    polar_to_cartesian,
+    projection_spectra,
+)
+from .phantoms import disk, load_image, shepp_logan
+from .projection import radon
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # data
+    "shepp_logan", "disk", "load_image",
+    # forward model
+    "radon",
+    # reconstruction
+    "backproject", "fbp", "cbp", "bpf", "fourier_gridding",
+    # filters
+    "FILTERS", "fourier_filter", "spatial_kernel", "filter_sinogram", "convolve_sinogram",
+    "cone_filter", "padded_size",
+    # Fourier gridding steps
+    "projection_spectra", "polar_to_cartesian", "inverse_fft2", "polar_grid", "cartesian_grid",
+    "frequency_axis",
+]

tomorecon-0.1.0/src/tomorecon/_utils.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import numpy as np
+from skimage.util import img_as_float
+
+
+def as_float_image(image) -> np.ndarray:
+    """Image as float; integer/bool images are rescaled to [0, 1] like skimage's `img_as_float`."""
+    image = np.asarray(image)
+    if image.dtype == np.float16:
+        return image.astype(np.float32)
+    return img_as_float(image)
+
+
+def as_float_data(data) -> np.ndarray:
+    """Measured data (e.g. a sinogram) as float, keeping its values."""
+    data = np.asarray(data)
+    if data.dtype.char not in "df":
+        data = data.astype(np.float32 if data.dtype == np.float16 else float)
+    return data
+
+
+def default_theta(n_angles: int) -> np.ndarray:
+    """`n_angles` equally spaced angles in [0, 180) degrees."""
+    return np.linspace(0, 180, n_angles, endpoint=False)
+
+
+def center_crop(image: np.ndarray, size: int) -> np.ndarray:
+    """Centred size x size crop of a square image (centre pixel at index shape // 2)."""
+    start = image.shape[0] // 2 - size // 2
+    return image[start:start + size, start:start + size]

tomorecon-0.1.0/src/tomorecon/backprojection.py

@@ -0,0 +1,95 @@
+"""Backprojection-based reconstruction: BP, FBP, CBP and BPF."""
+from __future__ import annotations
+
+import numpy as np
+
+from ._utils import as_float_data, default_theta
+from .filters import cone_filter, convolve_sinogram, filter_sinogram
+
+__all__ = ["backproject", "fbp", "cbp", "bpf"]
+
+
+def _angles(sinogram, theta):
+    if theta is None:
+        return default_theta(sinogram.shape[1])
+    theta = np.asarray(theta, dtype=float)
+    if theta.shape != (sinogram.shape[1],):
+        raise ValueError(f"theta has {theta.size} angles but the sinogram has {sinogram.shape[1]} columns")
+    return theta
+
+
+def backproject(sinogram: np.ndarray, theta: np.ndarray | None = None,
+                output_size: int | None = None, interval: int = 1) -> np.ndarray:
+    """
+    Unfiltered backprojection: smear every projection back across the image plane.
+
+    Parameters
+    ----------
+    sinogram : ndarray of shape (n_detectors, n_angles)
+        As returned by `radon`; rotation centre at row n_detectors // 2.
+    theta : 1-D array, optional
+        Projection angles in degrees. Default: n_angles equally spaced angles in [0, 180).
+    output_size : int, optional
+        Side of the reconstructed image. Default: n_detectors.
+    interval : int
+        Use only every `interval`-th projection (to show the effect of fewer angles).
+
+    Returns
+    -------
+    ndarray of shape (output_size, output_size)
+        Scaled by pi / (2 * angles used), so that backprojecting a ramp-filtered
+        sinogram reconstructs the object at its original intensity.
+    """
+    sinogram = as_float_data(sinogram)
+    theta = _angles(sinogram, theta)
+    n = sinogram.shape[0]
+    output_size = output_size or n
+
+    rows, cols = np.mgrid[:output_size, :output_size] - output_size // 2
+    detector = np.arange(n) - n // 2
+    image = np.zeros((output_size, output_size))
+    used = range(0, len(theta), interval)
+    for i in used:
+        angle = np.deg2rad(theta[i])
+        t = cols * np.cos(angle) - rows * np.sin(angle)
+        image += np.interp(t, detector, sinogram[:, i], left=0, right=0)
+    return image * np.pi / (2 * len(used))
+
+
+def fbp(sinogram: np.ndarray, theta: np.ndarray | None = None, filter: str | None = "ramp",
+        output_size: int | None = None) -> np.ndarray:
+    """
+    Filtered backprojection: filter every projection in the frequency domain, then backproject.
+
+    `filter` is one of `FILTERS` ('ramp', 'shepp-logan', 'cosine', 'hamming', 'hann');
+    smoother windows trade resolution for less noise. See `backproject` for the other arguments.
+    """
+    return backproject(filter_sinogram(sinogram, filter), theta, output_size)
+
+
+def cbp(sinogram: np.ndarray, theta: np.ndarray | None = None, filter: str | None = "ramp",
+        output_size: int | None = None) -> np.ndarray:
+    """
+    Convolve-backproject: like `fbp`, but the filter is applied as a spatial convolution
+    of each projection. The result is identical to `fbp` up to floating-point error.
+    """
+    return backproject(convolve_sinogram(sinogram, filter), theta, output_size)
+
+
+def bpf(sinogram: np.ndarray, theta: np.ndarray | None = None, filter: str | None = "ramp",
+        output_size: int | None = None, grid_factor: int = 2) -> np.ndarray:
+    """
+    Backproject-filter: backproject first, then remove the 1/r blur with the 2-D cone filter.
+
+    Parameters
+    ----------
+    grid_factor : int
+        Backproject onto a grid `grid_factor` times larger than `output_size` before
+        filtering, because the 1/r blur extends far outside the object (1 gives visible
+        errors; 2 is enough in practice).
+
+    See `backproject` and `fbp` for the other arguments.
+    """
+    output_size = output_size or np.asarray(sinogram).shape[0]
+    blurred = backproject(sinogram, theta, grid_factor * output_size)
+    return cone_filter(blurred, filter, output_size)[1]

tomorecon-0.1.0/src/tomorecon/filters.py

@@ -0,0 +1,163 @@
+"""Reconstruction filters: 1-D ramp-type filters, their spatial kernels, and the 2-D cone filter."""
+from __future__ import annotations
+
+import numpy as np
+from scipy.fft import fft, fft2, fftfreq, fftshift, ifft, ifft2
+
+from ._utils import as_float_data, center_crop
+
+__all__ = [
+    "FILTERS",
+    "padded_size",
+    "fourier_filter",
+    "spatial_kernel",
+    "filter_sinogram",
+    "convolve_sinogram",
+    "cone_filter",
+]
+
+FILTERS = ("ramp", "shepp-logan", "cosine", "hamming", "hann")
+
+
+def _check(name):
+    if name is not None and name not in FILTERS:
+        raise ValueError(f"Unknown filter {name!r}; choose one of {FILTERS} or None")
+
+
+def padded_size(n: int) -> int:
+    """Smallest power of two >= 2n (and >= 64): FFT filtering at this length is a linear convolution."""
+    return max(64, int(2 ** np.ceil(np.log2(2 * n))))
+
+
+def fourier_filter(size: int, name: str | None = "ramp") -> np.ndarray:
+    """
+    Frequency response of a reconstruction filter, in FFT order (DC first).
+
+    The ramp is built as the DFT of the band-limited spatial ramp kernel
+    (h[0] = 1/4, h[odd n] = -1/(pi n)^2), which avoids the DC error of a sampled |f|.
+    It equals 2|f| (f in cycles/sample), i.e. 1 at Nyquist. Other filters are the ramp
+    times an apodizing window.
+
+    Parameters
+    ----------
+    size : int
+        Filter length (use `padded_size(n_detectors)`).
+    name : {'ramp', 'shepp-logan', 'cosine', 'hamming', 'hann'} or None
+        None returns an all-pass (unity) filter.
+
+    Returns
+    -------
+    ndarray of shape (size,)
+    """
+    _check(name)
+    if name is None:
+        return np.ones(size)
+
+    n = np.concatenate((np.arange(1, size / 2 + 1, 2, dtype=int),
+                        np.arange(size / 2 - 1, 0, -2, dtype=int)))
+    h = np.zeros(size)
+    h[0] = 0.25
+    h[1::2] = -1 / (np.pi * n) ** 2
+    response = 2 * np.real(fft(h))
+
+    if name == "shepp-logan":
+        omega = np.pi * fftfreq(size)[1:]
+        response[1:] *= np.sin(omega) / omega
+    elif name == "cosine":
+        response *= fftshift(np.sin(np.linspace(0, np.pi, size, endpoint=False)))
+    elif name == "hamming":
+        response *= fftshift(np.hamming(size))
+    elif name == "hann":
+        response *= fftshift(np.hanning(size))
+    return response
+
+
+def spatial_kernel(n_detectors: int, name: str | None = "ramp") -> np.ndarray:
+    """
+    Spatial convolution kernel equivalent to `fourier_filter` (for convolve-backproject).
+
+    Covers lags -(n-1) ... (n-1), every lag that occurs when convolving a projection of
+    length n, so convolving with it equals FFT filtering with zero-padding.
+
+    Returns
+    -------
+    ndarray of shape (2 * n_detectors - 1,), lag 0 at index n_detectors - 1
+    """
+    size = padded_size(n_detectors)
+    h = np.real(ifft(fourier_filter(size, name)))
+    lags = np.arange(-(n_detectors - 1), n_detectors)
+    return h[lags % size]
+
+
+def filter_sinogram(sinogram: np.ndarray, name: str | None = "ramp") -> np.ndarray:
+    """
+    Filter every projection (column) in the frequency domain.
+
+    Projections are zero-padded to `padded_size` so the product of FFTs is a linear,
+    not circular, convolution.
+    """
+    sinogram = as_float_data(sinogram)
+    n = sinogram.shape[0]
+    size = padded_size(n)
+    spectrum = fft(sinogram, n=size, axis=0) * fourier_filter(size, name)[:, None]
+    return np.real(ifft(spectrum, axis=0))[:n]
+
+
+def convolve_sinogram(sinogram: np.ndarray, name: str | None = "ramp") -> np.ndarray:
+    """
+    Filter every projection (column) by spatial convolution with `spatial_kernel`.
+    Gives the same result as `filter_sinogram` (to floating-point precision).
+    """
+    sinogram = as_float_data(sinogram)
+    n = sinogram.shape[0]
+    kernel = spatial_kernel(n, name)
+    # full convolution has length 3n-2; output sample i sits at index i + (n-1)
+    return np.stack([np.convolve(column, kernel)[n - 1:2 * n - 1] for column in sinogram.T], axis=1)
+
+
+def _window(freq: np.ndarray, name: str | None) -> np.ndarray:
+    """Apodizing window at |freq| (cycles/sample); beyond Nyquist it is held at its Nyquist value."""
+    _check(name)
+    f = np.minimum(np.abs(freq), 0.5)
+    if name in ("ramp", None):
+        return np.ones_like(f)
+    if name == "shepp-logan":
+        return np.sinc(f)
+    if name == "cosine":
+        return np.cos(np.pi * f)
+    if name == "hamming":
+        return 0.54 + 0.46 * np.cos(2 * np.pi * f)
+    return 0.5 + 0.5 * np.cos(2 * np.pi * f)  # hann
+
+
+def cone_filter(image: np.ndarray, name: str | None = "ramp",
+                output_size: int | None = None) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Apply the 2-D cone filter 2|rho| (optionally apodized) to an unfiltered backprojection.
+
+    Unfiltered backprojection is the object convolved with 1/r, whose 2-D Fourier transform
+    is 1/|rho|; multiplying by |rho| undoes it. The factor 2 matches the scaling of the
+    1-D ramp in `fourier_filter`.
+
+    Parameters
+    ----------
+    image : square 2-D array
+        Unfiltered backprojection. The 1/r blur reaches far outside the object, so compute it
+        on a larger grid than needed (e.g. 2x) and crop with `output_size`.
+    name : filter name, see `FILTERS`
+    output_size : int, optional
+        Side of the centred crop to return. Default: full size.
+
+    Returns
+    -------
+    spectrum : ndarray
+        Filtered 2-D spectrum, fftshift-ed (DC in the centre), for display.
+    filtered : ndarray
+        Filtered image, cropped to `output_size`.
+    """
+    size = image.shape[0]
+    u, v = np.meshgrid(fftfreq(size), fftfreq(size))
+    rho = np.hypot(u, v)
+    spectrum = fft2(image) * (2 * rho * _window(rho, name))
+    filtered = np.real(ifft2(spectrum))
+    return fftshift(spectrum), center_crop(filtered, output_size or size)

tomorecon-0.1.0/src/tomorecon/gridding.py

@@ -0,0 +1,127 @@
+"""Direct Fourier reconstruction (Fourier gridding) via the Fourier slice theorem."""
+from __future__ import annotations
+
+import numpy as np
+from numpy.fft import fft, fftshift, ifft2, ifftshift
+from scipy.interpolate import RegularGridInterpolator
+
+from ._utils import as_float_data, center_crop, default_theta
+
+__all__ = [
+    "frequency_axis",
+    "projection_spectra",
+    "polar_grid",
+    "cartesian_grid",
+    "polar_to_cartesian",
+    "inverse_fft2",
+    "fourier_gridding",
+]
+
+
+def frequency_axis(n: int) -> np.ndarray:
+    """Angular frequencies (rad/sample) of an fftshift-ed length-n FFT; zero at index n // 2."""
+    return (np.arange(n) - n // 2) * (2 * np.pi / n)
+
+
+def projection_spectra(sinogram: np.ndarray, oversample: int = 1) -> np.ndarray:
+    """
+    1-D Fourier transform of every projection (along the detector axis).
+
+    Parameters
+    ----------
+    sinogram : ndarray of shape (n_detectors, n_angles)
+    oversample : int
+        Zero-pad each projection to `oversample * n_detectors` first. This samples the
+        Fourier slices more finely and greatly reduces gridding interpolation error
+        (1 gives strong artifacts; 4 is about as accurate as FBP).
+
+    Returns
+    -------
+    ndarray of shape (oversample * n_detectors, n_angles), complex
+        fftshift-ed: zero frequency at row N // 2, frequencies given by `frequency_axis(N)`.
+    """
+    sinogram = as_float_data(sinogram)
+    n0 = sinogram.shape[0]
+    n = n0 * oversample
+    padded = np.zeros((n, sinogram.shape[1]))
+    start = n // 2 - n0 // 2                      # keep the rotation centre at row n // 2
+    padded[start:start + n0] = sinogram
+    return fftshift(fft(ifftshift(padded, axes=0), axis=0), axes=0)
+
+
+def polar_grid(n: int, theta: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """(theta_grid [rad], radius_grid [rad/sample]), both (n, len(theta)): where the slices are sampled."""
+    return np.meshgrid(np.deg2rad(theta), frequency_axis(n))
+
+
+def cartesian_grid(n: int) -> tuple[np.ndarray, np.ndarray]:
+    """(kx, ky), both (n, n): kx varies along columns, ky along rows (rad/sample)."""
+    return np.meshgrid(frequency_axis(n), frequency_axis(n))
+
+
+def polar_to_cartesian(spectra: np.ndarray, theta: np.ndarray) -> np.ndarray:
+    """
+    Interpolate the polar samples of the 2-D Fourier transform onto the Cartesian grid.
+
+    Fourier slice convention of `radon` (t = x cos(theta) - y sin(theta)):
+        P_theta(w) = F(kx = w cos(theta), ky = -w sin(theta)).
+    Each Cartesian point maps to theta = atan2(-ky, kx), w = |k|; angles below 0 use
+    P_{theta+pi}(w) = P_theta(-w). Interpolation is bilinear in (w, theta), with the slice
+    at 180 degrees appended so the 179 -> 0 degree wrap-around is handled.
+
+    Parameters
+    ----------
+    spectra : ndarray of shape (N, n_angles)
+        From `projection_spectra`.
+    theta : 1-D array
+        Projection angles in degrees, ascending, within [0, 180).
+
+    Returns
+    -------
+    ndarray of shape (N, N), complex, fftshift-ed (DC at [N // 2, N // 2])
+    """
+    n = spectra.shape[0]
+    w = frequency_axis(n)
+    theta = np.deg2rad(np.asarray(theta, dtype=float))
+
+    # slice at pi = slice at 0 mirrored (w -> -w maps row k to row 2*(n//2) - k)
+    mirrored = spectra[(2 * (n // 2) - np.arange(n)) % n, 0]
+    values = np.concatenate([spectra, mirrored[:, None]], axis=1)
+    angles = np.append(theta, np.pi)
+
+    kx, ky = cartesian_grid(n)
+    angle = np.arctan2(-ky, kx)
+    radius = np.hypot(kx, ky)
+    negative = angle < 0
+    angle[negative] += np.pi
+    radius[negative] *= -1
+
+    interpolate = RegularGridInterpolator((w, angles), values, bounds_error=False, fill_value=0)
+    return interpolate(np.column_stack((radius.ravel(), angle.ravel()))).reshape(n, n)
+
+
+def inverse_fft2(spectrum: np.ndarray, output_size: int | None = None) -> np.ndarray:
+    """Real image from an fftshift-ed 2-D spectrum, optionally cropped to the centred output_size."""
+    image = np.real(fftshift(ifft2(ifftshift(spectrum))))
+    return image if output_size is None else center_crop(image, output_size)
+
+
+def fourier_gridding(sinogram: np.ndarray, theta: np.ndarray | None = None,
+                     output_size: int | None = None, oversample: int = 4) -> np.ndarray:
+    """
+    Direct Fourier reconstruction: 1-D FFT of each projection, polar-to-Cartesian
+    interpolation of the slices, inverse 2-D FFT.
+
+    Parameters
+    ----------
+    sinogram : ndarray of shape (n_detectors, n_angles)
+    theta : 1-D array, optional
+        Projection angles in degrees. Default: n_angles equally spaced angles in [0, 180).
+    output_size : int, optional
+        Side of the reconstructed image. Default: n_detectors.
+    oversample : int
+        Zero-padding factor of the projections, see `projection_spectra`.
+    """
+    theta = default_theta(np.shape(sinogram)[1]) if theta is None else theta
+    spectrum = polar_to_cartesian(projection_spectra(sinogram, oversample), theta)
+    return inverse_fft2(spectrum, output_size or np.shape(sinogram)[0])

tomorecon-0.1.0/src/tomorecon/phantoms.py

@@ -0,0 +1,60 @@
+"""Test objects: the Shepp-Logan phantom, a disk, or any image file."""
+from __future__ import annotations
+
+from importlib.resources import as_file, files
+
+import imageio.v3 as iio
+import numpy as np
+from skimage.transform import rescale, resize
+
+__all__ = ["shepp_logan", "disk", "load_image"]
+
+
+def shepp_logan(size: int = 256) -> np.ndarray:
+    """
+    Modified Shepp-Logan head phantom (bundled with the package).
+
+    Parameters
+    ----------
+    size : int
+        Side length of the returned square image.
+
+    Returns
+    -------
+    ndarray of shape (size, size), float, values in [0, 1]
+    """
+    with as_file(files("tomorecon") / "data" / "shepp_logan_phantom.png") as path:
+        image = iio.imread(path, mode="L")
+    return rescale(image, scale=size / image.shape[0], mode="reflect", channel_axis=None)
+
+
+def disk(shape: tuple[int, int] = (120, 120), radius: float = 20,
+         center: tuple[float, float] = (100, 60)) -> np.ndarray:
+    """
+    Binary disk, useful for seeing how a single object traces a sine curve in the sinogram.
+
+    Parameters
+    ----------
+    shape : (rows, cols)
+    radius : float
+    center : (x, y)
+        Disk centre as (column, row).
+
+    Returns
+    -------
+    ndarray of shape `shape`, float, 1 inside the disk and 0 outside
+    """
+    y, x = np.mgrid[:shape[0], :shape[1]]
+    return (((x - center[0]) ** 2 + (y - center[1]) ** 2) < radius ** 2).astype(float)
+
+
+def load_image(path, size: int = 256) -> np.ndarray:
+    """
+    Load an image file as grayscale and resize it to (size, size).
+
+    Returns
+    -------
+    ndarray of shape (size, size), float, values in [0, 1]
+    """
+    image = iio.imread(path, mode="L")
+    return resize(image, (size, size), mode="reflect", anti_aliasing=True)

tomorecon-0.1.0/src/tomorecon/projection.py

@@ -0,0 +1,70 @@
+"""Forward model: the 2-D parallel-beam Radon transform."""
+from __future__ import annotations
+
+from warnings import warn
+
+import numpy as np
+from skimage.transform import warp
+
+from ._utils import as_float_image, default_theta
+
+__all__ = ["radon"]
+
+
+def _pad_to_square(image: np.ndarray, circle: bool) -> np.ndarray:
+    if circle:
+        # Object must lie inside the inscribed circle; crop to the largest centred square.
+        size = min(image.shape)
+        radius = size // 2
+        rows, cols = np.ogrid[:image.shape[0], :image.shape[1]]
+        dist2 = (rows - image.shape[0] // 2) ** 2 + (cols - image.shape[1] // 2) ** 2
+        if np.any(image[dist2 > radius ** 2]):
+            warn("radon: image must be zero outside the reconstruction circle", stacklevel=3)
+        starts = [int(np.ceil((s - size) / 2)) for s in image.shape]
+        return image[starts[0]:starts[0] + size, starts[1]:starts[1] + size]
+
+    # Pad so the whole image fits inside the inscribed circle of the padded square.
+    diagonal = np.sqrt(2) * max(image.shape)
+    pad = [int(np.ceil(diagonal - s)) for s in image.shape]
+    before = [(s + p) // 2 - s // 2 for s, p in zip(image.shape, pad)]
+    return np.pad(image, [(b, p - b) for b, p in zip(before, pad)], mode="constant")
+
+
+def radon(image: np.ndarray, theta: np.ndarray | None = None, circle: bool = True) -> np.ndarray:
+    """
+    Radon transform: line integrals of `image` along parallel rays at each angle.
+
+    For each angle the image is rotated about its centre (bilinear interpolation) and
+    summed along the columns. The detector coordinate is t = x cos(theta) - y sin(theta)
+    with x = column and y = row, both relative to the centre pixel.
+
+    Parameters
+    ----------
+    image : 2-D array
+    theta : 1-D array, optional
+        Projection angles in degrees. Default: 0, 1, ..., 179.
+    circle : bool
+        If True (default), assume the object lies inside the circle inscribed in the image;
+        the sinogram then has as many detector bins as the image side. If False, the image
+        is zero-padded so that nothing is cut off (sinogram length ~ sqrt(2) * side).
+
+    Returns
+    -------
+    sinogram : ndarray of shape (n_detectors, len(theta))
+        One projection per column; the rotation centre is at row n_detectors // 2.
+    """
+    image = as_float_image(image)
+    if image.ndim != 2:
+        raise ValueError("radon: image must be 2-D")
+    theta = default_theta(180) if theta is None else np.asarray(theta, dtype=float)
+
+    padded = _pad_to_square(image, circle)
+    center = padded.shape[0] // 2
+    sinogram = np.zeros((padded.shape[0], len(theta)), dtype=padded.dtype)
+    for i, angle in enumerate(np.deg2rad(theta)):
+        cos_a, sin_a = np.cos(angle), np.sin(angle)
+        rotation = np.array([[cos_a, sin_a, -center * (cos_a + sin_a - 1)],
+                             [-sin_a, cos_a, -center * (cos_a - sin_a - 1)],
+                             [0, 0, 1]])
+        sinogram[:, i] = warp(padded, rotation, clip=False).sum(axis=0)
+    return sinogram

tomorecon-0.1.0/tests/test_reconstruction.py

@@ -0,0 +1,110 @@
+"""Every reconstruction method must reproduce the Shepp-Logan phantom (RMSE inside the FOV circle)."""
+import numpy as np
+import pytest
+from skimage.transform import iradon
+from skimage.transform import radon as sk_radon
+
+import tomorecon as tr
+
+THETA = np.arange(180)
+
+
+@pytest.fixture(scope="module")
+def phantom():
+    return tr.shepp_logan()
+
+
+@pytest.fixture(scope="module")
+def sinogram(phantom):
+    return tr.radon(phantom, THETA)
+
+
+@pytest.fixture(scope="module")
+def inside(phantom):
+    n = phantom.shape[0]
+    rows, cols = np.mgrid[:n, :n] - n // 2
+    return rows ** 2 + cols ** 2 < (n // 2 - 2) ** 2
+
+
+@pytest.fixture(scope="module")
+def rmse(phantom, inside):
+    return lambda image: float(np.sqrt(np.mean((image[inside] - phantom[inside]) ** 2)))
+
+
+def test_phantom(phantom):
+    assert phantom.shape == (256, 256)
+    assert 0 <= phantom.min() and phantom.max() <= 1
+    assert tr.shepp_logan(128).shape == (128, 128)
+
+
+def test_disk():
+    d = tr.disk((50, 60), radius=5, center=(30, 20))
+    assert d.shape == (50, 60) and d[20, 30] == 1 and d[0, 0] == 0
+
+
+def test_radon_matches_skimage(phantom, sinogram):
+    np.testing.assert_allclose(sinogram, sk_radon(phantom, THETA), atol=1e-10)
+
+
+def test_radon_no_circle_matches_skimage(phantom):
+    np.testing.assert_allclose(tr.radon(phantom, THETA[::10], circle=False),
+                               sk_radon(phantom, THETA[::10], circle=False), atol=1e-10)
+
+
+def test_fbp_matches_skimage(sinogram, inside):
+    ref = iradon(sinogram, THETA, filter_name="ramp", circle=True)
+    np.testing.assert_allclose(tr.fbp(sinogram, THETA)[inside], ref[inside], atol=1e-8)
+
+
+@pytest.mark.parametrize("name", tr.FILTERS)
+def test_fbp(sinogram, rmse, name):
+    assert rmse(tr.fbp(sinogram, THETA, filter=name)) < 0.06
+
+
+@pytest.mark.parametrize("name", ["ramp", "cosine"])
+def test_cbp_equals_fbp(sinogram, name):
+    np.testing.assert_allclose(tr.cbp(sinogram, THETA, name), tr.fbp(sinogram, THETA, name), atol=1e-10)
+
+
+def test_bpf(sinogram, rmse):
+    assert rmse(tr.bpf(sinogram, THETA)) < 0.05
+
+
+def test_fourier_gridding(sinogram, rmse):
+    assert rmse(tr.fourier_gridding(sinogram, THETA)) < 0.04
+    # without oversampling the interpolation error is much larger
+    assert rmse(tr.fourier_gridding(sinogram, THETA, oversample=1)) > 0.06
+
+
+def test_fourier_slice_theorem(phantom, sinogram):
+    # theta = 0: the FT of the projection is the ky = 0 row of the 2-D FT
+    spectra = tr.projection_spectra(sinogram)
+    F = np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(phantom)))
+    n = spectra.shape[0]
+    np.testing.assert_allclose(spectra[:, 0], F[n // 2, :], atol=1e-6 * np.abs(F).max())
+
+
+def test_default_theta(sinogram):
+    np.testing.assert_allclose(tr.fbp(sinogram), tr.fbp(sinogram, THETA))
+
+
+def test_theta_length_mismatch(sinogram):
+    with pytest.raises(ValueError):
+        tr.fbp(sinogram, THETA[:10])
+
+
+def test_interval_normalisation(sinogram):
+    full = tr.backproject(sinogram, THETA).mean()
+    assert abs(tr.backproject(sinogram, THETA, interval=18).mean() / full - 1) < 0.02
+
+
+def test_spatial_kernel_is_centred():
+    k = tr.spatial_kernel(256)
+    assert k.size == 511 and np.argmax(k) == 255
+    np.testing.assert_allclose(k, k[::-1], atol=1e-12)
+
+
+def test_filter_validation():
+    np.testing.assert_array_equal(tr.fourier_filter(64, None), np.ones(64))
+    with pytest.raises(ValueError):
+        tr.fourier_filter(64, "nope")