Реализация фильтра Габора в частотной области - PullRequest
0 голосов
/ 29 августа 2018

Здесь мы имеем реализацию пространственного домена фильтра Габора. Но мне нужно реализовать фильтр Габора в частотной области по соображениям производительности.

Я нашел уравнение частотной области фильтра Габора :

enter image description here

Я на самом деле сомневаюсь в правильности и / или применимости этой формулы.

Исходный код

Итак, я реализовал следующее:

public partial class GaborFfftForm : Form
{
    private double Gabor(double u, double v, double f0, double theta, double a, double b)
    {
        double rad = Math.PI / 180 * theta;
        double uDash = u * Math.Cos(rad) + v * Math.Sin(rad);
        double vDash = (-1) * u * Math.Sin(rad) + v * Math.Cos(rad);

        return Math.Exp((-1) * Math.PI * Math.PI * ((uDash - f0) / (a * a)) + (vDash / (b * b)));
    }

    public Array2d<Complex> GaborKernelFft(int sizeX, int sizeY, double f0, double theta, double a, double b)
    {
        int halfX = sizeX / 2;
        int halfY = sizeY / 2;

        Array2d<Complex> kernel = new Array2d<Complex>(sizeX, sizeY);

        for (int u = -halfX; u < halfX; u++)
        {
            for (int v = -halfY; v < halfY; v++)
            {
                double g = Gabor(u, v, f0, theta, a, b);

                kernel[u + halfX, v + halfY] = new Complex(g, 0);
            }
        }

        return kernel;
    }

    public GaborFfftForm()
    {
        InitializeComponent();

        Bitmap image = DataConverter2d.ReadGray(StandardImage.LenaGray);
        Array2d<double> dImage = DataConverter2d.ToDouble(image);

        int newWidth = Tools.ToNextPowerOfTwo(dImage.Width) * 2;
        int newHeight = Tools.ToNextPowerOfTwo(dImage.Height) * 2;

        double u0 = 0.2;
        double v0 = 0.2;
        double alpha = 10;//1.5;
        double beta = alpha;

        Array2d<Complex> kernel2d = GaborKernelFft(newWidth, newHeight, u0, v0, alpha, beta);

        dImage.PadTo(newWidth, newHeight);
        Array2d<Complex> cImage = DataConverter2d.ToComplex(dImage);
        Array2d<Complex> fImage = FourierTransform.ForwardFft(cImage);

        // FFT convolution .................................................
        Array2d<Complex> fOutput = new Array2d<Complex>(newWidth, newHeight);
        for (int x = 0; x < newWidth; x++)
        {
            for (int y = 0; y < newHeight; y++)
            {
                fOutput[x, y] = fImage[x, y] * kernel2d[x, y];
            }
        }

        Array2d<Complex> cOutput = FourierTransform.InverseFft(fOutput);
        Array2d<double> dOutput = Rescale2d.Rescale(DataConverter2d.ToDouble(cOutput));

        //dOutput.CropBy((newWidth-image.Width)/2, (newHeight - image.Height)/2);

        Bitmap output = DataConverter2d.ToBitmap(dOutput, image.PixelFormat);

        Array2d<Complex> cKernel = FourierTransform.InverseFft(kernel2d);
        cKernel = FourierTransform.RemoveFFTShift(cKernel);
        Array2d<double> dKernel = DataConverter2d.ToDouble(cKernel);
        Array2d<double> dRescaledKernel = Rescale2d.Rescale(dKernel);
        Bitmap kernel = DataConverter2d.ToBitmap(dRescaledKernel, image.PixelFormat);

        pictureBox1.Image = image;
        pictureBox2.Image = kernel;
        pictureBox3.Image = output;
    }
}

Просто сконцентрируйтесь на алгоритмических шагах в это время.

Я сгенерировал ядро ​​Габора в частотной области. Поскольку ядро ​​уже находится в частотной области, я не применял к нему FFT, а изображение - FFT-ed. Затем я умножил ядро ​​и изображение для достижения FFT-Convolution. Затем они преобразуются в обратное БПФ и конвертируются обратно в растровое изображение, как обычно.

Выход

enter image description here

  1. Ядро выглядит хорошо. Но выход фильтра не выглядит многообещающим (или, не так ли?).
  2. Ориентация ( theta ) не влияет на ядро.
  3. Расчет / формула часто страдают от исключения деления на ноль при изменении значений.

Как я могу исправить эти проблемы?

О, а также

  • Что представляют собой параметры α , β ?
  • какое должно быть соответствующее значение f 0 ?

Обновление:

