为什么高斯核值不是由方程生成的和书中给出的相同？

我使用以下代码创建了高斯核。

double gaussian(double x, double mu, double sigma) {
    return std::exp(-(((x - mu) / (sigma))*((x - mu) / (sigma))) / 2.0);
}

typedef std::vector<double> kernel_row;
typedef std::vector<kernel_row> kernel_type;

kernel_type produce2dGaussianKernel(int kernelRadius) {

    double sigma = kernelRadius / 2.;
    kernel_type kernel2d(2 * kernelRadius + 1, kernel_row(2 * kernelRadius + 1));
    double sum = 0;
    // compute values
    for (int row = 0; row < kernel2d.size(); row++)
        for (int col = 0; col < kernel2d[row].size(); col++) {
            double x = gaussian(row, kernelRadius, sigma)
                * gaussian(col, kernelRadius, sigma);
            kernel2d[row][col] = x;
            sum += x;
        }
    // normalize
    for (int row = 0; row < kernel2d.size(); row++)  {
        for (int col = 0; col < kernel2d[row].size(); col++) {
            kernel2d[row][col] /= sum;
        }
    }

    return kernel2d;
}

它的结果是

0.01134 0.08382 0.01134
0.08382 0.61935 0.08382
0.01134 0.08382 0.01134
Press any key to continue . . .

还有书中给出的这个3x3高斯核

{1 / 16.0f, 2 / 16.0f, 1 / 16.0f,
2 / 16.0f, 4 / 16.0f, 2 / 16.0f,
1 / 16.0f, 2 / 16.0f, 1 / 16.0f };

我想知道为什么两个系数不一样。以及在哪个西格玛值下，生成高斯内核(书中给出)掩码？ 注:我用的是高斯方程生成高斯核

已编辑:我在我的代码中添加了高斯函数。

最佳答案

好的，这本书的内核是一个二项式加权内核，可以在帕斯卡三角形中找到，在具有 3 个系数的行上:1 2 1。矩阵中的每个单元格都是与其行索引对应的系数乘以其列索引对应的系数，然后将整个事物归一化。

很遗憾，我找不到您的gaussian 函数的源代码。我可以将您的函数的输出与我对其功能的猜测进行比较，但我真的不想花时间去做这件事。

为什么这很重要，因为实际上有两种类型的高斯核。我怀疑您的内核使用熟悉的基于指数的高斯分布、归一化的 exp(-x*x/(2*s*s)) 或类似的东西。但是像这样的内核仅在涉及连续函数的卷积中才真正有效，而不是图像数据等离散样本集。

所以另一个叫做“离散高斯核”。对于大 sigma，它非常接近连续高斯核，但对于小于 4 像素的 sigma，离散版本与连续版本有点不同。

这是包含离散高斯核的维基百科文章的链接:https://en.wikipedia.org/wiki/Scale_space_implementation#The_discrete_Gaussian_kernel 不幸的是，它可能很难计算，因为它依赖于修改后的贝塞尔函数而不是标准数学库中提供的指数函数。

编辑

我继续挖掘我的代码来计算离散高斯核。我无法证明这个计算的算法是正确的，因为我几年前写了它，但我不记得我是怎么想到这个的。下面的代码将来自离散高斯内核的值与从高斯函数采样的值进行比较，用于固定的 sigma 和多个输入。

#include <iostream>
#include <iomanip>
#include <cmath>

// x is expected to be an integer value
double DiscreteGaussian(double x, double Sigma) {
    x = std::fabs(x);

    if(x > Sigma * 10) return 0;

    double k = 0;

    const double LnSigma_x_2 = std::log(Sigma) * 2;

    const double Ca = x * (LnSigma_x_2 - std::log(2.0)) - (Sigma * Sigma);

    double Ra = 0;                  // accumulated LnGamma(k + 1)
    double Rb = std::lgamma(x + 1); // accumulated LnGamma(x + k + 1)
    double Rc = 0;                  // accumulated k * (4*Ln(Sigma)-2*Ln(2))

    const double Cc = 2.0 * (LnSigma_x_2 - std::log(2.0));   // const for Rc

    double Sum;
    double Next = std::exp(-Rb);

    do {
        Sum = Next;
        k += 1;
        Ra += std::log(k);
        Rb += std::log(x + k);
        Rc += Cc;
        const double ExpTerm = Rc - Ra - Rb;
        Next = Sum + std::exp(ExpTerm);
    } while(Next != Sum);

    return Sum * std::exp(Ca); 
}

double ContinuousGaussian(double x, double Sigma) {
    static const double NORMER = 0.3989422804014327;  // 1/sqrt(2*pi)
    const double x_as_sigmas = x / Sigma;
    return std::exp(-0.5 * x_as_sigmas * x_as_sigmas) * NORMER / Sigma;
}

int main() {
    // t is sigma squared, so for a t of 2, use a sigma of sqrt(2)
    const double sigma = std::sqrt(0.5);
    std::cout << "Sigma " << sigma << '\n';
    std::cout << " x    Discrete          Sampled\n";
    for(int x = -5; x<=5; ++x) {
        const double yd = DiscreteGaussian(x, sigma);
        const double yc = ContinuousGaussian(x, sigma);
        std::cout << (x < 0 ? "" : " ") << x << "    "
            << std::setw(14) << std::setprecision(8) << std::fixed << std::left
            << yd << "    " << yc << '\n';
    }
}

输出看起来像这样

Sigma 0.707107
 x    Discrete          Sampled
-5    0.00000499        0.00000000
-4    0.00009996        0.00000006
-3    0.00160434        0.00006963
-2    0.01935206        0.01033349
-1    0.15642080        0.20755375
 0    0.64503527        0.56418958
 1    0.15642080        0.20755375
 2    0.01935206        0.01033349
 3    0.00160434        0.00006963
 4    0.00009996        0.00000006
 5    0.00000499        0.00000000

如您所见，即使对于很小的 sigma，差异也很小，并且根据应用的不同，差异可能不足以切换到使用采样连续高斯函数。

关于c++ - 高斯生成的内核和书中给出的不一样。为什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39744615/