Question

每个人我都试图用FFT实现模式匹配，但我不确定结果应该是什么（我觉得我错过了一些东西，尽管读了很多关于这个问题的东西，并尝试了很多不同的实现这一个是迄今为止最好的）。这是我的FFT相关函数。

void fft2d(fftw_complex**& a, int rows, int cols, bool forward = true)
{
    fftw_plan p;
    for (int i = 0; i < rows; ++i)
    {
        p = fftw_plan_dft_1d(cols, a[i], a[i], forward ? FFTW_FORWARD : FFTW_BACKWARD, FFTW_ESTIMATE);
        fftw_execute(p);
    }

    fftw_complex* t = (fftw_complex*)fftw_malloc(rows * sizeof(fftw_complex));

    for (int j = 0; j < cols; ++j)
    {
        for (int i = 0; i < rows; ++i)
        {
            t[i][0] = a[i][j][0];
            t[i][1] = a[i][j][1];
        }

        p = fftw_plan_dft_1d(rows, t, t, forward ? FFTW_FORWARD : FFTW_BACKWARD, FFTW_ESTIMATE);
        fftw_execute(p);

        for (int i = 0; i < rows; ++i)
        {
            a[i][j][0] = t[i][0];
            a[i][j][1] = t[i][1];
        }
    }

    fftw_free(t);
}

int findCorrelation(int argc, char* argv[])
{
    BMP bigImage;
    BMP keyImage;
    BMP result;
    RGBApixel blackPixel = { 0, 0, 0, 1 };
    const bool swapQuadrants = (argc == 4);

    if (argc < 3 || argc > 4) {
        cout << "correlation img1.bmp img2.bmp" << endl;
        return 1;
    }

    if (!keyImage.ReadFromFile(argv[1])) {
        return 1;
    }

    if (!bigImage.ReadFromFile(argv[2])) {
        return 1;
}
    //Preparations
    const int maxWidth = std::max(bigImage.TellWidth(), keyImage.TellWidth());
    const int maxHeight = std::max(bigImage.TellHeight(), keyImage.TellHeight());

    const int rowsCount = maxHeight;
    const int colsCount = maxWidth;

    BMP bigTemp = bigImage;
    BMP keyTemp = keyImage;

    keyImage.SetSize(maxWidth, maxHeight);
    bigImage.SetSize(maxWidth, maxHeight);

    for (int i = 0; i < rowsCount; ++i)
        for (int j = 0; j < colsCount; ++j) {
            RGBApixel p1;

            if (i < bigTemp.TellHeight() && j < bigTemp.TellWidth()) {
                p1 = bigTemp.GetPixel(j, i);
            } else {
                p1 = blackPixel;
            }

            bigImage.SetPixel(j, i, p1);

            RGBApixel p2;

            if (i < keyTemp.TellHeight() && j < keyTemp.TellWidth()) {
                p2 = keyTemp.GetPixel(j, i);
            } else {
                p2 = blackPixel;
            }

            keyImage.SetPixel(j, i, p2);
        }
    //Here is where the transforms begin
    fftw_complex **a = (fftw_complex**)fftw_malloc(rowsCount * sizeof(fftw_complex*));
    fftw_complex **b = (fftw_complex**)fftw_malloc(rowsCount * sizeof(fftw_complex*));
    fftw_complex **c = (fftw_complex**)fftw_malloc(rowsCount * sizeof(fftw_complex*));

    for (int i = 0; i < rowsCount; ++i) {

        a[i] = (fftw_complex*)fftw_malloc(colsCount * sizeof(fftw_complex));
        b[i] = (fftw_complex*)fftw_malloc(colsCount * sizeof(fftw_complex));
        c[i] = (fftw_complex*)fftw_malloc(colsCount * sizeof(fftw_complex));

        for (int j = 0; j < colsCount; ++j) {
            RGBApixel p1;

            p1 = bigImage.GetPixel(j, i);

            a[i][j][0] = (0.299*p1.Red + 0.587*p1.Green + 0.114*p1.Blue);
            a[i][j][1] = 0.0;

            RGBApixel p2;

            p2 = keyImage.GetPixel(j, i);

            b[i][j][0] = (0.299*p2.Red + 0.587*p2.Green + 0.114*p2.Blue);
            b[i][j][1] = 0.0;
        }
    }

    fft2d(a, rowsCount, colsCount);
    fft2d(b, rowsCount, colsCount);

    result.SetSize(maxWidth, maxHeight);

    for (int i = 0; i < rowsCount; ++i)
        for (int j = 0; j < colsCount; ++j) {
            fftw_complex& y = a[i][j];
            fftw_complex& x = b[i][j];

            double u = x[0], v = x[1];
            double m = y[0], n = y[1];

            c[i][j][0] = u*m + n*v;
            c[i][j][1] = v*m - u*n;

            int fx = j;
            if (fx>(colsCount / 2)) fx -= colsCount;

            int fy = i;
            if (fy>(rowsCount / 2)) fy -= rowsCount;

            float r2 = (fx*fx + fy*fy);

            const double cuttoffCoef = (maxWidth * maxHeight) / 37992.;
            if (r2<128 * 128 * cuttoffCoef)
                c[i][j][0] = c[i][j][1] = 0;
        }

    fft2d(c, rowsCount, colsCount, false);

    const int halfCols = colsCount / 2;
    const int halfRows = rowsCount / 2;

    if (swapQuadrants) {
        for (int i = 0; i < halfRows; ++i)
            for (int j = 0; j < halfCols; ++j) {
                std::swap(c[i][j][0], c[i + halfRows][j + halfCols][0]);
                std::swap(c[i][j][1], c[i + halfRows][j + halfCols][1]);
            }

        for (int i = halfRows; i < rowsCount; ++i)
            for (int j = 0; j < halfCols; ++j) {
                std::swap(c[i][j][0], c[i - halfRows][j + halfCols][0]);
                std::swap(c[i][j][1], c[i - halfRows][j + halfCols][1]);
            }
    }

    for (int i = 0; i < rowsCount; ++i)
        for (int j = 0; j < colsCount; ++j) {
            const double& g = c[i][j][0];
            RGBApixel pixel;

            pixel.Alpha = 0;
            int gInt = 255 - static_cast<int>(std::floor(g + 0.5));
            pixel.Red = gInt;
            pixel.Green = gInt;
            pixel.Blue = gInt;

            result.SetPixel(j, i, pixel);
        }


    BMP res;
    res.SetSize(maxWidth, maxHeight);

    result.WriteToFile("result.bmp");

    return 0;
}

