demons_reg/01_Demons_Theorie_Teil_1-5.md

Dämonenbasierte Bildregistrierung - Grundlagen & Theorie

TEIL 1: Bildregistrierung Grundlagen

Was ist Bildregistrierung?

Problem: Gegeben zwei Bilder - ein festes Bild F und ein bewegtes Bild M - finde eine räumliche Transformation T, die beide Bilder ausrichtet.

Ziel: Minimiere die Ähnlichkeit (normalerweise quadratischer Fehler):

E(T) = ||F(x) - M(T(x))||²

wobei:

• F(x): Intensität des festen Bildes am Ort x
• M(T(x)): Intensität des bewegten Bildes am transformierten Ort T(x)
• x: Pixel-/Voxelposition

Warum Bildregistrierung?

Bildregistrierung ist essentiell in:

• Medizinische Bildgebung: Ausrichtung von CT/MRT-Aufnahmen über Zeit
• Bildverarbeitung: Automatische Strukturerkennung
• Computer Vision: Motion Estimation, Stereo Vision
• Remote Sensing: Satelliten-Bildanalyse

Die Kerneigenschaften der Demons

Der Demons-Algorithmus basiert auf drei Hauptideen:

1. Intensitätserhaltung: Die Annahme ist, dass intensitätsähnliche Punkte korrespondierende anatomische Strukturen sind
2. Optischer Fluss: Die "Kraft" wird aus lokalen Intensitätgradienten berechnet
3. Iterative Regularisierung: Gausssche Glättung nach jeder Iteration

---

TEIL 2: Die Demons-Kraft (Demons Force)

Mathematische Formulierung

An jedem Pixel p wird eine Displacement Field u berechnet, die die Deformation antreibt:

         |F(p) - M∘s(p)|²    · (∇M∘s(p))^T
u(p) = ─────────────────────────────────────────
        ||∇M∘s(p)||² + σ_i²/σ_x²

Worauf diese Formel aufbaut:

• Numerator: Intensitätsdifferenz × Gradient des bewegten Bildes
• Denominator: Normalisierung durch Gradienten-Magnitude und Rausch

Parameter:

• σ_i = |F(p) - M∘s(p)| (lokale Rauschschätzung, wird iterativ berechnet)
• σ_x: Maximale Schrittlänge (kontrolliert ||u(p)|| ≤ σ_x/2), typisch 0.5-2 Pixel

Intuition: Warum funktioniert das?

Die Formel ist clever konstruiert:

1. Wenn Intensitäten unterschiedlich sind (|F(p) - M∘s(p)| groß):

   • Die Kraft ist stark
   • Der Algorithmus macht große Schritte

2. Wenn Gradienten klein sind (flache Region):

   • Der Nenner ist klein → Kraft größer
   • Dies macht den Algorithmus in Bereichen mit schwachen Kanten robust

3. Richtung: Der Gradient ∇M∘s gibt die Bewegungsrichtung vor

   • Die Kraft "schiebt" in die Richtung des stärksten Gradienten

Varianten der Demons-Kraft

Es gibt mehrere Varianten, abhängig von welcher Jacobi-Matrix J_p verwendet wird:

Thirion's Original (bewegtes Bild)

J_p = -∇(M∘s)  (Gauss-Newton Approximation)
u(p) = -[F(p) - M∘s(p)] / (||∇(M∘s)||² + σ²) · ∇(M∘s)^T

