Canny边缘检测及实现

其他 2020-02-21 21:17:32 阅读次数: 0

简单来说，Canny检测的步骤如下：

（1）使用低通滤波器抑制噪声

（2）计算梯度幅值和梯度方向

（3）非极大值抑制

（4）检测边缘

 下面给出每一步的代码。

抑制噪声：

Mat imageSource = imread("D:\\image.jpg", 0), imageGaussian; //读取图像
//imshow("Image", imageSource);
GaussianBlur(imageSource, imageGaussian, Size(5, 5), 0); //高斯滤波平滑图像
//imshow("Gaussian Image", imageGaussian);

计算X和Y梯度幅值，梯度方向：

/**
	imageInput - 输入图像
	imageX - 输出X方向的梯度幅值
	imageY - 输出Y方向的梯度幅值
	pointDirection - 每一点的梯度方向
**/
void SobelXY(Mat imageInput, Mat &imageX, Mat &imageY, double *pointDirection)
{
	imageX = imageInput.clone();
	imageY = imageInput.clone();
	for (int i = 0; i < imageInput.rows*imageInput.cols; i++)
	{
		pointDirection[i] = 0;
	}
	double dx, dy;
	int k = 0;
	for (int i = 1; i < imageInput.rows - 1; i++)
	{
		for (int j = 1; j < imageInput.cols - 1; j++)
		{
			dx = imageInput.at<uchar>(i + 1, j - 1) + 2 * imageInput.at<uchar>(i + 1, j) + imageInput.at<uchar>(i + 1, j + 1) -
				(imageInput.at<uchar>(i - 1, j - 1) + 2 * imageInput.at<uchar>(i - 1, j) + imageInput.at<uchar>(i - 1, j + 1));

			dy = imageInput.at<uchar>(i - 1, j - 1) + 2 * imageInput.at<uchar>(i, j - 1) + imageInput.at<uchar>(i + 1, j - 1) -
				(imageInput.at<uchar>(i - 1, j + 1) + 2 * imageInput.at<uchar>(i, j + 1) + imageInput.at<uchar>(i + 1, j + 1));

			imageX.at<uchar>(i, j) = saturate_cast<uchar>(dx);
			imageY.at<uchar>(i, j) = saturate_cast<uchar>(dy);
			if (dx == 0) dx = 0.00000000000000001; //避免除0
				
			pointDirection[k] = atan(dy / dx) * 57.3; //弧度转角度
			pointDirection[k] += 90;
			k++;
		}
	}
	convertScaleAbs(imageX, imageX);
	convertScaleAbs(imageY, imageY);
}

梯度幅值：

若梯度幅值为G，X方向为Gx，Y方向为Gy。则有G = sqrt(Gx^2 + Gy^2)。也有简单的算法G = Gx + Gy

/**
	imageX - X方向的梯度幅值
	imageY - Y方向的梯度幅值
	imageOutput - 输出图像
**/
void SobelXYAdd(Mat imageX, Mat imageY, Mat &imageOutput)
{
	imageOutput = imageX.clone();
	for (int i = 0; i < imageX.rows; i++)
	{
		uchar *ptrX = imageX.ptr<uchar>(i);
		uchar *ptrY = imageY.ptr<uchar>(i);
		uchar *ptr = imageOutput.ptr<uchar>(i);
		for (int j = 0; j < imageX.cols; j++)
		{
			ptr[j] = saturate_cast<uchar>(sqrt(ptrX[j] * ptrX[j] + ptrY[j] * ptrY[j]));
		}
	}
	convertScaleAbs(imageOutput, imageOutput);
}

非极大值抑制：沿着该点的梯度方向，比较前后两个点的梯度幅值，若该点大于前后两点的梯度幅值则保留，否则置为0

此处我贴个图用以说明前后两点究竟是哪两点以及其梯度幅值的求法

上图中g1，g2，g3，g4，c都为像素点，其中点c是我们所要判断是否为极大值的点。显然，g1，g2，g3，g4在点c相邻的八个点。手绘的点A，B即是点c的前后两点。设点g1，g2的梯度幅值为val_g1，val_g2

则点A的梯度幅值val_A = m*val_g1+(1-m)val_g2，其中m = tan(θ)，显然θ可由该点的梯度方向求得

