258 lines
7.2 KiB
Markdown
258 lines
7.2 KiB
Markdown
# 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. |