C++ 图像的边缘检测

我已经写了一个代码来检测边缘使用双阈值，我在这里做的是 如果较高阈值图像的像素值为255，则该图像有效；如果较低阈值图像的白色像素与该像素相连，则该图像的边缘有效。 但在我的程序中，只有高阈值的图像被复制。低阈值的有效像素没有被绘制。此外，此代码适用于较大的图像，而不是较小的图像。我真的无法理解y，因为我没有硬编码宽度和高度的值

这是我的密码

 void edge_linking(ImgGray img_low,ImgGray img_high,ImgGray *img_edge_link,int mu)
 {
     int x,y;

     CPoint p;
     vector<Point>edgelink;

     for(y=mu;y<=(*img_edge_link).Height()-mu;y++)
     {
         for(x=mu;x<=(*img_edge_link).Width()-mu;x++)
         {
             //if(x>0 && y>0 && x< (*img_edge_link).Width()-1 &&(*img_edge_link).Height()-1)
             //{
             if(img_high(x,y)==255)
             {
                    (*img_edge_link)(x,y)=255;
                    edgelink.push_back(Point(img_high(x,y)));

                    while(!edgelink.empty())
                    {

                       p=edgelink.back();
                       edgelink.pop_back();

                       if (p.x >0 && img_low(p.x-1,p.y)==255 && (*img_edge_link)(p.x-1,p.y)!=255 )
                       { 
                           (*img_edge_link)(p.x-1,p.y)=255;
                           edgelink.push_back(Point(p.x-1,p.y));
                       }
                       if (p.y>0 && img_low(p.x,p.y-1)==255 && (*img_edge_link)(p.x,p.y-1)!=255)
                       {
                           (*img_edge_link)(p.x,p.y-1)=255;
                           edgelink.push_back(Point(p.x,p.y-1));
                       }
                       if (p.x<(*img_edge_link).Width()-1 && img_low(p.x+1,p.y)==255 && (*img_edge_link)(p.x+1,p.y)!=255)
                       {
                           (*img_edge_link)(p.x+1,p.y)=255;
                           edgelink.push_back(Point(p.x+1,p.y));
                       }
                       if (p.y <(*img_edge_link).Height()-1 && img_low(p.x,p.y+1)==255 && (*img_edge_link)(p.x,p.y+1)!=255 )
                       {
                           (*img_edge_link)(p.x,p.y+1)=255;
                           edgelink.push_back(Point(p.x,p.y+1));
                       }
                       if (p.x>0 && p.y<(*img_edge_link).Height()-1 && img_low(p.x-1,p.y+1)==255 && (*img_edge_link)(p.x-1,p.y+1)!=255)
                       {
                       (*img_edge_link)(p.x-1,p.y+1)=255;
                       edgelink.push_back(Point(p.x-1,p.y+1));
                       }
                       if(p.x>0 && p.y>0 && img_low(p.x-1,p.y-1)==255 && (*img_edge_link)(p.x-1,p.y-1)!=255)
                       {
                       (*img_edge_link)(p.x-1,p.y-1)=255;
                       edgelink.push_back(Point(p.x-1,p.y-1));
                       }
                       if(p.y<(*img_edge_link).Height()-1 && p.x<(*img_edge_link).Width()-1 && img_low(p.x+1,p.y+1)==255 && (*img_edge_link)(p.x+1,p.y+1)!=255)
                       {
                       (*img_edge_link)(p.x+1,p.y+1)=255;
                       edgelink.push_back(Point(p.x+1,p.y+1));
                       }
                       if(p.y>0 && p.x<(*img_edge_link).Width()-1 && img_low(p.x+1,p.y-1)==255 && (*img_edge_link)(p.x+1,p.y-1)!=255)
                       {
                        (*img_edge_link)(p.x+1,p.y-1)=255;
                        edgelink.push_back(Point(p.x+1,p.y-1));
                       }

                   }
              }
          }
     }
 }

void edge_链接（ImgGray img_低，ImgGray img_高，ImgGray*img_edge_链接，int mu）
{
int x，y；
CPP点；
矢量链接；
对于（y=mu；y0&&x<（*img_边缘链接）。宽度（）-1&（*img_边缘链接）。高度（）-1）
//{
如果（img_高（x，y）==255）
{
（*图像边缘链接）（x，y）=255；
向后推（点（调高（x，y））；
而（！edgelink.empty（））
{
p=边缘线背面（）；
edgelink.pop_back（）；
如果（p.x>0和&img\u低（p.x-1，p.y）==255和（*img\u边缘链接）（p.x-1，p.y）！=255）
{ 
（*img_edge_link）（p.x-1，p.y）=255；
边线向后推（点（p.x-1，p.y））；
}
如果（p.y>0和&img\u低（p.x，p.y-1）==255和（*img\u边缘链接）（p.x，p.y-1）！=255）
{
（*img_edge_link）（p.x，p.y-1）=255；
边线向后推（点（p.x，p.y-1））；
}
如果（p.x0和&img_低（p.x-1，p.y-1）=255和（*img_边缘链接）（p.x-1，p.y-1）！=255）
{
（*img_edge_link）（p.x-1，p.y-1）=255；
边线向后推（点（p.x-1，p.y-1））；
}
如果（p.y这条线有点奇怪：

edgelink.push_back(Point(img_high(x,y)));

“edgelink”是点的向量，但img_high（x，y）可能返回一个整数，因此您使用一个值而不是两个坐标初始化Point类。如下所示：

edgelink.push_back(Point(x,y));

…似乎更有意义。
几点：

首先，您说它不适用于小图像，可能是因为mu参数（我假设它是某种边界？）的缘故。输出图像是否初始化为零

其次，我认为可以通过避免一些不必要的检查来改进代码。

首先计算低阈值图像和高阈值图像之间的差值（低=低-高：低中的像素不在高中）。这将为您提供存储在低中的弱边，以及存储在高中的强边。

接下来，用255的像素值在高图像上循环，并用255的值将它们的邻域标记为低，比如说128。

最后，只需将“高”中的像素设置为255，其中“低”中对应的像素为128（弱边与强边相邻）

除了其他人提到的错误之外，我看不到更多的问题…
我不太明白您想要实现什么。但是为什么不使用像canny边缘检测器这样的边缘检测算法呢？我看不到您“问题”中的实际问题@nuriaion:看起来这是迟滞阈值步骤，它是canny edge Detector的一部分，也有点点和CPoint的错误