Separable Footprint Projector Model for CT

• The SF projector model is a computed tomography simulation algorithm that approximates voxel-detector mapping via separable 1D kernels.
• It employs a two-pass separable convolution structure that decomposes projections along the u and v axes for precise and fast computation.
• Integrated into CTorch with GPU acceleration and PyTorch auto-differentiation, it balances accuracy with computational efficiency for iterative reconstruction.

The Separable Footprint (SF) projector model is an algorithmic formulation for simulating the forward and backward projection operations in computed tomography (CT), with particular focus on efficient and accurate modeling of the mapping between volumetric voxels and detector measurements in 2D and 3D CT geometries. The SF approach approximates the geometrically accurate projection of a finite-sized voxel onto a detecting surface as a separable product of two one-dimensional (1D) kernels, providing a computationally tractable yet accurate alternative to other projector classes. CTorch implements the SF projector as a GPU-accelerated, auto-differentiable module, enabling integration with deep-learning and iterative reconstruction workflows through its PyTorch interface (Jiang et al., 20 Mar 2025).

1. Mathematical Foundations

The SF projector is grounded in the continuous-to-discrete modeling of X-ray forward projection. For a 3D object with attenuation map $x(\mathbf{r})$, the intensity detected at a particular detector coordinate $(u,v)$ and gantry angle $\theta$ is given by integrating the volume along an X-ray path parameterized by $t$:

$$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$

For each cubic voxel $(i, j, k)$, the geometric projection onto the detector is, in principle, a two-dimensional (2D) footprint defined by

$$W_{i,j,k}(u,v) = \iint_{(x,y,z) \in \text{voxel}_{i,j,k}} \delta(u-u(x,y,z;\theta)) \delta(v-v(x,y,z;\theta))\,dx\,dy\,dz$$

The SF approach replaces the direct high-dimensional computation of $W_{i,j,k}(u,v)$ with a separable approximation:

$$W_{i,j,k}(u,v) \approx W_u^{(i,j,k)}(u)\cdot W_v^{(i,j,k)}(v)$$

where $W_u^{(i,j,k)}(u)$ and $(u,v)$0 are the voxel’s 1D footprint kernels along the $(u,v)$1 and $(u,v)$2 axes, respectively, and reflect integrals at fixed $(u,v)$3 and $(u,v)$4.

The discrete SF forward-projection maps a voxel volume $(u,v)$5 to a sinogram $(u,v)$6:

$(u,v)$7

where $(u,v)$8 is the projected center of each voxel and $(u,v)$9 are detector pixel centers.

2. Algorithmic Structure and Pseudocode

The SF projector algorithm employs a two-pass, separable convolution structure for both forward- and backprojection:

2.1. Forward Projection (SF)

First, the projection is carried out as convolution along the $\theta$0 direction, forming an intermediate 3D buffer $\theta$1. Then, convolution along the $\theta$2 direction produces the final sinogram $\theta$3. The core pseudocode is:

$$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$9

2.2. Backprojection (SF)

The backprojection process is the adjoint, first distributing along $\theta$4 (building $\theta$5), then along $\theta$6 to recover $\theta$7:

$(i, j, k)$0

Loop fusion and careful indexing are used in practice to optimize memory usage and computational efficiency.

3. GPU Acceleration and Implementation

The CTorch SF projector is implemented with two CUDA kernels per view for both forward and backward passes:

• SF_FP_U (forward, pass 1): Grid assigns blockIdx.x to voxel columns $\theta$8 (or $\theta$9 tiles), blockIdx.y to slice $t$0. Threads handle $t$1-pixel index $t$2 and $t$3-index. Each thread loads the $t$4 coefficients for its voxel from constant memory and accumulates $t$5 in a global intermediate buffer $t$6.
• SF_FP_V (forward, pass 2): Grid assigns blockIdx.x to $t$7-pixel $t$8, blockIdx.y to $t$9 tile. Threads operate over $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$0-pixel $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$1 and $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$2-index. Each thread loads $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$3 into shared memory and convolve with $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$4, writing to $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$5.
• Backward pass kernels (SF_BP_V, SF_BP_U) mirror the accumulation steps for gradient computation.

Memory optimizations include precomputing all possible $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$6 and $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$7 kernel values per view and storing them in CUDA constant memory (enabling efficient broadcast), binding the input volume $$y(\theta,u,v) = \int_{t_\text{min}}^{t_\text{max}} x\bigl(\mathbf{r}_s(\theta) + t(\mathbf{r}_d(\theta,u,v) - \mathbf{r}_s(\theta))\bigr)\;dt$$8 to a 3D texture reference for automatic caching and interpolation, and tiling intermediates in shared memory to minimize global memory traffic.

4. PyTorch Integration and Auto-Differentiation

The SF projector in CTorch is wrapped as a PyTorch network module, exposing both the forward and custom backward operations as Python-callable functions. All inputs and outputs are native PyTorch tensors, allowing seamless autograd integration in deep learning pipelines. The custom gradient (adjoint) logic in the SF backprojection ensures correctness for gradient-based optimization and learning-based reconstruction tasks (Jiang et al., 20 Mar 2025).

5. Performance, Accuracy, and Trade-Offs

The SF projector is distinguished by a balance between computational efficiency and projection accuracy. Compared to the ray-driven (RD) and distance-driven (DD) projectors, the SF model avoids the need for explicit high-dimensional voxel-detector intersection calculations by exploiting the separability approximation. This reduces computation time relative to full 2D footprint convolution while retaining essential volume-to-detector mapping fidelity. All four projector classes (voxel-driven, ray-driven, DD, SF) are available in CTorch, allowing users to select the optimal trade-off for specific numerical or simulation needs.

A plausible implication is that for iterative and learning-based reconstruction, where repeated projection and backprojection steps dominate runtime, the SF projector permits effective scaling to 3D and high-resolution geometries without prohibitive computational or memory burdens.

6. Applications and Context

The SF projector model, particularly as implemented in CTorch, supports a wide range of scanner geometries including 2D fan-beam, 3D circular cone-beam, and 3D non-circular cone-beam. Detector models may be flat or curved, capturing the diversity in clinical CT scanner hardware. The flexible geometry definition supports view-specific adjustments to accommodate real-world scanner variation.

Through efficient, auto-differentiable GPU-acceleration, the SF projector enables high fidelity CT simulations, accurate forward models for algorithmic development, and state-of-the-art iterative and deep-learning-based reconstruction approaches, serving as a foundational tool for contemporary tomographic research (Jiang et al., 20 Mar 2025).