torchtomo 0.1.0__py3-none-any.whl

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/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})"
+        )

torchtomo/fanbeam.py

@@ -0,0 +1,383 @@
+"""Fan beam CT projector with flat detector."""
+
+from typing import Optional
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from .base import BaseProjector
+from .filters import FilterType, apply_filter
+
+
+class FanBeam(BaseProjector):
+    """
+    Fan beam CT projector with flat detector.
+
+    In fan beam geometry, X-rays emanate from a point source and spread
+    out in a fan shape to a flat detector array. This is the standard geometry
+    for clinical CT scanners.
+
+    Geometry:
+        - Point source at distance src_dist from origin
+        - Flat detector at distance det_dist from origin (opposite side)
+        - Source and detector rotate around the object
+
+    Example:
+        >>> 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)
+    """
+
+    def __init__(
+        self,
+        img_size: int = 256,
+        n_angles: int = 360,
+        n_det: int = 400,
+        src_dist: float = 500.0,
+        det_dist: float = 500.0,
+        det_width: Optional[float] = None,
+        det_spacing: Optional[float] = None,
+        angle_range: tuple[float, float] = (0, 2 * np.pi),
+        n_samples: int = 512,
+        circle: bool = True,
+    ):
+        """
+        Initialize fan beam projector.
+
+        Args:
+            img_size: Image size (assumed square)
+            n_angles: Number of projection angles
+            n_det: Number of detector elements
+            src_dist: Source to isocenter distance (in pixels)
+            det_dist: Isocenter to detector distance (in pixels)
+            det_width: Total detector width (alternative to det_spacing)
+            det_spacing: Spacing between detector elements (alternative to det_width)
+            angle_range: Range of angles (default: full rotation)
+            n_samples: Number of samples per ray for integration
+            circle: If True, mask image to inscribed circle
+        """
+        super().__init__(img_size, n_angles, n_det, angle_range)
+
+        self.src_dist = src_dist
+        self.det_dist = det_dist
+        magnification = (src_dist + det_dist) / src_dist
+        if det_spacing is not None:
+            self.det_width = det_spacing * n_det
+        elif det_width is not None:
+            self.det_width = det_width
+        else:
+            self.det_width = 1.5 * magnification * img_size
+        self.n_samples = n_samples
+        self.circle = circle
+
+        self.scale = 2.0 / img_size
+        self._src_dist_norm = src_dist * self.scale
+        self._det_dist_norm = det_dist * self.scale
+        self._det_width_norm = self.det_width * self.scale
+
+        ray_grids, ray_lengths = self._precompute_ray_grids()
+        self.register_buffer("ray_grids", ray_grids)
+        self.register_buffer("ray_lengths", ray_lengths)
+
+        back_grids, weights = self._precompute_backward_grids()
+        self.register_buffer("backward_grids", back_grids)
+        self.register_buffer("backward_weights", weights)
+
+        det_pos = torch.linspace(
+            -self._det_width_norm / 2, self._det_width_norm / 2, n_det
+        )
+        D = self._src_dist_norm + self._det_dist_norm
+        cos_weight = D / torch.sqrt(D**2 + det_pos**2)
+        self.register_buffer("cos_weight", cos_weight)
+
+        if circle:
+            coords = torch.linspace(-1, 1, img_size)
+            y, x = torch.meshgrid(coords, coords, indexing="ij")
+            mask = (x**2 + y**2 <= 1).float()
+            self.register_buffer("circle_mask", mask)
+
+    def _precompute_ray_grids(self) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Precompute sampling grids for all rays.
+
+        Returns:
+            grids: [n_angles, n_det, n_samples, 2]
+            ray_lengths: [n_angles, n_det] path length through image for each ray
+        """
+        all_grids = []
+        all_lengths = []
+
+        for angle in self.angles:
+            grid, lengths = self._compute_rays_for_angle(angle)
+            all_grids.append(grid)
+            all_lengths.append(lengths)
+
+        return torch.stack(all_grids), torch.stack(all_lengths)
+
+    def _compute_rays_for_angle(
+        self, angle: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute ray sampling points for a single angle.
+
+        Only samples the portion of each ray that intersects the unit circle
+        (image region in normalized coordinates).
+
+        Returns:
+            grid: [n_det, n_samples, 2]
+            ray_lengths: [n_det] path length through image for each ray
+        """
+        cos_a = torch.cos(angle)
+        sin_a = torch.sin(angle)
+
+        src_x = -self._src_dist_norm * sin_a
+        src_y = self._src_dist_norm * cos_a
+
+        det_cx = self._det_dist_norm * sin_a
+        det_cy = -self._det_dist_norm * cos_a
+
+        det_dir_x = cos_a
+        det_dir_y = sin_a
+
+        det_offsets = torch.linspace(
+            -self._det_width_norm / 2, self._det_width_norm / 2, self.n_det
+        )
+
+        det_x = det_cx + det_offsets * det_dir_x
+        det_y = det_cy + det_offsets * det_dir_y
+
+        dir_x = det_x - src_x
+        dir_y = det_y - src_y
+        ray_len_full = torch.sqrt(dir_x**2 + dir_y**2)
+        dir_x = dir_x / ray_len_full
+        dir_y = dir_y / ray_len_full
+
+        a = dir_x**2 + dir_y**2
+        b = 2 * (src_x * dir_x + src_y * dir_y)
+        c = src_x**2 + src_y**2 - 1.0
+
+        discriminant = b**2 - 4 * a * c
+        discriminant = torch.clamp(discriminant, min=0)
+
+        sqrt_disc = torch.sqrt(discriminant)
+        t_entry = (-b - sqrt_disc) / (2 * a)
+        t_exit = (-b + sqrt_disc) / (2 * a)
+
+        t_entry = torch.clamp(t_entry, min=0)
+        t_exit = torch.clamp(t_exit, min=t_entry)
+
+        ray_lengths = t_exit - t_entry
+
+        t_samples = torch.linspace(0, 1, self.n_samples).view(1, -1)
+        t_actual = t_entry.view(-1, 1) + t_samples * (t_exit - t_entry).view(-1, 1)
+
+        ray_x = src_x + t_actual * dir_x.view(-1, 1)
+        ray_y = src_y + t_actual * dir_y.view(-1, 1)
+
+        grid = torch.stack([ray_x, ray_y], dim=-1)
+
+        return grid, ray_lengths
+
+    def _precompute_backward_grids(self) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Precompute grids and weights for back-projection.
+
+        Returns:
+            grids: [n_angles, H, W, 2] sampling positions in sinogram
+            weights: [n_angles, H, W] distance weighting
+        """
+        grids = []
+        weights = []
+
+        coords = torch.linspace(-1, 1, self.img_size)
+        grid_y, grid_x = torch.meshgrid(coords, coords, indexing="ij")
+
+        for angle in self.angles:
+            grid, weight = self._compute_backward_for_angle(angle, grid_x, grid_y)
+            grids.append(grid)
+            weights.append(weight)
+
+        return torch.stack(grids), torch.stack(weights)
+
+    def _compute_backward_for_angle(
+        self,
+        angle: torch.Tensor,
+        grid_x: torch.Tensor,
+        grid_y: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute back-projection mapping for a single angle.
+
+        For each pixel, determine which detector element it maps to and
+        compute the FBP weight U² where U = D / (D + x*sin(β) - y*cos(β)).
+        """
+        cos_a = torch.cos(angle)
+        sin_a = torch.sin(angle)
+
+        src_x = -self._src_dist_norm * sin_a
+        src_y = self._src_dist_norm * cos_a
+
+        det_cx = self._det_dist_norm * sin_a
+        det_cy = -self._det_dist_norm * cos_a
+
+        px_x = grid_x - src_x
+        px_y = grid_y - src_y
+
+        sd_x = det_cx - src_x
+        sd_y = det_cy - src_y
+        sd_len = torch.sqrt(sd_x**2 + sd_y**2)
+
+        sd_ux = sd_x / sd_len
+        sd_uy = sd_y / sd_len
+
+        proj_len = px_x * sd_ux + px_y * sd_uy
+
+        t = sd_len / (proj_len + 1e-8)
+
+        int_x = src_x + t * px_x
+        int_y = src_y + t * px_y
+
+        det_dir_x = cos_a
+        det_dir_y = sin_a
+
+        det_offset = (int_x - det_cx) * det_dir_x + (int_y - det_cy) * det_dir_y
+
+        det_normalized = det_offset / (self._det_width_norm / 2)
+
+        grid = torch.zeros(self.img_size, self.img_size, 2)
+        grid[..., 0] = det_normalized
+        grid[..., 1] = 0
+
+        D = self._src_dist_norm + self._det_dist_norm
+        U = D / (D + grid_x * sin_a + grid_y * cos_a)
+        weight = U * U
+
+        return grid, weight
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward projection: image -> sinogram.
+
+        Args:
+            x: Image tensor [B, 1, H, W]
+
+        Returns:
+            Sinogram [B, 1, n_angles, n_det]
+        """
+        B = x.shape[0]
+        device = x.device
+
+        if self.circle:
+            x = x * self.circle_mask.view(1, 1, self.img_size, self.img_size)
+
+        projections = []
+
+        for i in range(self.n_angles):
+            grid = self.ray_grids[i]
+            ray_len = self.ray_lengths[i]
+
+            grid = grid.unsqueeze(0).expand(B, -1, -1, -1).to(device)
+
+            samples = F.grid_sample(
+                x,
+                grid,
+                mode="bilinear",
+                padding_mode="zeros",
+                align_corners=True,
+            )
+
+            projection = samples.mean(dim=-1)
+            projection = projection * ray_len.view(1, 1, -1).to(device)
+            projections.append(projection)
+
+        sinogram = torch.stack(projections, dim=2)
+
+        return sinogram
+
+    def backward(self, sinogram: torch.Tensor) -> torch.Tensor:
+        """
+        Back projection (adjoint): sinogram -> image.
+
+        Args:
+            sinogram: Sinogram [B, 1, n_angles, n_det]
+
+        Returns:
+            Back-projected image [B, 1, H, W]
+        """
+        B = sinogram.shape[0]
+        device = sinogram.device
+
+        recon = torch.zeros(B, 1, self.img_size, self.img_size, device=device)
+
+        for i in range(self.n_angles):
+            # Sinogram row [B, 1, 1, n_det]
+            sino_row = sinogram[:, :, i : i + 1, :]
+
+            # Sampling grid
+            grid = self.backward_grids[i].unsqueeze(0).expand(B, -1, -1, -1)
+            grid = grid.to(device)
+
+            # Sample
+            contribution = F.grid_sample(
+                sino_row,
+                grid,
+                mode="bilinear",
+                padding_mode="zeros",
+                align_corners=True,
+            )
+
+            # Apply distance weighting
+            weight = self.backward_weights[i].view(1, 1, self.img_size, self.img_size)
+            weight = weight.to(device)
+
+            recon += contribution * weight
+
+        delta_beta = (self.angle_range[1] - self.angle_range[0]) / self.n_angles
+        recon = recon * delta_beta / 2
+
+        # Circle mask
+        if self.circle:
+            recon = recon * self.circle_mask.view(1, 1, self.img_size, self.img_size)
+
+        return recon
+
+    def fbp(
+        self, sinogram: torch.Tensor, filter_name: FilterType = "ramp"
+    ) -> torch.Tensor:
+        """
+        Filtered back-projection for fan beam with flat detector.
+
+        Args:
+            sinogram: Sinogram [B, 1, n_angles, n_det]
+            filter_name: Filter type
+
+        Returns:
+            Reconstructed image [B, 1, H, W]
+        """
+        cos_w = self.cos_weight.view(1, 1, 1, -1).to(sinogram.device)
+        weighted_sino = sinogram * cos_w
+
+        filtered_sino = apply_filter(weighted_sino, filter_name)
+
+        filtered_sino = filtered_sino * (self.img_size / 2)
+
+        recon = self.backward(filtered_sino)
+
+        return recon
+
+    def __repr__(self) -> str:
+        return (
+            f"FanBeam("
+            f"img_size={self.img_size}, "
+            f"n_angles={self.n_angles}, "
+            f"n_det={self.n_det}, "
+            f"src_dist={self.src_dist}, "
+            f"det_dist={self.det_dist})"
+        )

torchtomo/filters.py

@@ -0,0 +1,102 @@
+"""FBP filters for CT reconstruction."""
+
+from typing import Literal
+
+import numpy as np
+import torch
+import torch.fft as fft
+
+FilterType = Literal["ramp", "shepp-logan", "cosine", "hamming", "hann", "none"]
+
+
+def get_filter(
+    size: int,
+    filter_name: FilterType = "ramp",
+    device: torch.device = None,
+    dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+    """
+    Generate frequency-domain filter for FBP.
+
+    Args:
+        size: Filter size
+        filter_name: Type of filter
+        device: Target device
+        dtype: Data type
+
+    Returns:
+        Filter in frequency domain, shape [size]
+    """
+    if filter_name == "none":
+        return torch.ones(size, device=device, dtype=dtype)
+
+    # Frequency axis: fftfreq gives [-0.5, 0.5) normalized frequencies
+    freq = np.fft.fftfreq(size).astype(np.float64)
+
+    # Ramp filter: |f| scaled to detector spacing
+    # In FBP, the filter is |omega| = 2*pi*|f|, but with discrete sampling
+    # we use |f| directly and scale appropriately
+    ramp = np.abs(freq)
+
+    if filter_name == "ramp":
+        filt = ramp
+    elif filter_name == "shepp-logan":
+        # sinc window (avoids division by zero)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            window = np.sinc(2 * freq)  # sinc(2f) = sin(2*pi*f)/(2*pi*f)
+        filt = ramp * window
+    elif filter_name == "cosine":
+        filt = ramp * np.cos(np.pi * freq)
+    elif filter_name == "hamming":
+        filt = ramp * (0.54 + 0.46 * np.cos(2 * np.pi * freq))
+    elif filter_name == "hann":
+        filt = ramp * (0.5 + 0.5 * np.cos(2 * np.pi * freq))
+    else:
+        raise ValueError(f"Unknown filter: {filter_name}")
+
+    # Convert to torch tensor
+    filt = torch.from_numpy(filt.astype(np.float32)).to(device=device, dtype=dtype)
+
+    return filt
+
+
+def apply_filter(
+    sinogram: torch.Tensor,
+    filter_name: FilterType = "ramp",
+) -> torch.Tensor:
+    """
+    Apply FBP filter to sinogram in frequency domain.
+
+    Args:
+        sinogram: Sinogram of shape [B, 1, n_angles, n_det]
+        filter_name: Type of filter to apply
+
+    Returns:
+        Filtered sinogram of shape [B, 1, n_angles, n_det]
+    """
+    if filter_name == "none":
+        return sinogram
+
+    B, C, n_angles, n_det = sinogram.shape
+    device = sinogram.device
+    dtype = sinogram.dtype
+
+    # Pad to next power of 2 for efficient FFT (and to avoid circular conv)
+    pad_len = max(64, int(2 ** np.ceil(np.log2(2 * n_det))))
+
+    # Get filter
+    filt = get_filter(pad_len, filter_name, device=device, dtype=dtype)
+
+    # FFT of sinogram with zero-padding
+    sino_fft = fft.fft(sinogram, n=pad_len, dim=-1)
+
+    # Apply filter in frequency domain
+    filtered_fft = sino_fft * filt.view(1, 1, 1, -1)
+
+    # Inverse FFT
+    filtered = fft.ifft(filtered_fft, dim=-1).real
+
+    # Crop to original size
+    filtered = filtered[..., :n_det]
+
+    return filtered

torchtomo/parallel.py

@@ -0,0 +1,217 @@
+"""Parallel beam CT projector."""
+
+from typing import Optional
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from .base import BaseProjector
+from .filters import FilterType, apply_filter
+
+
+class ParallelBeam(BaseProjector):
+    """
+    Parallel beam CT projector.
+
+    In parallel beam geometry, all X-rays are parallel for each projection
+    angle. This is the simplest geometry and is used in synchrotron CT.
+
+    Example:
+        >>> projector = ParallelBeam(img_size=256, n_angles=180, n_det=256)
+        >>> sinogram = projector.forward(image)  # [B, 1, 180, 256]
+        >>> recon = projector.fbp(sinogram)      # [B, 1, 256, 256]
+    """
+
+    def __init__(
+        self,
+        img_size: int = 256,
+        n_angles: int = 180,
+        n_det: Optional[int] = None,
+        angle_range: tuple[float, float] = (0, np.pi),
+        circle: bool = True,
+    ):
+        """
+        Initialize parallel beam projector.
+
+        Args:
+            img_size: Image size (assumed square)
+            n_angles: Number of projection angles
+            n_det: Number of detector elements (default: img_size)
+            angle_range: Range of angles in radians (default: 0 to pi)
+            circle: If True, mask image to inscribed circle
+        """
+        n_det = n_det or img_size
+        super().__init__(img_size, n_angles, n_det, angle_range)
+
+        self.circle = circle
+
+        # Pixel size (assuming image spans [-1, 1])
+        self.pixel_size = 2.0 / img_size
+
+        # Precompute rotation grids for forward projection
+        grids = self._precompute_forward_grids()
+        self.register_buffer("forward_grids", grids)
+
+        # Circle mask for reconstruction
+        if circle:
+            coords = torch.linspace(-1, 1, img_size)
+            y, x = torch.meshgrid(coords, coords, indexing="ij")
+            mask = (x**2 + y**2 <= 1).float()
+            self.register_buffer("circle_mask", mask)
+
+    def _precompute_forward_grids(self) -> torch.Tensor:
+        """Precompute sampling grids for forward projection."""
+        grids = []
+
+        for angle in self.angles:
+            grid = self._rotation_grid(angle)
+            grids.append(grid)
+
+        return torch.stack(grids)  # [n_angles, H, W, 2]
+
+    def _rotation_grid(self, angle: torch.Tensor) -> torch.Tensor:
+        """Create sampling grid for rotating image by angle."""
+        cos_a = torch.cos(angle)
+        sin_a = torch.sin(angle)
+
+        # Create normalized coordinate grid [-1, 1]
+        coords = torch.linspace(-1, 1, self.img_size)
+        y, x = torch.meshgrid(coords, coords, indexing="ij")
+
+        # Rotation matrix (rotate coordinates, not image)
+        x_rot = cos_a * x + sin_a * y
+        y_rot = -sin_a * x + cos_a * y
+
+        # Stack to grid format [H, W, 2]
+        grid = torch.stack([x_rot, y_rot], dim=-1)
+
+        return grid
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward projection (Radon transform): image -> sinogram.
+
+        Args:
+            x: Image tensor [B, 1, H, W]
+
+        Returns:
+            Sinogram [B, 1, n_angles, n_det]
+        """
+        B = x.shape[0]
+        device = x.device
+
+        # Apply circle mask if enabled
+        if self.circle:
+            x = x * self.circle_mask.view(1, 1, self.img_size, self.img_size)
+
+        projections = []
+
+        for i in range(self.n_angles):
+            # Get rotation grid for this angle
+            grid = self.forward_grids[i].unsqueeze(0).expand(B, -1, -1, -1)
+            grid = grid.to(device)
+
+            # Rotate image
+            rotated = F.grid_sample(
+                x, grid, mode="bilinear", padding_mode="zeros", align_corners=True
+            )
+
+            # Sum along vertical axis (parallel rays) - this is the line integral
+            # Multiply by pixel size to get proper integral
+            projection = rotated.sum(dim=2) * self.pixel_size  # [B, 1, W]
+
+            projections.append(projection)
+
+        # Stack to sinogram [B, 1, n_angles, n_det]
+        sinogram = torch.stack(projections, dim=2)
+
+        return sinogram
+
+    def backward(self, sinogram: torch.Tensor) -> torch.Tensor:
+        """
+        Back projection (adjoint of Radon transform): sinogram -> image.
+
+        This smears each projection back across the image.
+
+        Args:
+            sinogram: Sinogram [B, 1, n_angles, n_det]
+
+        Returns:
+            Back-projected image [B, 1, H, W]
+        """
+        B = sinogram.shape[0]
+        device = sinogram.device
+
+        recon = torch.zeros(B, 1, self.img_size, self.img_size, device=device)
+
+        for i in range(self.n_angles):
+            angle = self.angles[i]
+            cos_a = torch.cos(angle)
+            sin_a = torch.sin(angle)
+
+            # Image coordinates
+            coords = torch.linspace(-1, 1, self.img_size, device=device)
+            y, x = torch.meshgrid(coords, coords, indexing="ij")
+
+            # Project each pixel onto detector line
+            # t = x * cos(angle) + y * sin(angle)
+            # Note: flip y to match image coordinate convention
+            t = x * cos_a - y * sin_a
+
+            # Create sampling grid for this projection
+            # We need to sample from sinogram row at position t
+            grid = torch.zeros(B, self.img_size, self.img_size, 2, device=device)
+            grid[..., 0] = t  # detector position
+            grid[..., 1] = 0  # single row
+
+            # Get sinogram row [B, 1, 1, n_det]
+            sino_row = sinogram[:, :, i : i + 1, :]
+
+            # Sample and add to reconstruction
+            contribution = F.grid_sample(
+                sino_row,
+                grid,
+                mode="bilinear",
+                padding_mode="zeros",
+                align_corners=True,
+            )
+
+            recon += contribution
+
+        # Normalize by angular spacing (delta_theta)
+        delta_theta = (self.angle_range[1] - self.angle_range[0]) / self.n_angles
+        recon = recon * delta_theta
+
+        # Apply circle mask
+        if self.circle:
+            recon = recon * self.circle_mask.view(1, 1, self.img_size, self.img_size)
+
+        return recon
+
+    def fbp(
+        self, sinogram: torch.Tensor, filter_name: FilterType = "ramp"
+    ) -> torch.Tensor:
+        """
+        Filtered back-projection reconstruction.
+
+        Args:
+            sinogram: Sinogram [B, 1, n_angles, n_det]
+            filter_name: Filter type ('ramp', 'shepp-logan', 'cosine',
+                'hamming', 'hann')
+
+        Returns:
+            Reconstructed image [B, 1, H, W]
+        """
+        # Apply ramp filter in frequency domain
+        filtered_sino = apply_filter(sinogram, filter_name)
+
+        # Scale the filtered sinogram by img_size / 2
+        # This compensates for the pixel_size scaling in forward projection
+        # and the discrete approximation of the FBP integral
+        filtered_sino = filtered_sino * (self.img_size / 2)
+
+        # Back-project
+        recon = self.backward(filtered_sino)
+
+        return recon