Fixed Image Variant (Thirion's Alternative)

J_p = -∇F  (einfacher, aber weniger genau)

Symmetric Forces (ESM - Efficient Second-Order Minimization) - EMPFOHLEN

J_p = -1/2(∇F + ∇(M∘s))  (zweiter Ordnung, schnellere Konvergenz!)
u(p) = [F(p) - M∘s(p)] / (||∇F + ∇(M∘s)||²/4 + σ²) · (∇F + ∇(M∘s))^T

Die symmetrischen Kräfte sind theoretisch und praktisch überlegen!

---

TEIL 3: Der Komplette Algorithmus

Additive Demons (traditionell, ITK-Standard)

Algorithmus: Additive Demons Iterations

Input:  Fixed image F, Moving image M
Output: Displacement field s (kumulativ)

Initialisiere s = 0 (Identität)

FOR iteration = 1 bis max_iterations:
    
    // Schritt 1: Berechne Demons-Kraft an jedem Pixel
    FOR jedes Pixel p:
        Berechne Intensitätsdifferenz:
            diff = F(p) - (M warped mit s)(p)
        
        Berechne Gradienten:
            grad_F = ∇F(p)
            grad_M = ∇(M∘s)(p)
        
        Berechne update (mit Symmtrischen Kräften):
            u(p) = diff / (||grad_F + grad_M||²/4 + σ²) · (grad_F + grad_M)^T
    
    // Schritt 2: Fluid-ähnliche Regularisierung (optional)
    u ← Gaussian_Kernel(σ_fluid) * u
    // σ_fluid typisch 1 Pixel
    
    // Schritt 3: Akkumuliere die Deformation
    s_new = s + u
    
    // Schritt 4: Diffusions-ähnliche Regularisierung (optional)
    s ← Gaussian_Kernel(σ_diff) * s_new
    // σ_diff typisch 1 Pixel

END FOR

Compositive Demons (theoretisch besser)

Der Unterschied: Verwendung von Komposition statt Addition

Algorithmus: Compositive Demons Iterations

Initialisiere s = Id (Identität)

FOR iteration = 1 bis max_iterations:
    
    // Schritt 1-2: Wie in Additive, aber...
    // Schritt 3: Komposition (nicht Addition!)
    c ← s ∘ (Id + u)  // c = s(x + u(x))
    // Das ist geometrisch sauberer!
    
    s ← c (oder mit Regularisierung geglättet)

END FOR

Diffeomorphic Demons (invertierbar, für spezielle Anwendungen)

Verwendet Lie-Gruppe-Struktur und Exponential-Map:

Algoritmus: Diffeomorphic Demons

Initialisiere s = Id

FOR iteration = 1 bis max_iterations:
    
    // Schritt 1-2: Wie vorher
    u ← ... (Demons-Kraft berechnen)
    u ← Gaussian_Kernel * u
    
    // Schritt 3: EXPONENTIAL-Komposition (Lie-Gruppe)
    c ← s ∘ exp(u)
    // exp(u) wird mit Scaling & Squaring berechnet
    
    // Exponentiale approximieren mit:
    N = ceil(log2(max||u(p)||/0.5))
    v = u / 2^N
    FOR i = 1 bis N:
        v = v ∘ v
    s = v

END FOR

---

TEIL 4: Implementierungsdetails

Bildinterpolation

Problem: T(p) ist oft nicht auf Gitterpunkten. Lösung: Interpolation

Häufige Methoden:
- Linear interpolation: Schnell, ausreichend für die meisten Fälle
- B-spline: Glatter, aber langsamer
- Nearest neighbor: Schnell, aber grob

Multi-resolution (Pyramiden)

Für große Verformungen:

1. Berechne Bildpyramide: Level 8→4→2→1 (Downsampling)
2. Registriere auf grobster Ebene (schnell, globale Deformation)
3. Verfeinere auf feiner Ebene (lokal, Details)

Konvergenzkriterien

Iterationen abbrechen wenn:
- Max iterations erreicht (typisch 100-500)
- Mittlere Verschiebung < Schwellwert (z.B. 0.1 Pixel)
- MSE-Verbesserung < Schwellwert

---

TEIL 5: Praktische Tipps

Parameter tuning

σ_fluid (Fluid-Regularisierung):  0.5 - 2.0 Pixel
σ_diff (Diffusions-Regularisierung): 0.5 - 2.0 Pixel
σ_x (Max Schrittlänge): 0.5 - 2.0 Pixel

Standard-Startwerte: σ_fluid = 1, σ_diff = 1, σ_x = 2

Fehlerquellen

1. Zu starke Regularisierung: Glatt, aber ungenau
2. Zu schwache Regularisierung: Faltig, potentiell nicht-invertierbar
3. Falsche Bildinterpolation: Artefakte
4. Zu große Schritte: Divergenz
5. Multi-resolution nicht verwendet: Schlechte Konvergenz bei großen Deformationen

Wann Demons verwenden?

✅ GUT für:

• Monomodale Registrierung (CT-CT, MRT-MRT)
• Schnelle Verarbeitung notwendig
• Iterative Anwendungen
• 2D und 3D

❌ WENIGER GUT für:

• Multimodale Registrierung (CT-MRT) → verwende Varianten mit anderer Metrik
• Sehr große Deformationen ohne Multi-resolution
• Wenn garantierte Invertierbarkeit erforderlich ist → verwende Diffeomorphic Demons

---

Zusammenfassung: Die Demons-Registrierung ist ein eleganter und effizienter Algorithmus, der auf lokalen Intensitätsgradienten und iterativer Regularisierung basiert. Die symmetrischen Kräfte bieten dabei die beste Balance zwischen Schnelligkeit und Genauigkeit.