即此处采用简单的线性插值来求出点A的梯度幅值。类似的B也可这样求得。下面给出代码：

 1 /**
 2     imageInput - 输入图像
 3     imageOutput - 输出图像
 4     pointDirection - 各个点的梯度方向
 5 **/
 6 void NotMaxValue(Mat imageInput, Mat &imageOutput, double *pointDirection)
 7 {
 8     imageOutput = imageInput.clone();
 9     int k = 0;
10     for (int i = 1; i < imageInput.rows - 1; i++)
11     {
12         for (int j = 1; j < imageInput.cols - 1; j++)
13         {
14             uchar leftTop = imageInput.at<uchar>(i - 1, j - 1);
15             uchar top = imageInput.at<uchar>(i - 1, j);
16             uchar rightTop = imageInput.at<uchar>(i - 1, j + 1);
17             uchar left = imageInput.at<uchar>(i, j - 1);
18             uchar val = imageInput.at<uchar>(i, j);
19             uchar right = imageInput.at<uchar>(i, j + 1);
20             uchar leftBottom = imageInput.at<uchar>(i + 1, j - 1);
21             uchar bottom = imageInput.at<uchar>(i + 1, j);
22             uchar rightBottom = imageInput.at<uchar>(i + 1, j + 1);
23             int direction = pointDirection[k];
24             if (direction > 0 && direction <= 45)
25             {
26                 if (val <= right + tan(direction)*(rightTop - right) ||
27                     val <= left + tan(direction)*(leftBottom - left))
28                 {
29                     imageInput.at<uchar>(i, j) = 0;
30                 }
31             }
32             if (direction > 45 && direction <= 90)
33             {
34                 if (val <= top + tan(90 - direction)*(rightTop - top) ||
35                     val <= bottom + tan(90 - direction)*(leftBottom - bottom))
36                 {
37                     imageInput.at<uchar>(i, j) = 0;
38                 }
39             }
40             if (direction > 90 && direction <= 135)
41             {
42                 if (val <= top + tan(direction - 90)*(leftTop - top) ||
43                     val <= bottom + tan(direction - 90)*(rightBottom - bottom))
44                 {
45                     imageInput.at<uchar>(i, j) = 0;
46                 }
47             }
48             if (direction > 135 && direction <= 180)
49             {
50                 if (val <= left + tan(180 - direction)*(leftTop - left) ||
51                     val <= right + tan(180 - direction)*(rightBottom - right))
52                 {
53                     imageInput.at<uchar>(i, j) = 0;
54                 }
55             }
56             k++;
57         }
58     }
59 }

边缘检测：

这里采用了双阈值，有阈值L，H。其中L < H

若某点的梯度幅值大于H，则认为该点是强边缘，若小于L则认为该点非边缘。若在两个阈值之间，则认为是弱边缘，根据其与强边缘是否连通来判断其是否是边缘。

void DoubleThreshold(Mat &imageInput, int lowThreshold, int highThreshold)
{
    for (int i = 0; i < imageInput.rows; i++)
    {
        uchar *ptr = imageInput.ptr<uchar>(i);
        for (int j = 0; j < imageInput.cols; j++)
        {
            if (ptr[j] < lowThreshold) ptr[j] = 0;
            else if (ptr[j] >= highThreshold) ptr[j] = 255;
        }
    }
}

bool LinkWithMaxValue(Mat image, int i, int j)
{
    uchar val = image.at<uchar>(i, j);
    uchar leftTop = image.at<uchar>(i - 1, j - 1);
    uchar top = image.at<uchar>(i - 1, j);
    uchar rightTop = image.at<uchar>(i - 1, j + 1);
    uchar left = image.at<uchar>(i, j - 1);
    uchar right = image.at<uchar>(i, j + 1);
    uchar leftBottom = image.at<uchar>(i + 1, j - 1);
    uchar bottom = image.at<uchar>(i + 1, j);
    uchar rightBottom = image.at<uchar>(i + 1, j + 1);
    return (leftTop == 255 || top == 255 || rightTop == 255 || left == 255 ||
        right == 255 || leftBottom == 255 || bottom == 255 || rightBottom == 255);
}