torchtomo/phantom.py

@@ -0,0 +1,186 @@
+"""Test phantoms for CT reconstruction."""
+
+from typing import Optional
+
+import numpy as np
+import torch
+
+
+def circle_phantom(
+    size: int = 256,
+    n_circles: int = 5,
+    device: Optional[torch.device] = None,
+) -> torch.Tensor:
+    """
+    Create a simple phantom with random circles.
+
+    Args:
+        size: Image size
+        n_circles: Number of circles
+        device: Target device
+
+    Returns:
+        Phantom image [1, 1, size, size]
+    """
+    coords = torch.linspace(-1, 1, size, device=device)
+    y, x = torch.meshgrid(coords, coords, indexing="ij")
+
+    phantom = torch.zeros(size, size, device=device)
+
+    # Background circle
+    phantom += 0.2 * ((x**2 + y**2) < 0.9).float()
+
+    # Random circles
+    torch.manual_seed(42)
+    for _ in range(n_circles):
+        cx = torch.rand(1).item() * 1.2 - 0.6
+        cy = torch.rand(1).item() * 1.2 - 0.6
+        r = torch.rand(1).item() * 0.2 + 0.05
+        intensity = torch.rand(1).item() * 0.8 + 0.2
+
+        circle = ((x - cx) ** 2 + (y - cy) ** 2) < r**2
+        phantom += intensity * circle.float()
+
+    # Clip to [0, 1]
+    phantom = phantom.clamp(0, 1)
+
+    return phantom.unsqueeze(0).unsqueeze(0)
+
+
+def shepp_logan(
+    size: int = 256,
+    device: Optional[torch.device] = None,
+    modified: bool = True,
+) -> torch.Tensor:
+    """
+    Create the Shepp-Logan phantom.
+
+    The Shepp-Logan phantom is a standard test image for CT reconstruction
+    algorithms. It consists of ellipses simulating a human head.
+
+    Args:
+        size: Image size
+        device: Target device
+        modified: If True, use modified (higher contrast) version
+
+    Returns:
+        Phantom image [1, 1, size, size]
+    """
+    # Ellipse parameters: (intensity, a, b, x0, y0, phi)
+    # a, b = semi-axes, x0, y0 = center, phi = rotation angle
+
+    if modified:
+        # Modified Shepp-Logan with better contrast
+        ellipses = [
+            (1.0, 0.69, 0.92, 0, 0, 0),  # Outer skull
+            (-0.8, 0.6624, 0.874, 0, -0.0184, 0),  # Brain
+            (-0.2, 0.11, 0.31, 0.22, 0, -18),  # Left ventricle
+            (-0.2, 0.16, 0.41, -0.22, 0, 18),  # Right ventricle
+            (0.1, 0.21, 0.25, 0, 0.35, 0),  # Top feature
+            (0.1, 0.046, 0.046, 0, 0.1, 0),  # Small circle 1
+            (0.1, 0.046, 0.046, 0, -0.1, 0),  # Small circle 2
+            (0.1, 0.046, 0.023, -0.08, -0.605, 0),  # Bottom left
+            (0.1, 0.023, 0.023, 0, -0.606, 0),  # Bottom center
+            (0.1, 0.023, 0.046, 0.06, -0.605, 0),  # Bottom right
+        ]
+    else:
+        # Original Shepp-Logan (low contrast)
+        ellipses = [
+            (2.0, 0.69, 0.92, 0, 0, 0),
+            (-0.98, 0.6624, 0.874, 0, -0.0184, 0),
+            (-0.02, 0.11, 0.31, 0.22, 0, -18),
+            (-0.02, 0.16, 0.41, -0.22, 0, 18),
+            (0.01, 0.21, 0.25, 0, 0.35, 0),
+            (0.01, 0.046, 0.046, 0, 0.1, 0),
+            (0.01, 0.046, 0.046, 0, -0.1, 0),
+            (0.01, 0.046, 0.023, -0.08, -0.605, 0),
+            (0.01, 0.023, 0.023, 0, -0.606, 0),
+            (0.01, 0.023, 0.046, 0.06, -0.605, 0),
+        ]
+
+    # Create coordinate grid
+    coords = torch.linspace(-1, 1, size, device=device)
+    y, x = torch.meshgrid(coords, coords, indexing="ij")
+    y = -y  # Flip y to match standard orientation (details at bottom)
+
+    phantom = torch.zeros(size, size, device=device)
+
+    for intensity, a, b, x0, y0, phi in ellipses:
+        phi_rad = phi * np.pi / 180
+
+        # Rotate coordinates
+        cos_p = np.cos(phi_rad)
+        sin_p = np.sin(phi_rad)
+
+        x_rot = cos_p * (x - x0) + sin_p * (y - y0)
+        y_rot = -sin_p * (x - x0) + cos_p * (y - y0)
+
+        # Ellipse equation
+        inside = (x_rot / a) ** 2 + (y_rot / b) ** 2 <= 1
+
+        phantom += intensity * inside.float()
+
+    # Normalize to [0, 1]
+    phantom = (phantom - phantom.min()) / (phantom.max() - phantom.min() + 1e-8)
+
+    return phantom.unsqueeze(0).unsqueeze(0)
+
+
+def forbild(
+    size: int = 256,
+    device: Optional[torch.device] = None,
+) -> torch.Tensor:
+    """
+    Create a simplified FORBILD head phantom.
+
+    A more challenging phantom with fine details for testing
+    resolution and artifact performance.
+
+    Args:
+        size: Image size
+        device: Target device
+
+    Returns:
+        Phantom image [1, 1, size, size]
+    """
+    coords = torch.linspace(-1, 1, size, device=device)
+    y, x = torch.meshgrid(coords, coords, indexing="ij")
+
+    phantom = torch.zeros(size, size, device=device)
+
+    # Outer skull (ellipse)
+    skull = ((x / 0.85) ** 2 + (y / 0.95) ** 2) < 1
+    phantom += 0.2 * skull.float()
+
+    # Brain tissue
+    brain = ((x / 0.75) ** 2 + (y / 0.85) ** 2) < 1
+    phantom += 0.3 * brain.float()
+
+    # Ventricles (pair of ellipses)
+    vent_l = (((x - 0.2) / 0.08) ** 2 + ((y - 0.1) / 0.25) ** 2) < 1
+    vent_r = (((x + 0.2) / 0.08) ** 2 + ((y - 0.1) / 0.25) ** 2) < 1
+    phantom -= 0.3 * (vent_l | vent_r).float()
+
+    # High-contrast inserts (simulating lesions)
+    for i in range(5):
+        cx = 0.4 * np.cos(2 * np.pi * i / 5)
+        cy = 0.4 * np.sin(2 * np.pi * i / 5) - 0.1
+        r = 0.05
+
+        insert = ((x - cx) ** 2 + (y - cy) ** 2) < r**2
+        phantom += 0.5 * insert.float()
+
+    # Fine resolution pattern (line pairs)
+    for i, offset in enumerate([0.6, 0.65, 0.7, 0.75]):
+        width = 0.02 / (i + 1)
+        for j in range(3):
+            cx = offset
+            cy = -0.3 + j * width * 3
+
+            line = (torch.abs(x - cx) < width) & (torch.abs(y - cy) < width)
+            phantom += 0.4 * line.float()
+
+    # Normalize
+    phantom = phantom.clamp(0, 1)
+
+    return phantom.unsqueeze(0).unsqueeze(0)

torchtomo-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+torchtomo/__init__.py,sha256=uCUkgFK14Bf-N23q1_NF6KKZlrTi-5I-z0KBVtsgSws,984
+torchtomo/base.py,sha256=3dkEAxJlFyH1VXSy2IJx-jWSZr8IAa3bmKt3vlrkPQQ,2354
+torchtomo/fanbeam.py,sha256=G9i4ifLl5EcQJy7PtL4P6Ro-mXWPV3eHHcxOMIj93Wo,11922
+torchtomo/filters.py,sha256=lw838cO8PBwTViu5-w86-5HNWiYB846ohPKhubUtSzY,2897
+torchtomo/parallel.py,sha256=HjiXhrB6Y3QDNkbnkBkDXcXDdSv9F0-A_NNV-IfGGjI,7008
+torchtomo/phantom.py,sha256=R1S6Qo9JLfBh2kjfJ8oPf7R0bD2kA-TkKLxjLlBm2xc,5642
+torchtomo-0.1.0.dist-info/licenses/LICENSE,sha256=rcEVLdBpwnZIu9UbcEraWPZRHolsdz2JOW9vLpVH_A8,532
+torchtomo-0.1.0.dist-info/METADATA,sha256=GRnudNy-bBIWlBUApOQbu6PzOXFw_iQM-oUDbj9VTFk,4727
+torchtomo-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+torchtomo-0.1.0.dist-info/top_level.txt,sha256=X2Zh7WpPRwxOyD7lTUs_uVxOyolY4CShibZH0_CB-xM,10
+torchtomo-0.1.0.dist-info/RECORD,,

torchtomo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

torchtomo-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+torchtomo