# 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.