示例输出 Result from calling the function

Answer 1

这个问题可能会更恰当地贴在另一个网站上，例如cross validated（metaoptimize.com过去也很好，但似乎已经不见了）

那说：

您可以使用FFT执行两种类似的操作：卷积和相关。卷积用于确定两个信号如何相互作用，而相关可用于表示两个信号彼此之间的相似程度。确保您正在进行正确的操作，因为它们通常都是通过DFT实现的。

对于DFT的这种类型的应用，除非您正在寻找两个数据源或其他任何通用的频率（例如，如果您正在比较两个桥以查看是否存在），您通常不会在傅立叶频谱中提取任何有用的信息。他们的支持间隔相似。）

您的第3张图片看起来很像电源域;通常我看到相关输出完全是灰色的，除非发生重叠。你的代码肯定似乎在计算逆DFT，所以除非我错过了一些东西，否则我为模糊外观提出的唯一其他解释可能是一些＆＃34;软糖因素＆＃34;代码在那里像：

if (r2<128 * 128 * cuttoffCoef)
  c[i][j][0] = c[i][j][1] = 0;

至于你应该期待什么：只要两个图像之间有共同元素，你就会看到一个峰值。峰值越大，两个图像越接近该区域。

一些评论和/或建议的更改：

1）卷积＆amp;相关性不是尺度不变的操作。换句话说，图案图像的大小会对输出产生显着影响。

2）在关联之前规范化你的图像。

当您为前向DFT传递准备好图像数据时：

a[i][j][0] = (0.299*p1.Red + 0.587*p1.Green + 0.114*p1.Blue);
a[i][j][1] = 0.0;
/* ... */

如何对图像进行灰度化是您的业务（尽管我会选择sqrt( r*r + b*b + g*g )之类的东西）。但是，我没有看到你做任何事情来规范图像。

＆＃34;标准化＆＃34;在这种情况下可以采取一些不同的含义。两种常见类型：

规范化介于0.0和1.0之间的值范围
规范化＆＃34;白度＆＃34;的图像

3）通过边缘增强滤镜运行图案图像。我亲自使用了canny，sobel，我觉得我和其他几个人搞混了。我记得，canny很快就会变得很脏，而索贝尔的价格却更贵，但是当我需要进行相关时，我得到了可比较的结果。请参阅＆＃34; dsp指南的chapter 24＆＃34;可以在线免费获得的书籍。整本书值得你花时间，但如果你的时间很短，那么至少第24章将会有很大的帮助。

4）在[0,255]之间重新缩放输出图像;如果要实现阈值，请在此步骤之后执行此操作，因为阈值处理步骤是有损的。

我对此的记忆是模糊的，但我记得（编辑清楚）：

您可以通过将最大功率谱值除以整个功率谱来缩放[-1.0,1.0]之间的最终图像像素（重新缩放之前）
最大功率谱值足够方便地是功率谱中最大值（对应于最低频率）
如果你把它除掉功率范围，你最终会做两倍的工作;由于FFT是线性的，你可以延迟除法，直到反DFT传递到你重新缩放[0..255]之间的像素为止。
如果在重新调整大部分值后重新调整为黑色而无法看到它们，则可以使用ODE y' = y(1 - y)的解决方案（一个示例是sigmoid f(x) = 1 / (1 + exp(-c*x) )，对于某些缩放因子c，提供更好的渐变）。这与提高您在视觉上解释结果的能力有关，而不是以编程方式找到峰值的任何内容。

编辑我上面说过[0,255]。我建议你重新缩放到[128,255]或其他一些灰色而不是黑色的下限。

使用FFT互相关的C ++模式匹配（图像）

1 个答案: