Gabor filter

This article may be too technical for most readers to understand. Please help improve it to make it understandable to non-experts, without removing the technical details. (February 2017) (Learn how and when to remove this template message)

In

).

Some authors claim that simple cells in the

human visual system

.

Definition

This section's factual accuracy is disputed. Relevant discussion may be found on the talk page. Please help to ensure that disputed statements are reliably sourced. (February 2013) (Learn how and when to remove this template message)

Its impulse response is defined by a sinusoidal wave (a plane wave for 2D Gabor filters) multiplied by a Gaussian function.^[6] Because of the multiplication-convolution property (

or used individually.

Complex

${\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)}$

Imaginary

${\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)}$

where ${\displaystyle x'=x\cos \theta +y\sin \theta }$ and ${\displaystyle y'=-x\sin \theta +y\cos \theta }$.

In this equation, ${\displaystyle \lambda }$ represents the wavelength of the sinusoidal factor, ${\displaystyle \theta }$ represents the orientation of the normal to the parallel stripes of a

Gabor function

, ${\displaystyle \psi }$ is the phase offset, ${\displaystyle \sigma }$ is the sigma/standard deviation of the Gaussian envelope and ${\displaystyle \gamma }$ is the spatial aspect ratio, and specifies the ellipticity of the support of the Gabor function.

Wavelet space

Gabor filters are directly related to Gabor wavelets, since they can be designed for a number of dilations and rotations. However, in general, expansion is not applied for Gabor wavelets, since this requires computation of bi-orthogonal wavelets, which may be very time-consuming. Therefore, usually, a filter bank consisting of Gabor filters with various scales and rotations is created. The filters are convolved with the signal, resulting in a so-called Gabor space. This process is closely related to processes in the primary visual cortex.^[8] Jones and Palmer showed that the real part of the complex Gabor function is a good fit to the receptive field weight functions found in simple cells in a cat's striate cortex.^[9]

Time-causal analogue of the Gabor filter

When processing temporal signals, data from the future cannot be accessed, which leads to problems if attempting to use Gabor functions for processing real-time signals that depend on the temporal dimension. A time-causal analogue of the Gabor filter has been developed in ^[10] based on replacing the Gaussian kernel in the Gabor function with a time-causal and time-recursive kernel referred to as the time-causal limit kernel. In this way, time-frequency analysis based on the resulting complex-valued extension of the time-causal limit kernel makes it possible to capture essentially similar transformations of a temporal signal as the Gabor filter can, and as can be described by the Heisenberg group, see ^[10] for further details.

Extraction of features from images

A set of Gabor filters with different frequencies and orientations may be helpful for extracting useful features from an image.^[11] In the discrete domain, two-dimensional Gabor filters are given by,

${\displaystyle G_{c}[i,j]=Be^{-{\frac {(i^{2}+j^{2})}{2\sigma ^{2}}}}\cos(2\pi f(i\cos \theta +j\sin \theta ))}$

${\displaystyle G_{s}[i,j]=Ce^{-{\frac {(i^{2}+j^{2})}{2\sigma ^{2}}}}\sin(2\pi f(i\cos \theta +j\sin \theta ))}$

where B and C are normalizing factors to be determined.

2D Gabor filters have rich applications in image processing, especially in

${\displaystyle f}$ defines the frequency being looked for in the texture. By varying ${\displaystyle \theta }$, we can look for texture oriented in a particular direction. By varying ${\displaystyle \sigma }$, we change the support of the basis or the size of the image region being analyzed.

Applications of 2D Gabor filters in image processing

In document image processing, Gabor features are ideal for identifying the script of a word in a multilingual document.[13] Gabor filters with different frequencies and with orientations in different directions have been used to localize and extract text-only regions from complex document images (both gray and colour), since text is rich in high frequency components, whereas pictures are relatively smooth in nature.^[14][15][16] It has also been applied for facial expression recognition ^[17] Gabor filters have also been widely used in pattern analysis applications. For example, it has been used to study the directionality distribution inside the porous spongy

Example implementations

Python

This is an example implementation in Python:

import numpy as np


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

    # Bounding box
    nstds = 3  # Number of standard deviation 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

For an implementation on images, see [1].

MATLAB

This is an example implementation in MATLAB/Octave:

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 for Gabor feature extraction from images in MATLAB can be found at http://www.mathworks.com/matlabcentral/fileexchange/44630.

Haskell

This is another example implementation in

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

See also

• Gabor transform
• Gabor wavelet
• Gabor atom
• Log Gabor filter

References