SFML C++ Canny 边缘检测双边答案

【问题标题】：SFML C++ Canny edge detection double edgesSFML C++ Canny 边缘检测双边
【发布时间】：2019-01-29 05:43:05
【问题描述】：

因此，我决定创建一个简单的 Canny 边缘检测器，作为练习，然后再用图像处理处理更难的主题。

我尝试遵循 Canny 的典型路径： 1.对图像进行灰度化 2.高斯滤波器模糊噪声 3. 边缘检测——我同时使用 Sobel 和 Scharr 4. 边缘细化——我根据梯度方向在方向上使用了非最大抑制——垂直、水平、45 对角线或 135 对角线 5. 滞后

我设法让它与 Scharr 的检测一起工作，但我经常遇到双边缘或多边缘的问题，尤其是 Sobel。我真的找不到一组参数可以让它工作。

我的 Sobel 算法：

void sobel(sf::Image &image, pixldata **garray, float division)
{
int t1 = 0, t2 = 0, t3 = 0, t4 = 0;
sf::Color color;
sf::Image bufor;
bufor.create(image.getSize().x, image.getSize().y, sf::Color::Cyan);

for (int i = 1;i < image.getSize().y - 1;i++)
{
    for (int j = 1;j < image.getSize().x - 1;j++)
    {

        t1 = (- image.getPixel(j - 1, i - 1).r - 2 * image.getPixel(j - 1, i).r - image.getPixel(j - 1, i + 1).r + image.getPixel(j + 1, i - 1).r + 2 * image.getPixel(j + 1, i).r + image.getPixel(j + 1, i + 1).r) / division;
        t2 = (- image.getPixel(j - 1, i).r - 2 * image.getPixel(j - 1, i + 1).r - image.getPixel(j, i + 1).r + image.getPixel(j + 1, i).r + 2 * image.getPixel(j + 1, i - 1).r + image.getPixel(j, i - 1).r) / division;
        t3 = (- image.getPixel(j - 1, i + 1).r - 2 * image.getPixel(j, i + 1).r - image.getPixel(j + 1, i + 1).r + image.getPixel(j - 1, i - 1).r + 2 * image.getPixel(j, i - 1).r + image.getPixel(j + 1, i - 1).r) / division;
        t4 = (- image.getPixel(j, i + 1).r - 2 * image.getPixel(j + 1, i + 1).r - image.getPixel(j + 1, i).r + image.getPixel(j - 1, i).r + 2 * image.getPixel(j - 1, i - 1).r + image.getPixel(j, i - 1).r) / division;

        color.r = (abs(t1) + abs(t2) + abs(t3) + abs(t4));
        color.g = (abs(t1) + abs(t2) + abs(t3) + abs(t4));
        color.b = (abs(t1) + abs(t2) + abs(t3) + abs(t4));

        garray[j][i].gx = t1;
        garray[j][i].gy = t3;
        garray[j][i].gtrue = sqrt(t1*t1 + t2*t2 + t3*t3 + t4*t4);
        garray[j][i].gsimpl = sqrt(t1*t1 + t2*t2);

        t1 = abs(t1);
        t2 = abs(t2);
        t3 = abs(t3);
        t4 = abs(t4);

        if (t1 > t4 && t1 > t3 && t1 > t2)
            garray[j][i].fi = 0;
        else if (t2 > t4 && t2 > t3 && t2 > t1)
            garray[j][i].fi = 45;
        else if (t3 > t4 && t3 > t2 && t3 > t1)
            garray[j][i].fi = 90;
        else if (t4 > t3 && t4 > t2 && t4 > t1)
            garray[j][i].fi = 135;
        else
            garray[j][i].fi = 0;

        if (sqrt(t1*t1 + t2*t2 + t3*t3 + t4*t4) < 0)
        {
            color.r = 0;
            color.g = 0;
            color.b = 0;
        }
        else if (sqrt(t1*t1 + t2*t2 + t3*t3 + t4*t4) > 255)
        {
            color.r = 255;
            color.g = 255;
            color.b = 255;
        }
        else
        {
            color.r = sqrt(t1*t1 + t2*t2 + t3*t3 + t4*t4);
            color.g = sqrt(t1*t1 + t2*t2 + t3*t3 + t4*t4);
            color.b = sqrt(t1*t1 + t2*t2 + t3*t3 + t4*t4);
        }
        bufor.setPixel(j, i, color);
    }
}
image.copy(bufor, 0, 0);
}

