commit 5fa7f42453adfb75183e3b5935a9ca7582ccd957 Author: admin Date: Sat Jan 10 13:41:08 2026 +0000 Dateien nach "/" hochladen diff --git a/01_Demons_Theorie_Teil_1-5.md b/01_Demons_Theorie_Teil_1-5.md new file mode 100644 index 0000000..cfff080 --- /dev/null +++ b/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. \ No newline at end of file