torchtomo 0.1.0__tar.gz

torchtomo-0.1.0/LICENSE

@@ -0,0 +1,12 @@
+This work is licensed under the Creative Commons Attribution–NonCommercial
+4.0 International License (CC BY-NC 4.0).
+
+You are free to use, share, and adapt this software for non-commercial
+research and educational purposes, provided that appropriate attribution
+is given to the authors and the source.
+
+Commercial use by third parties is prohibited without prior written
+permission from the authors. The authors retain all commercial rights.
+
+To view a copy of this license, visit:
+https://creativecommons.org/licenses/by-nc/4.0/

torchtomo-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: torchtomo
+Version: 0.1.0
+Summary: Differentiable CT Reconstruction in Pure PyTorch
+Author: BIAI Lab
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/itu-biai/torchtomo
+Project-URL: Repository, https://github.com/itu-biai/torchtomo
+Project-URL: Issues, https://github.com/itu-biai/torchtomo/issues
+Keywords: ct,tomography,reconstruction,pytorch,differentiable,deep-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=1.10
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: scikit-image; extra == "test"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: scikit-image; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# TorchTomo
+
+[![PyPI](https://img.shields.io/pypi/v/torchtomo.svg)](https://pypi.org/project/torchtomo/)
+[![Changelog](https://img.shields.io/github/v/release/itu-biai/torchtomo?include_prereleases&label=changelog)](https://github.com/itu-biai/torchtomo/releases)
+[![Tests](https://github.com/itu-biai/torchtomo/actions/workflows/test.yml/badge.svg)](https://github.com/itu-biai/torchtomo/actions/workflows/test.yml)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/itu-biai/torchtomo/blob/main/LICENSE)
+
+Differentiable CT reconstruction primitives in pure PyTorch.
+
+TorchTomo provides forward projection, adjoint backprojection, and filtered backprojection for parallel-beam and fan-beam geometries, with support for CPU, CUDA, and Apple Silicon (MPS).
+
+## Features
+
+- Pure PyTorch implementation with no custom CUDA build step
+- Autograd-friendly operators for learned reconstruction pipelines
+- Parallel-beam and fan-beam (flat detector) projectors
+- Built-in FBP filters: `ramp`, `shepp-logan`, `cosine`, `hamming`, `hann`, `none`
+- Built-in phantom generators for quick experiments
+
+## Installation
+
+```bash
+pip install torchtomo
+```
+
+## Quick Start (Parallel Beam)
+
+```python
+import torch
+from torchtomo import ParallelBeam, shepp_logan
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+phantom = shepp_logan(size=256, device=device)  # [1, 1, 256, 256]
+projector = ParallelBeam(img_size=256, n_angles=180, n_det=256).to(device)
+
+sinogram = projector.forward(phantom)                 # [1, 1, 180, 256]
+recon = projector.fbp(sinogram, filter_name="ramp")   # [1, 1, 256, 256]
+```
+
+## Fan-Beam Example
+
+```python
+from torchtomo import FanBeam, shepp_logan
+
+phantom = shepp_logan(size=256)
+projector = FanBeam(
+    img_size=256,
+    n_angles=360,
+    n_det=400,
+    src_dist=500.0,
+    det_dist=500.0,
+)
+
+sinogram = projector.forward(phantom)
+recon = projector.fbp(sinogram, filter_name="hann")
+```
+
+## Differentiable Optimization Example
+
+```python
+import torch
+import torch.nn.functional as F
+from torchtomo import ParallelBeam
+
+projector = ParallelBeam(img_size=256, n_angles=180)
+x = torch.zeros(1, 1, 256, 256, requires_grad=True)
+y = torch.randn(1, 1, 180, 256)
+
+loss = F.mse_loss(projector.forward(x), y)
+loss.backward()  # gradients flow through projection operators
+```
+
+## API Snapshot
+
+- `ParallelBeam(...)`
+- `FanBeam(...)`
+- `projector.forward(image)`
+- `projector.backward(sinogram)`
+- `projector.fbp(sinogram, filter_name="ramp")`
+- `apply_filter(sinogram, filter_name=...)`
+- `shepp_logan(size=..., device=...)`
+- `circle_phantom(size=..., n_circles=..., device=...)`
+- `torchtomo.phantom.forbild(size=..., device=...)`
+
+## Tensor Shapes
+
+- Image: `[B, 1, H, W]`
+- Sinogram: `[B, 1, n_angles, n_det]`
+
+## Development
+
+```bash
+git clone https://github.com/itu-biai/torchtomo.git
+cd torchtomo
+pip install -e ".[dev]"
+```
+
+```bash
+make test
+make lint
+make build
+```
+
+## CI/CD
+
+- `.github/workflows/test.yml`: Python test matrix on `push` and `pull_request`
+- `.github/workflows/publish.yml`: release-triggered test matrix and PyPI publish step
+
+## License
+
+MIT

torchtomo-0.1.0/README.md

@@ -0,0 +1,112 @@
+# TorchTomo
+
+[![PyPI](https://img.shields.io/pypi/v/torchtomo.svg)](https://pypi.org/project/torchtomo/)
+[![Changelog](https://img.shields.io/github/v/release/itu-biai/torchtomo?include_prereleases&label=changelog)](https://github.com/itu-biai/torchtomo/releases)
+[![Tests](https://github.com/itu-biai/torchtomo/actions/workflows/test.yml/badge.svg)](https://github.com/itu-biai/torchtomo/actions/workflows/test.yml)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/itu-biai/torchtomo/blob/main/LICENSE)
+
+Differentiable CT reconstruction primitives in pure PyTorch.
+
+TorchTomo provides forward projection, adjoint backprojection, and filtered backprojection for parallel-beam and fan-beam geometries, with support for CPU, CUDA, and Apple Silicon (MPS).
+
+## Features
+
+- Pure PyTorch implementation with no custom CUDA build step
+- Autograd-friendly operators for learned reconstruction pipelines
+- Parallel-beam and fan-beam (flat detector) projectors
+- Built-in FBP filters: `ramp`, `shepp-logan`, `cosine`, `hamming`, `hann`, `none`
+- Built-in phantom generators for quick experiments
+
+## Installation
+
+```bash
+pip install torchtomo
+```
+
+## Quick Start (Parallel Beam)
+
+```python
+import torch
+from torchtomo import ParallelBeam, shepp_logan
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+phantom = shepp_logan(size=256, device=device)  # [1, 1, 256, 256]
+projector = ParallelBeam(img_size=256, n_angles=180, n_det=256).to(device)
+
+sinogram = projector.forward(phantom)                 # [1, 1, 180, 256]
+recon = projector.fbp(sinogram, filter_name="ramp")   # [1, 1, 256, 256]
+```
+
+## Fan-Beam Example
+
+```python
+from torchtomo import FanBeam, shepp_logan
+
+phantom = shepp_logan(size=256)
+projector = FanBeam(
+    img_size=256,
+    n_angles=360,
+    n_det=400,
+    src_dist=500.0,
+    det_dist=500.0,
+)
+
+sinogram = projector.forward(phantom)
+recon = projector.fbp(sinogram, filter_name="hann")
+```
+
+## Differentiable Optimization Example
+
+```python
+import torch
+import torch.nn.functional as F
+from torchtomo import ParallelBeam
+
+projector = ParallelBeam(img_size=256, n_angles=180)
+x = torch.zeros(1, 1, 256, 256, requires_grad=True)
+y = torch.randn(1, 1, 180, 256)
+
+loss = F.mse_loss(projector.forward(x), y)
+loss.backward()  # gradients flow through projection operators
+```
+
+## API Snapshot
+
+- `ParallelBeam(...)`
+- `FanBeam(...)`
+- `projector.forward(image)`
+- `projector.backward(sinogram)`
+- `projector.fbp(sinogram, filter_name="ramp")`
+- `apply_filter(sinogram, filter_name=...)`
+- `shepp_logan(size=..., device=...)`
+- `circle_phantom(size=..., n_circles=..., device=...)`
+- `torchtomo.phantom.forbild(size=..., device=...)`
+
+## Tensor Shapes
+
+- Image: `[B, 1, H, W]`
+- Sinogram: `[B, 1, n_angles, n_det]`
+
+## Development
+
+```bash
+git clone https://github.com/itu-biai/torchtomo.git
+cd torchtomo
+pip install -e ".[dev]"
+```
+
+```bash
+make test
+make lint
+make build
+```
+
+## CI/CD
+
+- `.github/workflows/test.yml`: Python test matrix on `push` and `pull_request`
+- `.github/workflows/publish.yml`: release-triggered test matrix and PyPI publish step
+
+## License
+
+MIT

torchtomo-0.1.0/pyproject.toml

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "torchtomo"
+version = "0.1.0"
+description = "Differentiable CT Reconstruction in Pure PyTorch"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "BIAI Lab" }]
+requires-python = ">=3.9"
+keywords = ["ct", "tomography", "reconstruction", "pytorch", "differentiable", "deep-learning"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Image Processing",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+dependencies = [
+    "torch>=1.10",
+    "numpy",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-cov",
+    "scikit-image",
+]
+dev = [
+    "build",
+    "matplotlib",
+    "pytest",
+    "pytest-cov",
+    "ruff",
+    "scikit-image",
+    "twine",
+]
+
+[project.urls]
+Homepage = "https://github.com/itu-biai/torchtomo"
+Repository = "https://github.com/itu-biai/torchtomo"
+Issues = "https://github.com/itu-biai/torchtomo/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

torchtomo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

torchtomo-0.1.0/src/torchtomo/__init__.py

@@ -0,0 +1,35 @@
+"""
+TorchTomo: Differentiable CT Reconstruction in Pure PyTorch
+
+A lightweight library for CT forward and back projection that works
+on any device (CPU, CUDA, MPS) without compilation.
+
+Example:
+    >>> from torchtomo import ParallelBeam, FanBeam
+    >>>
+    >>> # Parallel beam
+    >>> projector = ParallelBeam(img_size=256, n_angles=180, n_det=256)
+    >>> sinogram = projector.forward(image)
+    >>> recon = projector.fbp(sinogram)
+    >>>
+    >>> # Fan beam
+    >>> projector = FanBeam(img_size=256, n_angles=360, n_det=400,
+    ...                     src_dist=500, det_dist=500)
+    >>> sinogram = projector.forward(image)
+    >>> recon = projector.fbp(sinogram)
+"""
+
+from .fanbeam import FanBeam
+from .filters import apply_filter, get_filter
+from .parallel import ParallelBeam
+from .phantom import circle_phantom, shepp_logan
+
+__version__ = "0.1.0"
+__all__ = [
+    "ParallelBeam",
+    "FanBeam",
+    "apply_filter",
+    "get_filter",
+    "shepp_logan",
+    "circle_phantom",
+]

torchtomo-0.1.0/src/torchtomo/base.py

@@ -0,0 +1,89 @@
+"""Base class for CT projectors."""
+
+from abc import ABC, abstractmethod
+
+import torch
+import torch.nn as nn
+
+
+class BaseProjector(nn.Module, ABC):
+    """
+    Abstract base class for CT projectors.
+
+    All projectors support:
+        - forward(): Image -> Sinogram (Radon transform)
+        - backward(): Sinogram -> Image (Adjoint/back-projection)
+        - fbp(): Filtered back-projection reconstruction
+
+    All operations are differentiable.
+    """
+
+    def __init__(
+        self,
+        img_size: int,
+        n_angles: int,
+        n_det: int,
+        angle_range: tuple[float, float] = (0, torch.pi),
+    ):
+        super().__init__()
+        self.img_size = img_size
+        self.n_angles = n_angles
+        self.n_det = n_det
+        self.angle_range = angle_range
+
+        angles = torch.linspace(
+            angle_range[0], angle_range[1], n_angles, dtype=torch.float32
+        )
+        self.register_buffer("angles", angles)
+
+    @abstractmethod
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward projection: image -> sinogram.
+
+        Args:
+            x: Image tensor of shape [B, 1, H, W]
+
+        Returns:
+            Sinogram of shape [B, 1, n_angles, n_det]
+        """
+        pass
+
+    @abstractmethod
+    def backward(self, sinogram: torch.Tensor) -> torch.Tensor:
+        """
+        Back projection (adjoint): sinogram -> image.
+
+        Note: This is NOT the inverse, just the adjoint operator.
+        For reconstruction, use fbp().
+
+        Args:
+            sinogram: Sinogram of shape [B, 1, n_angles, n_det]
+
+        Returns:
+            Back-projected image of shape [B, 1, H, W]
+        """
+        pass
+
+    @abstractmethod
+    def fbp(self, sinogram: torch.Tensor, filter_name: str = "ramp") -> torch.Tensor:
+        """
+        Filtered back-projection reconstruction.
+
+        Args:
+            sinogram: Sinogram of shape [B, 1, n_angles, n_det]
+            filter_name: Filter type ('ramp', 'shepp-logan', 'cosine',
+                        'hamming', 'hann')
+
+        Returns:
+            Reconstructed image of shape [B, 1, H, W]
+        """
+        pass
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"img_size={self.img_size}, "
+            f"n_angles={self.n_angles}, "
+            f"n_det={self.n_det})"
+        )