🔢 mathematics

Convergence of Ray- and Pixel-Driven Discretization Frameworks in the Strong Operator Topology

This paper theoretically justifies the common practice of combining ray-driven Radon transforms with pixel-driven backprojections in CT imaging by interpreting them as convolutional methods and proving their convergence in the strong operator topology under balanced spatial, detector, and angular resolutions.

Original authors: Richard Huber

Published 2026-02-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Richard Huber

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to figure out what's inside a sealed, opaque box without opening it. You can't see the inside, but you can shine a flashlight through it from every possible angle and measure how much light gets blocked. This is essentially how Computed Tomography (CT) works in hospitals: it takes X-rays from all angles to build a 3D picture of your insides.

Mathematically, this process is described by something called the Radon Transform. Think of the Radon Transform as the "perfect, magical recipe" that tells you exactly how to turn those light measurements into a clear picture of the object.

However, computers aren't magical. They are digital. They can't handle infinite, smooth lines or perfect curves; they only understand a grid of tiny squares (pixels), like a mosaic or a low-resolution video game.

The Problem: The "Pixelated" Mess

To make the computer do the math, scientists have to break the perfect "magic recipe" down into steps the computer can follow. This is called discretization.

There are two main ways to do this, and for decades, doctors and engineers have been mixing and matching them based on "gut feeling" (anecdotal evidence) rather than hard math:

The Ray-Driven Method (The "Laser Pointer"): Imagine shooting a laser beam through the object. You calculate how much of the beam hits each pixel. It's like tracing a line and seeing which tiles it crosses.
The Pixel-Driven Method (The "Flood Fill"): Imagine looking at a single pixel and asking, "Which laser beams pass through me?" You then spread that pixel's value out to the nearest measurement points.

The "Mismatched" Strategy

Here is the weird part: In the real world, the most accurate results usually come from mixing these two methods.

You use the Ray-Driven method to simulate the X-rays going through the object (Forward).
You use the Pixel-Driven method to reconstruct the image from the measurements (Backward).

It's like using a left-handed screwdriver to tighten a screw and a right-handed wrench to loosen it. It feels wrong because they don't match, yet everyone agrees it produces the best picture. The problem was: Why does this work? Is it just luck, or is there a solid reason?

The Paper's Big Discovery

Richard Huber, the author of this paper, decided to stop guessing and start proving. He treated these computer methods not just as messy code, but as precise mathematical machines (operators).

He proved that if you make the pixels small enough (high resolution), this "mismatched" combination actually converges to the perfect, magical recipe.

Here is the simple breakdown of his findings:

The "Balanced" Resolution: Usually, we make the pixels in the image and the pixels on the detector the same size (like a square grid).
The Proof: Huber showed that if you keep the pixel sizes balanced but make them smaller and smaller, the "Ray-Forward / Pixel-Backward" combo gets closer and closer to the perfect truth.
The "Unmatched" Advantage: He also showed that if you try to match them (Ray-Forward / Ray-Backward), you might actually get stuck with errors that don't go away, even with tiny pixels. The "mismatched" pair is actually the stable, reliable one.

A Creative Analogy: The Jigsaw Puzzle