void DoubleThresholdLink(Mat &imageOutput)
{
    int dx[] = { -1, 0, 1 };
    int dy[] = { -1, 0, 1 };
    bool *visited = new bool[imageOutput.rows*imageOutput.cols];
    stack<Point> mst;
    for (int i = 0; i < imageOutput.rows*imageOutput.cols; i++) visited[i] = 0;
    for (int i = 1; i < imageOutput.rows - 1; i++)
    {
        for (int j = 1; j < imageOutput.cols - 1; j++)
        {
            if (visited[i*imageOutput.rows + j]) continue;
            visited[i*imageOutput.rows + j] = 1;
            uchar val = imageOutput.at<uchar>(i, j);
            if (!val || val == 255) continue;
            if (LinkWithMaxValue(imageOutput, i, j))
            {
                imageOutput.at<uchar>(i, j) = 255;
                while (!mst.empty())
                {
                    Point temp = mst.top(); mst.pop();
                    if (visited[temp.x*imageOutput.rows + temp.y]) continue;
                    visited[temp.x*imageOutput.rows*temp.x + temp.y] = 1;
                    int data = imageOutput.at<uchar>(temp.x, temp.y);
                    if (!data) continue;
                    imageOutput.at<uchar>(temp.x, temp.y) = 255;
                    for (int r = 0; r < 3; r++)
                    {
                        for (int c = 0; c < 3; c++)
                        {
                            uchar changedX = temp.x + dx[r];
                            uchar changedY = temp.y + dy[c];
                            if (visited[changedX*imageOutput.rows + changedY]) continue;
                            mst.push(Point(changedX, changedY));
                        }
                    }
                }
            }
            else imageOutput.at<uchar>(i, j) = 0;
        }
    }
}