Scharr 代码的不同之处仅在于像素值的乘积。

        t1 = (-3 * image.getPixel(j - 1, i - 1).r - 10 * image.getPixel(j - 1, i).r - 3 * image.getPixel(j - 1, i + 1).r + 3 * image.getPixel(j + 1, i - 1).r + 10 * image.getPixel(j + 1, i).r + 3 * image.getPixel(j + 1, i + 1).r) / division;
        t2 = (-3 * image.getPixel(j - 1, i).r - 10 * image.getPixel(j - 1, i + 1).r - 3 * image.getPixel(j, i + 1).r + 3 * image.getPixel(j + 1, i).r + 10 * image.getPixel(j + 1, i - 1).r + 3 * image.getPixel(j, i - 1).r) / division;
        t3 = (-3 * image.getPixel(j - 1, i + 1).r - 10 * image.getPixel(j, i + 1).r - 3 * image.getPixel(j + 1, i + 1).r + 3 * image.getPixel(j - 1, i - 1).r + 10 * image.getPixel(j, i - 1).r + 3 * image.getPixel(j + 1, i - 1).r) / division;
        t4 = (-3 * image.getPixel(j, i + 1).r - 10 * image.getPixel(j + 1, i + 1).r - 3 * image.getPixel(j + 1, i).r + 3 * image.getPixel(j - 1, i).r + 10 * image.getPixel(j - 1, i - 1).r + 3 * image.getPixel(j, i - 1).r) / division;

细化代码：

void intelligentThin(sf::Image &image, int radius, pixldata **garray)
{
int xmax = image.getSize().x;
int ymax = image.getSize().y;
bool judgeandjury = true;

for (int i = 0;i < xmax;i++)
{
    int leftBound = 0, rightBound = 0, ceilBound = 0, bottomBound = 0;

    if (i < radius)
    {
        leftBound = 0;
        rightBound = i + radius;
    }
    else if (i >= xmax - radius)
    {
        leftBound = i - radius;
        rightBound = xmax - 1;
    }
    else
    {
        leftBound = i - radius;
        rightBound = i + radius;
    }

    for (int j = 0;j < ymax;j++)
    {
        if (j < radius)
        {
            ceilBound = 0;
            bottomBound = j + radius;
        }
        else if (j >= ymax - radius)
        {
            ceilBound = j - radius;
            bottomBound = ymax - 1;
        }
        else
        {
            ceilBound = j - radius;
            bottomBound = j + radius;
        }

        if (garray[i][j].fi == 0)
        {
            for (int t = leftBound; t <= rightBound; t++)
            {
                if ((image.getPixel(t, j).r >= image.getPixel(i, j).r) && (t != i))
                {
                    judgeandjury = false;
                }
            }
        }
        else if (garray[i][j].fi == 135)
        {
            for (int l = leftBound, t = ceilBound; (l <= rightBound && t <= bottomBound); l++, t++)
            {
                if ((image.getPixel(l, t).r >= image.getPixel(i, j).r) && (t != j))
                {
                    judgeandjury = false;
                }
            }
        }
        else if (garray[i][j].fi == 90)
        {
            for (int t = ceilBound; t <= bottomBound; t++)
            {
                if ((image.getPixel(i, t).r >= image.getPixel(i, j).r) && (t != j))
                {
                    judgeandjury = false;
                }
            }
        }
        else if (garray[i][j].fi == 45)
        {
            for (int l = rightBound, t = ceilBound; (l >= leftBound && t <= bottomBound); l--, t++)
            {
                if ((image.getPixel(l, t).r >= image.getPixel(i, j).r) && (t != j))
                {
                    judgeandjury = false;
                }
            }
        }

        if (judgeandjury == false)
        {
            image.setPixel(i, j, sf::Color::Black);
        }

        judgeandjury = true;

    }
    leftBound = rightBound = 0;
}
}

迟滞码：