Imagine you are trying to recreate a famous painting (the patient's body) using a jigsaw puzzle.

The Perfect World: The painting is a smooth, continuous masterpiece.
The Ray-Driven Approach: You look at the painting and say, "If I draw a straight line across this section, how much red paint does it cross?" You are measuring the lines.
The Pixel-Driven Approach: You look at a single puzzle piece and say, "If I place this piece here, how much does it contribute to the lines I measured?" You are distributing the blocks.

For a long time, people thought, "If I use the same logic for both measuring and placing, it should be perfect." But Huber proved that in the digital world, using different logic for measuring (lines) and placing (blocks) actually creates a better fit. It's like using a ruler to measure the wood but a saw designed for the grain to cut it. They are different tools, but together they build a perfect table.

Why This Matters

Validation: It stops the medical community from relying on "it works because it always has." Now they have a mathematical guarantee that this method is safe and accurate.
Better Images: It confirms that we don't need to invent complex new algorithms; we just need to keep refining the resolution of the tools we already use.
Efficiency: It tells engineers, "Don't waste time trying to make the forward and backward steps identical. Keep them different, and you'll get better results."

The Bottom Line

This paper is the "receipt" that proves the "mismatched" method is actually the correct way to build digital CT scans. It turns a decades-old "best practice" based on trial and error into a solid, proven scientific fact. It assures us that as computers get faster and pixels get smaller, our medical images will get clearer and more reliable, not because of magic, but because of math.

1. Problem Statement

Computed Tomography (CT) reconstruction relies on the Radon transform ( $R$ ) and its adjoint, the backprojection ( $R^*$ ). In practical applications, these infinite-dimensional operators must be discretized to process finite data.

The Discretization Dilemma: The most common practical approach combines a ray-driven forward projection (integrating line intersections with pixels) with a pixel-driven backprojection (interpolating detector values). While anecdotal evidence suggests this "unmatched" pair ($rd$- $pd^*$ ) yields the best reconstruction quality, there has been a lack of rigorous mathematical justification.
Theoretical Gap: Standard iterative reconstruction algorithms often require the forward and backward operators to be exact adjoints (matched pairs, e.g., $rd$- $rd^*$ or $pd$- $pd^*$ ) to guarantee convergence. Using unmatched pairs ($rd$- $pd^*$ ) theoretically risks non-convergence or slow convergence.
Resolution Constraints: Previous rigorous convergence proofs (e.g., in [5]) only applied to unbalanced resolutions where the spatial resolution ( $\delta_x$ ) is asymptotically smaller than the detector resolution ( $\delta_s$ ). However, in practice, balanced resolutions ( $\delta_x \approx \delta_s$ ) are the standard. It was unclear if the popular $rd$- $pd^*$ approach converges under these balanced conditions.

2. Methodology

The author reframes the discretization schemes as finite-rank operators defined via convolutional weight functions. This allows for a structured analysis within the framework of functional analysis.

Convolutional Discretization:
- Ray-Driven ( $R^{rd}_\delta$ ): The weight function $\omega^{rd}_{\delta_x}$ is derived from the intersection length of a ray with a pixel. It acts as a trapezoidal (or hat) function depending on the angle.
- Pixel-Driven ( $R^{pd}_\delta$ ): The weight function $\omega^{pd}_{\delta_s}$ is based on linear interpolation (anterpolation) on the detector. It acts as a hat function independent of the angle.
Operator Definitions: The discretized operators are defined as mappings between $L^2$ spaces of piecewise constant functions (pixel grids). The matrix entries are explicitly defined by these weight functions evaluated at geometric positions.
Convergence Analysis: The paper investigates convergence in the Strong Operator Topology (SOT), meaning pointwise convergence for any fixed function $f$ $f$ or $g$ $g$ as the discretization parameters $\delta \to 0$ $δ \to 0$ .
- The analysis utilizes Taylor's theorem to estimate errors for smooth functions.
- It employs a diagonal argument combined with uniform boundedness (proven via Jensen's inequality and specific weight sum estimates) to extend results from smooth, compactly supported functions to general $L^2$ functions.
Key Lemmas:
- Exactness: The ray-driven transform is exact on piecewise constant functions when evaluated at pixel centers.
- Weight Sums: The paper derives bounds on the sums of weights. Crucially, it shows that for ray-driven backprojection, the sum of weights converges to $1/\delta_s$ only if $\delta_s/\delta_x \to 0$ , whereas for pixel-driven backprojection, the sum equals $1/\delta_s$ exactly (within the detector range) regardless of the ratio.

3. Key Contributions

Theoretical Justification of $rd$- $pd^*$ : The paper proves that the ray-driven forward transform and pixel-driven backprojection converge in the Strong Operator Topology under balanced resolutions ( $\delta_x \approx \delta_s$ ). This provides the first rigorous theoretical backing for the industry-standard practice of using this unmatched pair.
Convergence Conditions for Mismatched Pairs:
- Ray-Driven Backprojection ( $R^{rd*}_\delta$ ): Proven to converge to $R^*$ only if the resolution is unbalanced ( $\delta_s \ll \delta_x$ ). Under balanced resolutions, it does not converge, explaining why $rd$- $rd^*$ is often problematic.
- Pixel-Driven Radon Transform ( $R^{pd}_\delta$ ): Proven to converge to $R$ only if unbalanced ( $\delta_x \ll \delta_s$ ). Under balanced resolutions, it fails to converge uniformly for all angles (specifically failing at multiples of $\pi/4$ ).
Unified Framework: By interpreting discretizations as convolutional operators, the author unifies the analysis of different schemes, allowing for precise error estimation and convergence proofs that were previously missing.
Limited and Sparse Angle Extensions: The results are extended to limited-angle tomography and sparse-angle settings, showing that the convergence properties hold even when the angular domain is restricted.

4. Results

Theorem 3.1 (Main Result):
- If $\delta_s / \delta_x \leq c$ (balanced), $R^{rd}_\delta \to R$ (Strong Convergence).
- If $\delta_x / \delta_s \leq c$ (balanced), $R^{pd*}_\delta \to R^*$ (Strong Convergence).
- If $\delta_s / \delta_x \to 0$ (unbalanced), $R^{rd*}_\delta \to R^*$ .
- If $\delta_x / \delta_s \to 0$ (unbalanced), $R^{pd}_\delta \to R$ .
Numerical Experiments:
- Forward Projection: Using a FORBILD head phantom, the pixel-driven method showed significantly lower errors than the ray-driven method for most angles in balanced settings. However, the pixel-driven method exhibited severe oscillations (artifacts) at specific angles (multiples of $\pi/4$ ) that did not vanish with increased resolution, confirming the theoretical lack of convergence for $R^{pd}$ in balanced settings.
- Backprojection: For a constant sinogram, the pixel-driven backprojection yielded the exact analytical result ( $\pi$ ) almost everywhere. In contrast, the ray-driven backprojection showed persistent oscillatory errors in balanced settings ( $\delta_s \approx \delta_x$ ) that only diminished when $\delta_s \ll \delta_x$ .
- Error Metrics: The experiments confirmed that while $rd$- $pd^*$ is the robust choice for balanced resolutions, using matched pairs ($rd$- $rd^*$ or $pd$- $pd^*$ ) in balanced settings leads to non-convergent behavior in one of the operators.

5. Significance

Bridging Theory and Practice: This work resolves the long-standing discrepancy between theoretical requirements (matched adjoints) and practical success (unmatched $rd$- $pd^*$ ). It proves that for balanced resolutions, the "unmatched" pair is actually the only combination where both operators converge to their continuous counterparts.
Guidance for Algorithm Design: The results suggest that iterative solvers using $rd$- $pd^*$ are theoretically sound because the operators converge pointwise, even if they are not exact adjoints. Conversely, using matched pairs in balanced settings is theoretically flawed because at least one operator fails to converge.
Future Directions: The paper opens avenues for investigating convergence in the Operator Norm (uniform convergence) for unbalanced settings and extending these convolutional discretization proofs to fan-beam and cone-beam geometries.

In summary, Huber provides the rigorous mathematical foundation confirming that the heuristic choice of combining ray-driven forward projection with pixel-driven backprojection is not just empirically effective, but theoretically necessary for convergence in standard, balanced-resolution CT imaging.