最后我贴下整个程序的代码：

  1 #include "core/core.hpp"  
  2 #include "highgui/highgui.hpp"  
  3 #include "imgproc/imgproc.hpp"  
  4 #include "iostream"
  5 #include "math.h"
  6 #include "stack"
  7 
  8 using namespace std;
  9 using namespace cv;
 10 
 11 void SobelXY(Mat imageInput, Mat &imageX, Mat &imageY, double *pointDirection);
 12 
 13 void SobelXYAdd(Mat imageX, Mat imageY, Mat &imageOutput);
 14 
 15 void NotMaxValue(Mat imageInput, Mat &imageOutput, double *pointDirection);
 16 
 17 bool LinkWithMaxValue(Mat image, int i, int j);
 18 
 19 void DoubleThreshold(Mat &imageInput, int lowThreshold, int highThreshold);
 20 
 21 void DoubleThresholdLink(Mat &imageOutput);
 22 
 23 int main(int argc, char **argv)
 24 {
 25     Mat imageSource = imread("D:\\image.jpg", 0), imageGaussian; //读取图像
 26     //imshow("Image", imageSource);
 27     GaussianBlur(imageSource, imageGaussian, Size(5, 5), 0); //高斯滤波平滑图像
 28     //imshow("Gaussian Image", imageGaussian);
 29     Mat imageSobelX, imageSobelY, imageSobel;
 30     double *pointDirection = new double[imageGaussian.rows * imageGaussian.cols];
 31     SobelXY(imageGaussian, imageSobelX, imageSobelY, pointDirection); //计算X和Y方向的梯度和梯度方向
 32     //imshow("Sobel X", imageSobelX);
 33     //imshow("Sobel Y", imageSobelY);
 34     SobelXYAdd(imageSobelX, imageSobelY, imageSobel); //计算梯度幅值
 35     //imshow("Sobel", imageSobel);
 36     Mat imageMaxValue;
 37     NotMaxValue(imageSobel, imageMaxValue, pointDirection); //抑制非极大值
 38     //imshow("MaxValue", imageMaxValue);
 39     DoubleThreshold(imageMaxValue, 50, 100);
 40     DoubleThresholdLink(imageMaxValue);
 41     imshow("Canny", imageMaxValue);
 42     Canny(imageGaussian, imageGaussian, 50, 100);
 43     imshow("OpenCV Canny", imageGaussian);
 44     waitKey();
 45     return 0;
 46 }
 47 
 48 /**
 49     imageInput - 输入图像
 50     imageX - 输出X方向的梯度幅值
 51     imageY - 输出Y方向的梯度幅值
 52     pointDirection - 每一点的梯度方向
 53 **/
 54 void SobelXY(Mat imageInput, Mat &imageX, Mat &imageY, double *pointDirection)
 55 {
 56     imageX = imageInput.clone();
 57     imageY = imageInput.clone();
 58     for (int i = 0; i < imageInput.rows*imageInput.cols; i++)
 59     {
 60         pointDirection[i] = 0;
 61     }
 62     double dx, dy;
 63     int k = 0;
 64     for (int i = 1; i < imageInput.rows - 1; i++)
 65     {
 66         for (int j = 1; j < imageInput.cols - 1; j++)
 67         {
 68             dx = imageInput.at<uchar>(i + 1, j - 1) + 2 * imageInput.at<uchar>(i + 1, j) + imageInput.at<uchar>(i + 1, j + 1) -
 69                 (imageInput.at<uchar>(i - 1, j - 1) + 2 * imageInput.at<uchar>(i - 1, j) + imageInput.at<uchar>(i - 1, j + 1));
 70 
 71             dy = imageInput.at<uchar>(i - 1, j - 1) + 2 * imageInput.at<uchar>(i, j - 1) + imageInput.at<uchar>(i + 1, j - 1) -
 72                 (imageInput.at<uchar>(i - 1, j + 1) + 2 * imageInput.at<uchar>(i, j + 1) + imageInput.at<uchar>(i + 1, j + 1));
 73 
 74             imageX.at<uchar>(i, j) = saturate_cast<uchar>(dx);
 75             imageY.at<uchar>(i, j) = saturate_cast<uchar>(dy);
 76             if (dx == 0) dx = 0.00000000000000001; //避免除0
 77                 
 78             pointDirection[k] = atan(dy / dx) * 57.3; //弧度转角度
 79             pointDirection[k] += 90;
 80             k++;
 81         }
 82     }
 83     convertScaleAbs(imageX, imageX);
 84     convertScaleAbs(imageY, imageY);
 85 }
 86 /**
 87     imageX - X方向的梯度幅值
 88     imageY - Y方向的梯度幅值
 89     imageOutput - 输出图像
 90 **/
 91 void SobelXYAdd(Mat imageX, Mat imageY, Mat &imageOutput)
 92 {
 93     imageOutput = imageX.clone();
 94     for (int i = 0; i < imageX.rows; i++)
 95     {
 96         uchar *ptrX = imageX.ptr<uchar>(i);
 97         uchar *ptrY = imageY.ptr<uchar>(i);
 98         uchar *ptr = imageOutput.ptr<uchar>(i);
 99         for (int j = 0; j < imageX.cols; j++)
100         {
101             ptr[j] = saturate_cast<uchar>(sqrt(ptrX[j] * ptrX[j] + ptrY[j] * ptrY[j]));
102         }
103     }
104     convertScaleAbs(imageOutput, imageOutput);
105 }
106 
107 /**
108     imageInput - 输入图像
109     imageOutput - 输出图像
110     pointDirection - 各个点的梯度方向
111 **/
112 void NotMaxValue(Mat imageInput, Mat &imageOutput, double *pointDirection)
113 {
114     imageOutput = imageInput.clone();
115     int k = 0;
116     for (int i = 1; i < imageInput.rows - 1; i++)
117     {
118         for (int j = 1; j < imageInput.cols - 1; j++)
119         {
120             uchar leftTop = imageInput.at<uchar>(i - 1, j - 1);
121             uchar top = imageInput.at<uchar>(i - 1, j);
122             uchar rightTop = imageInput.at<uchar>(i - 1, j + 1);
123             uchar left = imageInput.at<uchar>(i, j - 1);
124             uchar val = imageInput.at<uchar>(i, j);
125             uchar right = imageInput.at<uchar>(i, j + 1);
126             uchar leftBottom = imageInput.at<uchar>(i + 1, j - 1);
127             uchar bottom = imageInput.at<uchar>(i + 1, j);
128             uchar rightBottom = imageInput.at<uchar>(i + 1, j + 1);
129             int direction = pointDirection[k];
130             if (direction > 0 && direction <= 45)
131             {
132                 if (val <= right + tan(direction)*(rightTop - right) ||
133                     val <= left + tan(direction)*(leftBottom - left))
134                 {
135                     imageInput.at<uchar>(i, j) = 0;
136                 }
137             }
138             if (direction > 45 && direction <= 90)
139             {
140                 if (val <= top + tan(90 - direction)*(rightTop - top) ||
141                     val <= bottom + tan(90 - direction)*(leftBottom - bottom))
142                 {
143                     imageInput.at<uchar>(i, j) = 0;
144                 }
145             }
146             if (direction > 90 && direction <= 135)
147             {
148                 if (val <= top + tan(direction - 90)*(leftTop - top) ||
149                     val <= bottom + tan(direction - 90)*(rightBottom - bottom))
150                 {
151                     imageInput.at<uchar>(i, j) = 0;
152                 }
153             }
154             if (direction > 135 && direction <= 180)
155             {
156                 if (val <= left + tan(180 - direction)*(leftTop - left) ||
157                     val <= right + tan(180 - direction)*(rightBottom - right))
158                 {
159                     imageInput.at<uchar>(i, j) = 0;
160                 }
161             }
162             k++;
163         }
164     }
165 }
166 
167 void DoubleThreshold(Mat &imageInput, int lowThreshold, int highThreshold)
168 {
169     for (int i = 0; i < imageInput.rows; i++)
170     {
171         uchar *ptr = imageInput.ptr<uchar>(i);
172         for (int j = 0; j < imageInput.cols; j++)
173         {
174             if (ptr[j] < lowThreshold) ptr[j] = 0;
175             else if (ptr[j] >= highThreshold) ptr[j] = 255;
176         }
177     }
178 }
179 
180 bool LinkWithMaxValue(Mat image, int i, int j)
181 {
182     uchar val = image.at<uchar>(i, j);
183     uchar leftTop = image.at<uchar>(i - 1, j - 1);
184     uchar top = image.at<uchar>(i - 1, j);
185     uchar rightTop = image.at<uchar>(i - 1, j + 1);
186     uchar left = image.at<uchar>(i, j - 1);
187     uchar right = image.at<uchar>(i, j + 1);
188     uchar leftBottom = image.at<uchar>(i + 1, j - 1);
189     uchar bottom = image.at<uchar>(i + 1, j);
190     uchar rightBottom = image.at<uchar>(i + 1, j + 1);
191     return (leftTop == 255 || top == 255 || rightTop == 255 || left == 255 ||
192         right == 255 || leftBottom == 255 || bottom == 255 || rightBottom == 255);
193 }
194 
195 void DoubleThresholdLink(Mat &imageOutput)
196 {
197     int dx[] = { -1, 0, 1 };
198     int dy[] = { -1, 0, 1 };
199     bool *visited = new bool[imageOutput.rows*imageOutput.cols];
200     stack<Point> mst;
201     for (int i = 0; i < imageOutput.rows*imageOutput.cols; i++) visited[i] = 0;
202     for (int i = 1; i < imageOutput.rows - 1; i++)
203     {
204         for (int j = 1; j < imageOutput.cols - 1; j++)
205         {
206             if (visited[i*imageOutput.rows + j]) continue;
207             visited[i*imageOutput.rows + j] = 1;
208             uchar val = imageOutput.at<uchar>(i, j);
209             if (!val || val == 255) continue;
210             if (LinkWithMaxValue(imageOutput, i, j))
211             {
212                 imageOutput.at<uchar>(i, j) = 255;
213                 while (!mst.empty())
214                 {
215                     Point temp = mst.top(); mst.pop();
216                     if (visited[temp.x*imageOutput.rows + temp.y]) continue;
217                     visited[temp.x*imageOutput.rows*temp.x + temp.y] = 1;
218                     int data = imageOutput.at<uchar>(temp.x, temp.y);
219                     if (!data) continue;
220                     imageOutput.at<uchar>(temp.x, temp.y) = 255;
221                     for (int r = 0; r < 3; r++)
222                     {
223                         for (int c = 0; c < 3; c++)
224                         {
225                             uchar changedX = temp.x + dx[r];
226                             uchar changedY = temp.y + dy[c];
227                             if (visited[changedX*imageOutput.rows + changedY]) continue;
228                             mst.push(Point(changedX, changedY));
229                         }
230                     }
231                 }
232             }
233             else imageOutput.at<uchar>(i, j) = 0;
234         }
235     }
236 }
View Code

参考博客：

博客1：https://blog.csdn.net/dcrmg/article/details/52344902

博客2：https://www.cnblogs.com/love6tao/p/5152020.html

其中，文中所用图片来自博客2

猜你喜欢

转载自www.cnblogs.com/ctqchina/p/12343060.html
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
NEFU 117 素数个数的位数
Closest Common Ancestors (Lca,tarjan)
ELK部署
【转载】Hive笔记整理（三）
SQL语句（一）基本表的定义
关于Java web开发中的MySQL的事务语句
MFC创建自定义窗体
如何用一句话激怒程序员？
《逆袭大学》文摘——9.4 基础和应用的平衡中找到大学的节奏
【spring源码分析】@Value注解原理
每日归档
更多
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022