Canny边缘检测算法是John F. Canny于 1986 年开发出来的一个多级边缘检测算法。截止目前googlescholar上引用次数达到3万多次。
论文地址:《A Computational Approach to Edge Detection 》
Canny边缘检测算法步骤:
1.利用高斯低通滤波器平滑图像,目的为了去除图像中噪声影响。
2.计算图像的强度梯度(intensity gradient)
3.应用非最大值抑制(non-maximum suppression)技术消除边误检(本来不是边缘,但检测出来是)
4.应用双阈值的方法来决定可能潜在的边缘。小阈值用来控制边缘连接,大的阈值用来控制强边缘的初始分割。
5.提取并连接边界输出边缘图像。
在matlab和opencv中均有已经封装好的函数,只要填好相应参数就行。
如果是自己实现步骤具体思路:
①高斯低通平滑滤波:
可以自己设置一个高斯卷积核G(x,y,δ),
图像与高斯平滑滤波器卷积:
②利用一阶有限差分计算梯度幅值与方位角:
例如:Sobel算子等。
梯度幅值与方向:
但是由于局部极值周围存在相近数值的点,所以需要进行非极大值抑制(NMS)。
③非极大值抑制(Non-Maxima suppression):
主要思路:由梯度幅值图像M(x,y)的结果,仅保留极大值,严格来说,保留梯度方向上的极大值点。
得到的图像为N(x,y),具体过程:
- 初始化N(x,y)=M(x,y)
- 对于每个点,在梯度方向和反梯度方向各找n个像素点,若M(x,y)不是这些点中的最大点,则将N(x,y)处点置零,否则,N(x,y)保持不变。
- N(x,y)单像素宽度问题,额外的边缘点,丢失的边缘点。
在沿着梯度方向上检测该点是否为局部极大值,通常简化为只用四个方向(0°,45°,90°,135°),得到的N(x,y)为包含边缘的宽度为1个像素。
④对上面得到的N(x,y)图像利用两个阈值进行二值化。
- 使用小阈值T1,得到大量的边缘点E1,大量的误检测点。
- 使用大阈值T2,得到少量的边缘点图像E2,许多空隙。
⑤边缘连接
- 将E2中相连的边缘点输出为一幅边缘图像E(x,y)
- 对于E(x,y)中每条边,从端点出发,在E1中寻找其延长的部分,直至与E(x,y)中另外一条边的端点相连,否则认为其没有连接部分。
- 将连接结果E(x,y)输出。
图像效果如下:
- Canny算子的优点:
- 参数较少
- 计算效率
- 得到的边缘连续完整
- 参数的选择:
- Gauss滤波的尺度δ参数等。
- 双阈值的选择(双阈值的经验:指定一个低阈值A,一个高阈值B,一般取B为图像整体灰度级分布的70%,且B为1.5到2倍大小的A;灰度值小于A的,置为0,灰度值大于B的,置为255;)
C++代码实现:
#include <iostream>
#include "opencv2/opencv.hpp"
using namespace std;
using namespace cv;
/*
生成高斯卷积核 kernel
*/
void gaussian_kernel(int kernel_size, int sigma, Mat &kernel)
{
const double PI = 4*atan(1);
int m = kernel_size / 2;
kernel = Mat(kernel_size, kernel_size, CV_32FC1);
float s = 2 * sigma*sigma;
for (int i = 0; i < kernel_size; i++)
{
for (int j = 0; j < kernel_size; j++)
{
int x = i - m;
int y = j - m;
kernel.at<float>(i, j) = exp(-(x*x + y*y) / s) / (PI*s);
}
}
}
/*
计算梯度值和方向
imageSource 原始灰度图
imageX X方向梯度图像
imageY Y方向梯度图像
gradXY 该点的梯度幅值
pointDirection 梯度方向角度
*/
void gradDirection(const Mat imageSource, Mat &imageX, Mat &imageY,Mat &gradXY, Mat &theta)
{
imageX = Mat::zeros(imageSource.size(), CV_32SC1);
imageY = Mat::zeros(imageSource.size(), CV_32SC1);
gradXY = Mat::zeros(imageSource.size(), CV_32SC1);
theta = Mat::zeros(imageSource.size(), CV_32SC1);
int rows = imageSource.rows;
int cols = imageSource.cols;
int stepXY = imageX.step;
int step = imageSource.step;
/*
Mat.step参数指图像的一行实际占用的内存长度,
因为opencv中的图像会对每行的长度自动补齐(8的倍数),
编程时尽量使用指针,指针读写像素是速度最快的,使用at函数最慢。
*/
uchar *PX = imageX.data;
uchar *PY = imageY.data;
uchar *P = imageSource.data;
uchar *XY = gradXY.data;
for (int i = 1; i < rows - 1; i++)
{
for (int j = 1; j < cols - 1; j++)
{
int a00 = P[(i - 1)*step + j - 1];
int a01 = P[(i - 1)*step + j];
int a02 = P[(i - 1)*step + j + 1];
int a10 = P[i*step + j - 1];
int a11 = P[i*step + j];
int a12 = P[i*step + j + 1];
int a20 = P[(i + 1)*step + j - 1];
int a21 = P[(i + 1)*step + j];
int a22 = P[(i + 1)*step + j + 1];
double gradY = double(a02 + 2 * a12 + a22 - a00 - 2 * a10 - a20);
double gradX = double(a00 + 2 * a01 + a02 - a20 - 2 * a21 - a22);
//PX[i*stepXY + j*(stepXY / step)] = abs(gradX);
//PY[i*stepXY + j*(stepXY / step)] = abs(gradY);
imageX.at<int>(i, j) = abs(gradX);
imageY.at<int>(i, j) = abs(gradY);
if (gradX == 0)
{
gradX = 0.000000000001;
}
theta.at<int>(i, j) = atan(gradY / gradX)*57.3;
theta.at<int>(i, j) = (theta.at<int>(i, j) + 360) % 360;
gradXY.at<int>(i, j) = sqrt(gradX*gradX + gradY*gradY);
//XY[i*stepXY + j*(stepXY / step)] = sqrt(gradX*gradX + gradY*gradY);
}
}
convertScaleAbs(imageX, imageX);
convertScaleAbs(imageY, imageY);
convertScaleAbs(gradXY, gradXY);
}
/*
局部非极大值抑制
沿着该点梯度方向,比较前后两个点的幅值大小,若该点大于前后两点,则保留,
若该点小于前后两点任意一点,则置为0;
imageInput 输入得到梯度图像
imageOutput 输出的非极大值抑制图像
theta 每个像素点的梯度方向角度
imageX X方向梯度
imageY Y方向梯度
*/
void nonLocalMaxValue(const Mat imageInput, Mat &imageOutput, const Mat &theta, const Mat &imageX, const Mat &imageY)
{
imageOutput = imageInput.clone();
int cols = imageInput.cols;
int rows = imageInput.rows;
for (int i = 1; i < rows - 1; i++)
{
for (int j = 1; j < cols - 1; j++)
{
if (0 == imageInput.at<uchar>(i, j))continue;
int g00 = imageInput.at<uchar>(i - 1, j - 1);
int g01 = imageInput.at<uchar>(i - 1, j);
int g02 = imageInput.at<uchar>(i - 1, j + 1);
int g10 = imageInput.at<uchar>(i , j - 1);
int g11 = imageInput.at<uchar>(i, j);
int g12 = imageInput.at<uchar>(i , j + 1);
int g20 = imageInput.at<uchar>(i + 1, j - 1);
int g21 = imageInput.at<uchar>(i + 1, j);
int g22 = imageInput.at<uchar>(i + 1, j + 1);
int direction = theta.at<int>(i, j); //该点梯度的角度值
int g1 = 0;
int g2 = 0;
int g3 = 0;
int g4 = 0;
double tmp1 = 0.0; //保存亚像素点插值得到的灰度数
double tmp2 = 0.0;
double weight = fabs((double)imageY.at<uchar>(i, j) / (double)imageX.at<uchar>(i, j));
if (weight == 0)weight = 0.0000001;
if (weight > 1)
{
weight = 1 / weight;
}
if ((0 <= direction && direction < 45) || 180 <= direction &&direction < 225)
{
tmp1 = g10*(1 - weight) + g20*(weight);
tmp2 = g02*(weight)+g12*(1 - weight);
}
if ((45 <= direction && direction < 90) || 225 <= direction &&direction < 270)
{
tmp1 = g01*(1 - weight) + g02*(weight);
tmp2 = g20*(weight)+g21*(1 - weight);
}
if ((90 <= direction && direction < 135) || 270 <= direction &&direction < 315)
{
tmp1 = g00*(weight)+g01*(1 - weight);
tmp2 = g21*(1 - weight) + g22*(weight);
}
if ((135 <= direction && direction < 180) || 315 <= direction &&direction < 360)
{
tmp1 = g00*(weight)+g10*(1 - weight);
tmp2 = g12*(1 - weight) + g22*(weight);
}
if (imageInput.at<uchar>(i, j) < tmp1 || imageInput.at<uchar>(i, j) < tmp2)
{
imageOutput.at<uchar>(i,j) = 0;
}
}
}
}
/*
双阈值的机理是:
指定一个低阈值A,一个高阈值B,一般取B为图像整体灰度级分布的70%,且B为1.5到2倍大小的A;
灰度值小于A的,置为0,灰度值大于B的,置为255;
*/
void doubleThreshold(Mat &imageInput, const double lowThreshold, const double highThreshold)
{
int cols = imageInput.cols;
int rows = imageInput.rows;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
double temp = imageInput.at<uchar>(i, j);
temp = temp>highThreshold ? (255) : (temp);
temp = temp < lowThreshold ? (0) : (temp);
imageInput.at<uchar>(i, j) = temp;
}
}
}
/*
连接处理:
灰度值介于A和B之间的,考察该像素点临近的8像素是否有灰度值为255的,
若没有255的,表示这是一个孤立的局部极大值点,予以排除,置为0;
若有255的,表示这是一个跟其他边缘有“接壤”的可造之材,置为255,
之后重复执行该步骤,直到考察完之后一个像素点。
其中的邻域跟踪算法,从值为255的像素点出发找到周围满足要求的点,把满足要求的点设置为255,
然后修改i,j的坐标值,i,j值进行回退,在改变后的i,j基础上继续寻找255周围满足要求的点。
当所有连接255的点修改完后,再把所有上面所说的局部极大值点置为0;(算法可以继续优化)。
参数1,imageInput:输入和输出的梯度图像
参数2,lowTh:低阈值
参数3,highTh:高阈值
*/
void doubleThresholdLink(Mat &imageInput,double lowTh,double highTh)
{
int cols = imageInput.cols;
int rows = imageInput.rows;
for (int i = 1; i < rows - 1; i++)
{
for (int j = 1; j < cols - 1; j++)
{
double pix = imageInput.at<uchar>(i, j);
if (pix != 255)continue;
bool change = false;
for (int k = -1; k <= 1; k++)
{
for (int u = -1; u <= 1; u++)
{
if (k == 0 && u == 0)continue;
double temp = imageInput.at<uchar>(i + k, j + u);
if (temp >= lowTh && temp <= highTh)
{
imageInput.at<uchar>(i + k, j + u) = 255;
change = true;
}
}
}
if (change)
{
if (i > 1)i--;
if (j > 2)j -= 2;
}
}
}
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
if (imageInput.at<uchar>(i, j) != 255)
{
imageInput.at<uchar>(i, j) = 0;
}
}
}
}
int main()
{
Mat image = imread("F:\\OutputResult\\SrcImage\\lena.jpg");
imshow("origin image", image);
//转换为灰度图
Mat grayImage;
cvtColor(image, grayImage, COLOR_RGB2GRAY);
imshow("gray image", grayImage);
//高斯滤波
Mat gausKernel;
int kernel_size = 3;
double sigma = 1;
gaussian_kernel(kernel_size, sigma, gausKernel);
Mat gausImage;
filter2D(grayImage, gausImage, grayImage.depth(), gausKernel);
imshow("gaus image", gausImage);
//计算XY方向梯度
Mat imageX, imageY, imageXY;
Mat theta;
gradDirection(grayImage, imageX, imageY, imageXY , theta);
imshow("XY grad", imageXY);
//对梯度幅值进行非极大值抑制
Mat localImage;
nonLocalMaxValue(imageXY, localImage, theta,imageX,imageY);;
imshow("Non local maxinum image", localImage);
//双阈值算法检测和边缘连接
doubleThreshold(localImage, 60, 100);
doubleThresholdLink(localImage, 60, 100);
imshow("canny image", localImage);
//opencv自带的canny边缘检测函数调用形式
//void cv::Canny( InputArray _src, OutputArray _dst,
//double low_thresh, double high_thresh,
//int aperture_size, bool L2gradient )
Mat dstImage;
Canny(image, dstImage, 60, 100);
imshow("opencv canny image", dstImage);
waitKey(0);
return 0;
}
参考博客:
https://blog.csdn.net/u010551600/article/details/80739610
https://www.cnblogs.com/techyan1990/p/7291771.html