Gabor-Filter

Ein Gabor-Filter ist ein in der Bildverarbeitung und der Signalverarbeitung benutzter Filter. Er ist nach Dennis Gabor benannt, der ihn als 1D-Filter für die Signalverarbeitung vorschlug.^[1]

Beispiel eines 2D-Gabor-Filters

Das Gabor-Filter wurde von Gösta Granlund auf die Anwendung für 2D-Bilder verallgemeinert.^[2]

Das Gabor-Filter ist ein linearer Filter und wird vielfach in der Kantendetektion und Bildstrukturanalyse verwendet.

Hierbei werden wiederkehrende Strukturen um einen Punkt mittels Frequenzanalyse erkannt. Die Art und Weise, wie das visuelle System von Säugetieren arbeitet, ähnelt dem Gabor-Filter.^[3]

Es wird erforscht, ob der Visuelle Cortex von Säugetierhirnen mittels Gabor-Funktionen modelliert werden kann.^[4][5]

In der 2D-Anwendung ist der Gabor-Filter ein mit einer Sinus-Welle modulierter Gauß-Kernel (siehe Gabor-Transformation).

Definition

Die Impulsantwort des Filters wird durch die Multiplikation eines Sinusoids und einer Gauß-Funktion bestimmt.^[6]

Der Filter hat einen realen und einen imaginären Anteil, welche orthogonal zueinander stehen.^[7] Dies erlaubt die Nutzung als komplexe Zahl oder in zerlegte reale und imaginäre Komponenten.

Komplex:

${\displaystyle g(x,y;\lambda ,\theta ,\psi ,\sigma ,\gamma )=\exp \left(-{\frac {x'^{2}+\gamma ^{2}y'^{2}}{2\sigma ^{2}}}\right)\exp \left(i\left(2\pi {\frac {x'}{\lambda }}+\psi \right)\right)}$

Real:

${\displaystyle g(x,y;\lambda ,\theta ,\psi ,\sigma ,\gamma )=\exp \left(-{\frac {x'^{2}+\gamma ^{2}y'^{2}}{2\sigma ^{2}}}\right)\cos \left(2\pi {\frac {x'}{\lambda }}+\psi \right)}$

Imaginär:

${\displaystyle g(x,y;\lambda ,\theta ,\psi ,\sigma ,\gamma )=\exp \left(-{\frac {x'^{2}+\gamma ^{2}y'^{2}}{2\sigma ^{2}}}\right)\sin \left(2\pi {\frac {x'}{\lambda }}+\psi \right)}$

mit ${\displaystyle x'=x\cos \theta +y\sin \theta }$ und ${\displaystyle y'=-x\sin \theta +y\cos \theta }$.

Hierbei ist ${\displaystyle \lambda }$ die Wellenlänge des Sinus, ${\displaystyle \theta }$ ist die Orientierung der Gabor-Funktion zur Normalen. ${\displaystyle \psi }$ ist die Phasenverschiebung, ${\displaystyle \sigma }$ ist die Standardabweichung der umhüllenden Gaussverteilung und ${\displaystyle \gamma }$ ist das Seitenverhältnis des Kernels und bestimmt die Exzentrizität der Kernel-Funktion.

Feature Extraktion aus Bildern

Eine Filterbank aus mehreren Gabor-Filtern mit unterschiedlichen Frequenzen und Orientierungen kann benutzt werden, um verschiedene Merkmale (Features) in einem Bild zu erkennen.^[8]

In der Texterkennung sind Gabor-Filter geeignet, um Schriftzeichen in mehrsprachigen Dokumenten zu erkennen.^[9] Gabor-Filter mit verschiedenen Frequenzen und Orientierungen können benutzt werden, um Textfelder aus komplexen ein- und mehrfarbigen Dokumenten-Scans zu extrahieren, da Text im Vergleich zu Bildern oder Zeichnungen mehr hochfrequente Anteile besitzt.^[10][11] Weitere Anwendungen besitzt der Filter in der Emotionserkennung^[12] und der Mustererkennung in der Medizin.^[13] Weitere Anwendungsbereiche im Bereich Bilderkennung sind die Iris-Erkennung, die Erkennung von Fingerabdrücken und Landnutzungsklassifizierung von Satellitendaten.^[14]

Beispiel Implementationen

Dies ist eine Beispiel-Implementierung in Python:

import numpy as np


def gabor(sigma, theta, Lambda, psi, gamma):
    """Gabor Feature extraktion."""
    sigma_x = sigma
    sigma_y = float(sigma) / gamma

    # Bounding box
    nstds = 3  # Anzahl der Standardabweichung sigma
    xmax = max(
        abs(nstds * sigma_x * np.cos(theta)), abs(nstds * sigma_y * np.sin(theta))
    )
    xmax = np.ceil(max(1, xmax))
    ymax = max(
        abs(nstds * sigma_x * np.sin(theta)), abs(nstds * sigma_y * np.cos(theta))
    )
    ymax = np.ceil(max(1, ymax))
    xmin = -xmax
    ymin = -ymax
    (y, x) = np.meshgrid(np.arange(ymin, ymax + 1), np.arange(xmin, xmax + 1))

    # Rotation
    x_theta = x * np.cos(theta) + y * np.sin(theta)
    y_theta = -x * np.sin(theta) + y * np.cos(theta)

    gb = np.exp(
        -0.5 * (x_theta**2 / sigma_x**2 + y_theta**2 / sigma_y**2)
    ) * np.cos(2 * np.pi / Lambda * x_theta + psi)
    return gb

Für eine Anwendung in der Bildverarbeitung.^[15]

Ein MATLAB/Octave Beispiel:

function gb=gabor_fn(sigma, theta, lambda, psi, gamma)

sigma_x = sigma;
sigma_y = sigma / gamma;

% Bounding box
nstds = 3;
xmax = max(abs(nstds * sigma_x * cos(theta)), abs(nstds * sigma_y * sin(theta)));
xmax = ceil(max(1, xmax));
ymax = max(abs(nstds * sigma_x * sin(theta)), abs(nstds * sigma_y * cos(theta)));
ymax = ceil(max(1, ymax));
xmin = -xmax; ymin = -ymax;
[x,y] = meshgrid(xmin:xmax, ymin:ymax);

% Rotation
x_theta = x * cos(theta) + y * sin(theta);
y_theta = -x * sin(theta) + y * cos(theta);

gb = exp(-.5*(x_theta.^2/sigma_x^2+y_theta.^2/sigma_y^2)).*cos(2*pi/lambda*x_theta+psi);

Code für Gabor Feature Extraction aus Bildern in MATLAB:^[16]

Ein Beispiel in Haskell:

import Data.Complex
gabor λ θ ψ σ γ x y = exp(-(x'^2 + γ^2 * y'^2) / (2*σ^2)) * exp(i * (2*pi*x'/λ + ψ))
    where x' =  x * cos θ + y * sin θ
          y' = -x * sin θ + y * cos θ
          i  = 0 :+ 1

Siehe auch

• Gabor-Transformation