void hysteresis(sf::Image &image, int radius, int uplevel, int lowlevel)
{

int xmax = image.getSize().x;
int ymax = image.getSize().y;
bool judgeandjury = false;

sf::Image bufor;
bufor.create(image.getSize().x, image.getSize().y, sf::Color::Cyan);

for (int i = 0;i < xmax;i++)
{
    int leftBound = 0, rightBound = 0, ceilBound = 0, bottomBound = 0;

    if (i < radius)
    {
        leftBound = 0;
        rightBound = i + radius;
    }
    else if (i >= xmax - radius)
    {
        leftBound = i - radius;
        rightBound = xmax - 1;
    }
    else
    {
        leftBound = i - radius;
        rightBound = i + radius;
    }

    for (int j = 0;j < ymax;j++)
    {
        int currentPoint = image.getPixel(i, j).r;

        if (j < radius)
        {
            ceilBound = 0;
            bottomBound = j + radius;
        }
        else if (j >= ymax - radius)
        {
            ceilBound = j - radius;
            bottomBound = ymax - 1;
        }
        else
        {
            ceilBound = j - radius;
            bottomBound = j + radius;
        }

        if (currentPoint > uplevel)
        {
            judgeandjury = true;
        }
        else if (currentPoint > lowlevel)
        {
            for (int t = leftBound; t <= rightBound; t++)
            {
                for (int l = ceilBound; l <= bottomBound; l++)
                {
                    if (image.getPixel(t, l).r > uplevel)
                    {
                        judgeandjury = true;
                    }

                }
            }
        }
        else judgeandjury = false;

        if (judgeandjury == true)
        {
            bufor.setPixel(i, j, sf::Color::White);
        }
        else
        {
            bufor.setPixel(i, j, sf::Color::Black);
        }

        judgeandjury = false;
        currentPoint = 0;

    }
    leftBound = rightBound = 0;
}
image.copy(bufor, 0, 0);
}

结果让索贝尔很不满意：

Thinning the Sobel

Sobel after hysteresis

使用 Scharr，结果会更好：

Thinned Scharr

Scharr after hysteresis

参数集：

#define thinsize 1                  
#define scharrDivision 1        
#define sobelDivision 1                 
#define hysteresisRadius 1          
#define level 40                    
#define hysteresisUpperLevelSobel 80        
#define hysteresisLowerLevelSobel 60        
#define hysteresisUpperLevelScharr 200      
#define hysteresisLowerLevelScharr 100

如您所见，Sobel 存在问题，它会生成双边。 Scharr 也会产生一些噪音，但我认为这是可以接受的。当然，如果有人可以提供一些建议，它总是会变得更好:)

这种行为的原因是什么？是因为我的错误还是算法不好，还是只是参数问题？

编辑：发布 main()

sf::Image imydz;
imydz.loadFromFile("lena.jpg");
int x = imydz.getSize().x;
int y = imydz.getSize().y;


pixldata **garray = new pixldata *[x];
for (int i = 0;i < x;i++)
{
garray[i] = new pixldata[y];
}


monochrome(imydz);
gauss(imydz, radius, sigma);

//sobel(imydz, garray, sobelDivision);

scharr(imydz, garray, scharrDivision);

intelligentThin(imydz, thinsize, garray);
hysteresis(imydz, hysteresisRadius, hysteresisUpperLevel, hysteresisLowerLevel);

第二次编辑 - 修复抑制：

sf::Image bufor;
bufor.create(image.getSize().x, image.getSize().y, sf::Color::Black);
for (int i = 1;i < xmax - 1;i++)
{
    for (int j = 1;j < ymax - 1;j++)
    {
        if (garray[i][j].fi == 0)
        {
            if (((image.getPixel(i, j).r >= image.getPixel(i + 1, j).r) && (image.getPixel(i, j).r > image.getPixel(i - 1, j).r)) ||
                ((image.getPixel(i, j).r > image.getPixel(i + 1, j).r) && (image.getPixel(i, j).r >= image.getPixel(i - 1, j).r)))
            {
                judgeandjury = true;
            }
            else judgeandjury = false;
        }
...
 if (judgeandjury == false)
        {
            bufor.setPixel(i, j, sf::Color::Black);
        }
        else bufor.setPixel(i, j, image.getPixel(i, j));
        judgeandjury = false;
    }
}
image.copy(bufor, 0, 0);

Repaired Scharr on Lena 看起来很奇怪 Another test image - strange results

Before binarization

Ready gears

【问题讨论】：