Я изменил свой код в соответствии с ответом @ Cris Luoengo .

    private double Gabor(double u, double v, double u0, double v0, double a, double b)
    {
        double p = (-2) * Math.PI * Math.PI;
        double q = (u-u0)/(a*a);
        double r = (v - v0) / (b * b);

        return Math.Exp(p * (q + r));
    }

    public Array2d<Complex> GaborKernelFft(int sizeX, int sizeY, double u0, double v0, double a, double b)
    {
        double xx = sizeX;
        double yy = sizeY;
        double halfX = (xx - 1) / xx;
        double halfY = (yy - 1) / yy;

        Array2d<Complex> kernel = new Array2d<Complex>(sizeX, sizeY);

        for (double u = 0; u <= halfX; u += 0.1)
        {
            for (double v = 0; v <= halfY; v += 0.1)
            {
                double g = Gabor(u, v, u0, v0, a, b);

                int x = (int)(u * 10);
                int y = (int)(v * 10);

                kernel[x,y] = new Complex(g, 0);
            }
        }

        return kernel;
    }

, где

        double u0 = 0.2;
        double v0 = 0.2;
        double alpha = 10;//1.5;
        double beta = alpha;

enter image description here

Я не уверен, хороший ли это вывод.

1 Ответ

0 голосов
/ 29 августа 2018

Кажется, что в уравнении для фильтра Габора найдена опечатка. Фильтр Габора является преобразованным гауссовым в частотной области. Следовательно, оно должно иметь и в показателе степени.

Уравнение (2) в вашей ссылке кажется более разумным, , но все еще пропускает 2 :

exp( -2(πσ)² (u-f₀)² )

Это 1D случай, это фильтр, который мы хотим использовать в направлении & theta ;. Теперь умножим в перпендикулярном направлении, v, на несмещенный гауссов. Я устанавливаю α и β как инверсию двух сигм:

exp( -2(π/α)² (u-f₀)² ) exp( -2(π/β)² v² ) = exp( -2π²((u-f₀)/α)² + -2π²(v/β)² )

Вы должны реализовать вышеприведенное уравнение с поворотом u и v на & theta;, как вы уже сделали.

Кроме того, u и v должны работать от -0,5 до 0,5, а не от -sizeX/2 до sizeX/2. И это при условии, что ваше БПФ устанавливает источник в середине изображения, что не является распространенным явлением. Обычно алгоритмы БПФ устанавливают начало координат в углу изображения. Таким образом, вы, вероятно, должны вместо этого использовать u и v от 0 до (sizeX-1)/sizeX.

При исправленной реализации, как указано выше, вы должны установить f₀ в диапазоне от 0 до 0,5 (попробуйте 0,2 для начала), а α и β должны быть достаточно малы, чтобы гауссиан не достиг частота 0 (вы хотите, чтобы фильтр там был 0)

В частотной области ваш фильтр будет выглядеть как повернутый гауссиан от начала координат.

В пространственной области величина вашего фильтра снова должна выглядеть как гауссовская. Мнимый компонент должен выглядеть следующим образом (изображение ссылки на страницу Википедии, на которой я его нашел):

Gabor, real part

(т.е. это антисимметрично (нечетно) в направлении & theta;), возможно, с большим количеством лепестков в зависимости от α, β и f₀. Реальный компонент должен быть похожим, но симметричным (четным) с максимумом посередине. Обратите внимание, что после IFFT вам может понадобиться сместить начало координат из верхнего левого угла в середину изображения (Google "fftshift").


Обратите внимание, что если вы установите α и β равными, вращение плоскости u - v не имеет значения. В этом случае вы можете использовать декартовы координаты вместо полярных координат для определения частоты. То есть вместо определения f₀ и θ в качестве параметров вы определяете u₀ и v₀. В показателе степени вы затем заменяете u-f₀ на u-u₀, а v на v-v₀.


Код после редактирования вопроса снова пропускает квадрат. Я бы написал код следующим образом:

private double Gabor(double u, double v, double u0, double v0, double a, double b)
{
    double p = (-2) * Math.PI * Math.PI;
    double q = (u-u0)/a;
    double r = (v - v0)/b;

    return Math.Exp(p * (q*q + r*r));
}

public Array2d<Complex> GaborKernelFft(int sizeX, int sizeY, double u0, double v0, double a, double b)
{
    double halfX = sizeX / 2;
    double halfY = sizeY / 2;

    Array2d<Complex> kernel = new Array2d<Complex>(sizeX, sizeY);

    for (double y = 0; y < sizeY; y++)
    {
        double v = y / sizeY;
        // v -= HalfY;  // whether this is necessary or not depends on your FFT
        for (double x = 0; x < sizeX; x++)
        {
            double u = x / sizeX;
            // u -= HalfX;  // whether this is necessary or not depends on your FFT
            double g = Gabor(u, v, u0, v0, a, b);

            kernel[(int)x, (int)y] = new Complex(g, 0);
        }
    }

    return kernel;
}
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...