FDK Algorithm: Cone-Beam CT Reconstruction Explained

The FDK algorithm is the workhorse of cone-beam CT reconstruction — fast, analytically grounded, and still the baseline every deep learning method has to beat. Understanding it deeply is essential for anyone working on CT reconstruction.

---

🧭 Background: What Problem Does FDK Solve?

CT scanners rotate an X-ray source around a patient and measure attenuation projections from many angles. The goal: reconstruct the 3D volume of attenuation coefficients $\mu(x, y, z)$ from those 2D projections.

Two main scanner geometries:

Note: FDK (Feldkamp, Davis & Kress, 1984) extended Filtered Back Projection (FBP) from 2D fan-beam to 3D cone-beam geometry. It's an approximation — exact only at the central plane — but fast and good enough for most clinical applications.

---

📐 Cone-Beam Geometry

flowchart LR
    S(["☀️ X-ray Source"]):::src
    O(["🫀 Object\n(patient)"]):::obj
    D(["🟦 2D Flat-Panel\nDetector"]):::det

    S -->|"cone-beam\nX-rays"| O
    O -->|"attenuated\nprojections"| D

    classDef src fill:#E8A838,stroke:#b07820,color:#fff
    classDef obj fill:#5BA85A,stroke:#3a6e39,color:#fff
    classDef det fill:#4A90D9,stroke:#2c5f8a,color:#fff

Key parameters:

• $D_{SO}$ — source-to-origin (isocentre) distance
• $D_{SD}$ — source-to-detector distance
• $\beta$ — rotation angle of the source around the object
• $(u, v)$ — detector coordinates (u = horizontal, v = vertical/cone)
• $\gamma$ — fan angle, $\delta$ — cone angle

---

🔧 The FDK Algorithm — Step by Step

flowchart TD
    A(["📥 Raw Projections\np(u, v, β)"]):::io
    B["① Weighting\ncos(cone angle)"]:::step
    C["② 1D Ramp Filtering\nalong u (fan direction)"]:::step
    D["③ 3D Cone-Beam\nBack-Projection"]:::step
    E(["📤 Reconstructed\nVolume μ(x,y,z)"]):::io

    A --> B --> C --> D --> E

    classDef io fill:#4A90D9,stroke:#2c5f8a,color:#fff
    classDef step fill:#5BA85A,stroke:#3a6e39,color:#fff

---

Step 1 · Cosine Weighting

Each detector pixel is weighted by the cosine of its cone angle $\delta$:

$$\tilde{p}(u, v, \beta) = \frac{D_{SO}}{\sqrt{D_{SO}^2 + u^2 + v^2}} \cdot p(u, v, \beta)$$

Tip: This compensates for the fact that rays hitting the edge of the detector travel a longer path and arrive at a steeper angle — without this, the reconstruction would be brighter at the centre and dark at the edges.

---

Step 2 · Ramp Filtering

Apply a Ram-Lak (ramp) filter along the $u$-direction of each weighted projection:

$$\hat{p}(u, v, \beta) = \tilde{p}(u, v, \beta) * h(u)$$

Where $h(u)$ is the ramp filter: $H(f) = |f|$ in the frequency domain.

In practice, the ramp filter is windowed (e.g. with a Hamming or Shepp-Logan window) to suppress high-frequency noise:

Tip: The choice of filter window is a classic sharpness-vs-noise tradeoff. For sparse-view CT (fewer projections), heavier windowing helps suppress streak artifacts.

---

Step 3 · Cone-Beam Back-Projection

Each filtered projection is smeared back through 3D space along the original cone-beam ray paths:

$$\mu(x, y, z) = \int_0^{2\pi} \frac{D_{SO}^2}{U(x,y,\beta)^2} \cdot \hat{p}\!\left(\frac{D_{SD}\cdot x'}{U}, \frac{D_{SD}\cdot z}{U}, \beta \right) d\beta$$

Where $U(x, y, \beta) = D_{SO} + x\sin\beta - y\cos\beta$ is the distance from source to the voxel projected onto the source-detector plane.

The $\frac{D_{SO}^2}{U^2}$ term is the distance weighting — it accounts for the diverging cone geometry.

Warning: Back-projection is the computational bottleneck. For a 512×512×512 volume with 1000 projections, naïve back-projection needs ~$10^{11}$ operations. GPU acceleration (CUDA) makes this tractable in seconds.

---

⚡ FDK vs Iterative Reconstruction

---

🩻 FDK in Sparse-View CT (Your FYP Context)

In sparse-view CT, the scanner only captures projections at a subset of angles (e.g. 60 instead of 1000). FDK applied to this data produces severe streak artifacts:

flowchart LR
    SP(["Sparse\nProjections\n(60 angles)"]):::warn
    FDK["FDK\nReconstruction"]:::proc
    NI(["Noisy + Streaky\nCT Volume ⚠️"]):::warn
    UNET["3D U-Net\n(Artifact Removal)"]:::model
    DC["Data-Consistency\nLayer"]:::physics
    CLEAN(["✅ Clean\nCT Volume"]):::good

    SP --> FDK --> NI --> UNET --> DC --> CLEAN

    classDef warn fill:#D97B4A,stroke:#9e5430,color:#fff
    classDef proc fill:#888,stroke:#555,color:#fff
    classDef model fill:#5BA85A,stroke:#3a6e39,color:#fff
    classDef physics fill:#9B6EBD,stroke:#6b4785,color:#fff
    classDef good fill:#4A90D9,stroke:#2c5f8a,color:#fff

FDK serves as the fast baseline input to the deep learning pipeline. The 3D U-Net then learns to undo the artifacts that FDK couldn't avoid.

Tip: Never skip FDK. Even in a deep learning pipeline, using FDK output as input (rather than raw sinogram) gives the network a physically meaningful starting point — convergence is faster and results are better.

---

📉 Limitations of FDK

• Approximate — exact only at the mid-plane ($z = 0$); error grows with cone angle
• Streak artifacts — severe under sparse-view or low-dose conditions
• No noise model — treats all measurements equally, doesn't account for Poisson noise in X-ray photons
• Cone-angle error — for large cone angles (>10°), image quality degrades noticeably at top/bottom slices

Note: For small cone angles (typical in clinical CBCT), the approximation error is negligible. For large-area detectors or C-arm CT, more exact algorithms (Katsevich, Zou-Pan) are preferred.

---

▶️ Video Resources

▶ Watch on YouTube CT Reconstruction & Filtered Back Projection — visual intuition

▶ Watch on YouTube FDK Algorithm Demonstration — backprojection process

---

📄 Further Reading

• Original FDK paper: Feldkamp, Davis & Kress (1984), JOSA A
• Textbook: Kak & Slaney — Principles of Computerized Tomographic Imaging (free PDF online)
• GPU implementation: ASTRA Toolbox — open-source, CUDA-accelerated CT reconstruction

---

💡 One-Sentence Intuition

FDK = weight each projection by cone geometry → ramp-filter to restore sharpness → smear back through 3D space → sum over all angles.

---

Part of my FYP notes series on CT reconstruction. Next: how 3D U-Net learns to undo FDK's streak artifacts.