Dateien nach "/" hochladen

01_Demons_Theorie_Teil_1-5.md

@@ -0,0 +1,258 @@
+# 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.