您的细化过程会产生双边（即使对于 Scharr）；事实上超过一倍。你从哪里得到这个奇怪的细化代码？
那是一大堆你希望我们通读的代码，加上一大堆牛奶，加上没有明确定义的问题。请尝试使这个更最小。
问题出在您的“细化”中，因此请发布该代码，并提供合适的输入和main()，以便我们尝试重现您的问题。顺便说一句，Canny 边缘检测器使用非极大值抑制，而不是细化。细化是一个完全不同的概念。
是的，您可能应该从头开始重写您的“细化”算法。请参阅wikipedia article，了解该算法的工作原理。你不需要循环 l 和 t。
@YvesDaoust 嗯，这纯粹是我的发明。我在阅读了维基百科的基础知识和一本书后创建了它。你能指出，这个解决方案有什么问题吗？

标签： c++ image-processing sfml canny-operator sobel

【解决方案1】：

我没有详细阅读你的整个代码，那里的代码太多了。但显然你的非最大抑制代码是错误的。让我们看看它对图像中间的一个像素，梯度接近0度的地方做了什么：

leftBound = i - radius;
rightBound = i + radius;
// ...
for (int t = leftBound; t <= rightBound; t++)
{
   if ((image.getPixel(t, j).r >= image.getPixel(i, j).r) && (t != i))
   {
      judgeandjury = false; // it's not a maximum: suppress
   }
}
// ...
if (judgeandjury == false)
{
   image.setPixel(i, j, sf::Color::Black);
}

这里，radius 被调用代码设置为 1。任何其他值都会不好，所以这没关系。我会把它作为一个参数完全删除。现在你的循环是：

for (int t = i-1; t <= t+1; t++)
   if (t != i)

这意味着您恰好命中了t 的两个值。所以这当然应该用更简单的不循环的代码来代替，它会更具可读性。

这就是它现在所做的：

if (   (image.getPixel(i-1, j).r >= image.getPixel(i, j).r)
    || (image.getPixel(i+1, j).r >= image.getPixel(i, j).r)) {
   judgeandjury = false; // it's not a maximum: suppress
}

因此，如果该像素不严格大于其邻居，则可以抑制该像素。回顾Wikipedia article，他们似乎提出了相同的建议。但实际上，这是不正确的，您希望该点严格大于两个邻居之一，并且大于或等于另一个。这可以防止梯度恰好在两个相邻像素上同样强的情况。实际最大值可以正好落在两个像素的中间，在这个局部最大梯度上产生两个像素值完全相同。但是我们暂时忽略这种情况，有可能，但可能性不大。

接下来，您在输入图像中抑制最大值...！这意味着，当您到达这条线上的下一个像素时，您会将其值与刚刚被抑制的值进行比较。当然它会更大，即使它小于那个位置的原始值。也就是说，非最大值看起来像最大值，因为您将相邻像素设置为 0。

所以：将算法的结果写入输出图像：

if (judgeandjury == true)
{
   output.setPixel(i, j, image.getPixel(i, j));
}

...你当然需要分配，但你已经知道了。

您的第二个问题是在 sobel 函数中，您可以在其中计算梯度幅度。它剪辑（饱和）输出。通过将高于 255 的输出值削减到 255，您可以沿着恒定值的边缘创建非常宽的线条。这条线的两个边缘满足非极大值抑制的测试，但在中间不满足，那里的像素与其相邻的像素具有相同的值。

要解决这个问题，可以：

使用浮点缓冲区来存储梯度幅度。在这里您无需担心数据范围。
将幅度除以某个值，使其永远不会超过 255。现在您是在量化幅度而不是对其进行裁剪。在这种情况下，量化应该没问题。

我强烈建议您遵循 (1)。我通常使用浮点值图像来显示所有内容，并且只转换为 8 位整数进行显示。这简化了很多事情！

【讨论】：

谢谢你，先生，它帮助了莉娜的照片。我在上面的帖子中添加了新代码，并应用了您的建议。我还发布了新的莉娜和另一个看起来很奇怪的图像的结果。不知何故，它在正确的边缘“周围”绘制了两条边。你能解释一下吗？
@Tomasz：非极大值抑制的输出现在看起来更好，还是这个也显示了这些双边？
@TomaszMałachowski：您必须显示细化的结果（显然仍然是错误的），而不是在二值化之后，因为这会隐藏所有信息。
@CrisLuengo 对于 Lena 来说它看起来更好，但对于另一张图像来说它看起来很奇怪 - 双边现在相互移开。我在帖子中附加了 3 张新图片，以便您查看结果
@YvesDaoust 我在二值化/滞后之前附上了 Lena 的图像。齿轮图像在二值化之前/之后看起来都一样