OpenCV图像处理专栏十九 | 手动实现基于Canny算子的边缘检测

最新推荐文章于 2024-09-28 06:00:00 发布
最新推荐文章于 2024-09-28 06:00:00 发布
阅读量2.1k 收藏 17
点赞数 3
分类专栏： 数字图像处理论文和算法复现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/just_sort/article/details/85053157
版权

1. 前言

接着昨天手动构造Sobel算子实现检测，今天来讲讲如何手动实现Canny边缘检测。由于要实现这个算法的需要的先验知识比较多，所以在学习这个算法的实现之前我们先来学习一下用于图像二值化的OSTU大津法。

2. OTSU算法原理

Ostu方法又名最大类间差方法，通过统计整个图像的直方图特性来实现全局阈值 t t t的自动选取。

它将图像的像素按灰度级分成 2 2 2个部分，使得 2 2 2个部分之间的灰度值差异最小，通过方差的计算来寻找一个合适的灰度级别来划分。

OTSU算法的计算很简单，不受到图像亮度和对比度的影响，因此使得类间方差最大的分割意味着错分概率最小。

设 t t t为灰度级阈值，从 L L L(一般为 255 255 255)个灰度级遍历 t t t，使得 t t t为某个值的时候，前景和背景的方差最大，这个 t t t值便是我们要求的灰度级阈值。

设 w 0 w0 w0表示分开后前景像素点占图像像素比例， u 0 u0 u0表示分开后前景像素点的平均灰度， w 1 w1 w1表示分开后背景像素点数占图像比例， u 1 u1 u1表示分开后背景像素点的平均灰度。

图像的总灰度被定义为：

u = w 0 ∗ u 0 + w 1 ∗ u 1.............. ( 1 ) u=w0*u0+w1*u1..............(1) u=w0∗u0+w1∗u1..............(1)

图像的方差计算公式为：

g = w 0 ∗ ( u 0 − w 0 ) ∗ ( u 0 − w 0 ) + w 1 ∗ ( u 1 − w 1 ) ∗ ( u 1 − w 1 ) . . . . . . . . . . . . . . . ( 2 ) g=w0*(u0-w0)*(u0-w0)+w1*(u1-w1)*(u1-w1)...............(2) g=w0∗(u0−w0)∗(u0−w0)+w1∗(u1−w1)∗(u1−w1)...............(2)

并且有：

w 0 + w 1 = 1................................... ( 3 ) w0+w1=1...................................(3) w0+w1=1...................................(3)

所以可以把公式(2)展开化简为：

g = w 0 ∗ w 1 ∗ ( u 0 − u 1 ) ∗ ( u 0 − u 1 ) g=w0*w1*(u0-u1)*(u0-u1) g=w0∗w1∗(u0−u1)∗(u0−u1)

公式推导完毕，我们来看一下OTSU算法的详细步骤。

3. OTSU算法流程

  • 先计算图像的直方图，即将图像所有的像素点按照 0   255 0~255 0 255共 256 256 256个bin，统计落在每个bin的像素点数量。
  • 归一化直方图，也即将每个bin中像素点数量除以总的像素点。
  • i i i表示分类的阈值，也即一个灰度级，从 0 0 0开始迭代。
  • 通过归一化的直方图，统计 [ 0 ， i ] [0，i] [0，i]灰度级的像素(假设像素值在此范围的像素叫做前景像素) 所占整幅图像的比例 w 0 w0 w0，并统计前景像素的平均灰度 u 0 u0 u0。然后统计 [ i ， 255 ] [i，255] [i，255]灰度级的像素(假设像素值在此范围的像素叫做背景像素) 所占整幅图像的比例 w 1 w1 w1，并统计背景像素的平均灰度 u 1 u1 u1。
  • 计算前景像素和背景像素的方差 g = w 0 ∗ w 1 ∗ ( u 0 − u 1 ) ∗ ( u 0 − u 1 ) g=w0*w1*(u0-u1)*(u0-u1) g=w0∗w1∗(u0−u1)∗(u0−u1)（已经推导了）。
  • 不断 i + + i++ i++，转到第 4 4 4个步骤。
  • 将最大 g g g相应的 i i i值作为图像的全局阈值。

4. OTSU算法代码实现

int OTSU(Mat src){
    int row = src.rows;
    int col = src.cols;
    int PixelCount[256]={0};
    float PixelPro[256]={0};
    int total_Pixel = row * col;
    float threshold = 0;
    //统计灰度级中每个像素在整副图中的个数
    for(int i = 0; i < row; i++){
        for(int j = 0; j < col; j++){
            PixelCount[src.at<int>(i, j)]++;
        }
    }
    //计算每个像素在整副图中的个数
    for(int i = 0; i < 256; i++){
        PixelPro[i] = (float)(PixelCount[i]) / (float)(total_Pixel);
    }
    //遍历灰度级[0,255]，计算出方差最大的灰度值，为最佳阈值
    float w0, w1, u0tmp, u1tmp, u0, u1, u, deltaTmp, deltaMax = 0;
    for(int i = 0; i < 256; i++){
        w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;
        for(int j = 0; j < 256; j++){
            if(j <= i){//以i为阈值分类，第一类总的概率
                w0 += PixelPro[j];
                u0tmp += j * PixelPro[j];
            }else{//前景部分
                w1 += PixelPro[j];
                u1tmp += j * PixelPro[j];
            }
        }
        u0 = u0tmp / w0; //第一类的平均灰度
        u1 = u1tmp / w1; //第二类的平均灰度
        u = u0 + u1; //整副图像的平均灰度
        //计算类间方差
        deltaTmp = w0 * (u0 - u) * (u0 - u) + w1 * (u1 - u) * (u1 - u);
        //找出最大类间方差以及对应阈值
        if(deltaTmp > deltaMax){
            deltaMax = deltaTmp;
            threshold = i;
        }
    }
    return threshold;
}

5. 边缘检测的一般标准

边缘检测有下面几个标准：
(1) 以低的错误率检测边缘，也即意味着需要尽可能准确的捕获图像中尽可能多的边缘。
(2) 检测到的边缘应精确定位在真实边缘的中心。
(3) 图像中给定的边缘应只被标记一次，并且在可能的情况下，图像的噪声不应产生假的边缘。

6. Canny算子边缘检测步骤

有了上面的铺垫，我们来到今天的主题，我们直接来看一下基于Canny算子进行边缘检测的步骤，我会在第6节详细讲解每一个步骤。基于Canny算子边缘检测的步骤如下：

  • 使用高斯滤波算法，以平滑图像，滤除噪声
  • 计算图像中每个像素点的梯度强度和方向
  • 应用非极大值抑制，以消除边缘检测带来的杂散响应
  • 应用双阈值检测来确定真正的边缘和潜在的边缘
  • 通过抑制孤立的弱边缘最终完成边缘检测

7. 对应算法步骤的详细解释

7.1 高斯滤波

首先高斯函数的定义为 h ( x , y ) = e − x 2 + y 2 2 σ 2 h(x, y) = e^{-\frac{x^2+y^2}{2\sigma^2}} h(x,y)=e−2σ2x2+y2​，其中 ( x , y ) (x,y) (x,y)是图像中像素点的坐标， σ \sigma σ为标准差，高斯模板就是利用这个函数来计算的。

接下来看高斯模板是如何构造的，假设高斯模板的尺寸为 ( 2 k + 1 ) × ( 2 k + 1 ) (2k+1)\times (2k+1) (2k+1)×(2k+1)。

为什么长宽都为奇数，这主要是保证整个模板有唯一中心元素，便于计算。

高斯模板中的元素值为：

H i , j = 1 2 π σ 2 e − ( i − k − 1 ) 2 + ( j − k − 1 ) 2 2 σ 2 H_{i,j}=\frac{1}{2\pi {\sigma^2}}e^{-\frac{(i-k-1)^2+(j-k-1)^2}{2\sigma^2}} Hi,j​=2πσ21​e−2σ2(i−k−1)2+(j−k−1)2​

然后在实现生成高斯模板时，又有两种形式，即整数形式和小数形式。对于小数形式的就是按照上面的公式直接构造，不需要其他处理，而整数形式的需要归一化，即将模板左上角的值归一化为 1 1 1。

使用整数高斯模板时，需要在模板前面加一个系数，这个系数为 1 ∑ ( i , j ) ∈ w w i , j \frac{1}{\sum_{(i,j)\in w}w_{i,j}} ∑(i,j)∈w​wi,j​1​，就是模板系数和的导数。

生成小数高斯模板代码如下：

#define PI 3.1415926
//生成小数形式的高斯模板
void generateGaussianTemplate(double window[][11], int ksize, double sigma){
    int center = ksize / 2; //模板的中心位置，也就是坐标原点
    double x2, y2;
    for(int i = 0; i < ksize; i++){
        x2 = pow(i - center, 2);
        for(int j = 0; j < ksize; j++){
            y2 = pow(j - center, 2);
            double g = exp(-(x2 + y2)) / (2 * sigma * sigma);
            g /= 2 * PI * sigma;
            window[i][j] = g;
        }
    }
    //归一化左上角的数为1
    double k = 1 / window[0][0];
    for(int i = 0; i < ksize; i++) {
        for (int j = 0; j < ksize; j++) {
            window[i][j] *= k;
        }
    }
}

整数部分基本一样，就不说了。对于 k s i z e = 3 ksize=3 ksize=3， σ = 0.8 \sigma=0.8 σ=0.8的高斯模板结果为：

1.00000 2.71828 1.00000 
2.71828 7.38906 2.71828 
1.00000 2.71828 1.00000

这里想说一下 σ \sigma σ的作用，当 σ \sigma σ比较小的时候，生成的高斯模板中心的系数比较大，而周围的系数比较小，这样对图像的平滑效果不明显。而当 σ \sigma σ比较大时，生成的模板的各个系数相差就不是很大，比较类似于均值模板，对图像的平滑效果比较明显。

7.2 计算梯度强度和方向

利用Sobel算子返回水平 G x Gx Gx和垂直 G y Gy Gy的一阶导数值。以此来计算梯度强度 G G G和梯度方向。

G = G x 2 + G y 2 G=\sqrt{G_x^2+G_y^2} G=Gx2​+Gy2​ ​

θ = a r c t a n ( G y G x ) \theta = arctan(\frac{G_y}{G_x}) θ=arctan(Gx​Gy​​)

G x = ∑ i ∑ j S o b e l x i , j ∗ i m g i , j G_x=\sum_i\sum_jSobelx_{i,j}*img_{i,j} Gx​=∑i​∑j​Sobelxi,j​∗imgi,j​

G y = ∑ i ∑ j S o b e l y i , j ∗ i m g i , j G_y=\sum_i\sum_jSobely_{i,j}*img_{i,j} Gy​=∑i​∑j​Sobelyi,j​∗imgi,j​

关于Sobel算子的构造请看昨天的推文：OpenCV图像处理专栏十八 | 手动构造Sobel算子完成边缘检测

7.3 应用非极大值抑制，以消除边缘检测带来的杂散响应

非极大值抑制是一种边缘稀疏技术，作用在于瘦边。在对图片进行梯度计算之后，仅仅基于梯度值提取的边缘仍然比较模糊。根据标准(3)，对边缘有且应当只有一个准确的响应。而非极大值抑制可以帮助将将局部最大值之外的所有梯度值抑制为 0 0 0，对梯度图像中每个像素进行非极大值抑制的算法步骤为：

(1) 将当前像素的梯度强度与沿正负梯度方向上的两个像素进行比较。

(2) 如果当前像素的梯度值与另外两个像素值相比最大，则该像素点保留为边缘点，否则该像素点被抑制。

通常为了更加精确的计算，在跨梯度方向的两个相邻像素之间使用线性插值来得到要比较的像素梯度。

Fig1. 梯度方向分割例子

如Fig1所示，将梯度分为 8 8 8个方向，分别为E、NE、N、NW、W、SW、S、SE。其中 0 0 0代表 [ 0 o , 4 5 o ] [0^o,45^o] [0o,45o], 1 1 1代表 [ 4 5 o , 9 0 o ] [45^o,90^o] [45o,90o]， 2 2 2代表 [ − 9 0 o , − 4 5 o ] [-90^o,-45^o] [−90o,−45o]， 3 3 3代表 [ − 4 5 o , 0 o ] [-45^o,0^o] [−45o,0o]。像素点 P P P的梯度方向为 θ \theta θ，则像素点 P 1 P1 P1和 P 2 P2 P2的梯度线性插值为：

梯度线性插值

因此非极大值抑制的伪代码如下：

非极大值抑制的伪代码

需要注意的是，如何标志方向并不重要，重要的是梯度方向的计算要和梯度算子的选取保持一致。

7.4 双阈值检测

在施加非极大值抑制之后，剩余的像素可以更准确地表示图像中的实际边缘。然而，仍然存在由于噪声和颜色变化引起的一些边缘像素。为了解决这些杂散响应，必须用弱梯度值过滤边缘像素，并保留具有高梯度值的边缘像素，可以通过选择高低阈值来实现。如果边缘像素的梯度值高于高阈值，则将其标记为强边缘像素；如果边缘像素的梯度值小于高阈值并且大于低阈值，则将其标记为弱边缘像素；如果边缘像素的梯度值小于低阈值，则会被抑制。阈值的选择取决于给定输入图像的内容。

双阈值检测的伪代码如下：

双阈值检测伪代码

7.5 抑制孤立弱边缘完成边缘检测

到目前为止，被划分为强边缘的像素点已经被确定为边缘，因为它们是从图像中的真实 边缘中提取出来的。然而，对于弱边缘像素，将会有一些争论，因为这些像素可以从真实边缘提取也可以是因噪声或颜色变化引起的。为了获得准确的结果，应该抑制由后者引起的弱边缘。通常，由真实边缘引起的弱边缘像素将连接到强边缘像素，而噪声响应未连接。为了跟踪边缘连接，通过查看弱边缘像素及其 8 8 8个邻域像素，只要其中一个为强边缘像素，则该弱边缘点就可以保留为真实的边缘。

这部分的伪代码如下：

抑制孤立弱边缘完成边缘检测

8. C++代码实现

按照上面的步骤一步步实现基于Canny的边缘检测算法，代码如下：

const double PI = 3.1415926;

double getSum(Mat src){
    double sum = 0;
    for(int i = 0; i < src.rows; i++){
        for(int j = 0; j < src.cols; j++){
            sum += (double)src.at<double>(i, j);
        }
    }
    return sum;
}

Mat CannyEdgeDetection(cv::Mat src, int kSize, double hightThres, double lowThres){
//    if(src.channels() == 3){
//        cvtColor(src, src, CV_BGR2GRAY);
//    }
    cv::Rect rect;
    Mat gaussResult;
    int row = src.rows;
    int col = src.cols;
    printf("%d %d\n", row, col);
    Mat filterImg = Mat::zeros(row, col, CV_64FC1);
    src.convertTo(src, CV_64FC1);
    Mat dst = Mat::zeros(row, col, CV_64FC1);
    int gaussCenter = kSize / 2;
    double  sigma = 1;
    Mat guassKernel = Mat::zeros(kSize, kSize, CV_64FC1);
    for(int i = 0; i < kSize; i++){
        for(int j = 0; j < kSize; j++){
            guassKernel.at<double>(i, j) = (1.0 / (2.0 * PI * sigma * sigma)) * (double)exp(-(((double)pow((i - (gaussCenter+1)), 2) + (double)pow((j-(gaussCenter+1)), 2)) / (2.0*sigma*sigma)));
        }
    }
    Scalar sumValueScalar = cv::sum(guassKernel);
    double sum = sumValueScalar.val[0];
    guassKernel = guassKernel / sum;
    for(int i = gaussCenter; i < row - gaussCenter; i++){
        for(int j = gaussCenter; j < col - gaussCenter; j++){
            rect.x = j - gaussCenter;
            rect.y = i - gaussCenter;
            rect.width = kSize;
            rect.height = kSize;
            //printf("%d %d\n", i, j);
            //printf("%d %d %.5f\n", i, j, cv::sum(guassKernel.mul(src(rect))).val[0]);
            filterImg.at<double>(i, j) = cv::sum(guassKernel.mul(src(rect))).val[0];
        }
    }
    Mat gradX = Mat::zeros(row, col, CV_64FC1); //水平梯度
    Mat gradY = Mat::zeros(row, col, CV_64FC1); //垂直梯度
    Mat grad = Mat::zeros(row, col, CV_64FC1); //梯度幅值
    Mat thead = Mat::zeros(row, col, CV_64FC1); //梯度角度
    Mat whereGrad = Mat::zeros(row, col, CV_64FC1);//区域
    //x方向的Sobel算子
    Mat Sx = (cv::Mat_<double>(3, 3) << -1, 0, 1, -2, 0, 2, -1, 0, 1);
    //y方向的Sobel算子
    Mat Sy = (cv::Mat_<double >(3, 3) << 1, 2, 1, 0, 0, 0, -1, -2, -1);
    //计算梯度赋值和角度
    for(int i=1; i < row-1; i++){
        for(int j=1; j < col-1; j++){
            rect.x = j-1;
            rect.y = i-1;
            rect.width = 3;
            rect.height = 3;
            Mat rectImg = Mat::zeros(3, 3, CV_64FC1);
            filterImg(rect).copyTo(rectImg);
            //梯度和角度
            gradX.at<double>(i, j) += cv::sum(rectImg.mul(Sx)).val[0];
            gradY.at<double>(i, j) += cv::sum(rectImg.mul(Sy)).val[0];
            grad.at<double>(i, j) = sqrt(pow(gradX.at<double>(i, j), 2) + pow(gradY.at<double>(i, j), 2));
            thead.at<double>(i, j) = atan(gradY.at<double>(i, j)/gradX.at<double>(i, j));
            if(0 <= thead.at<double>(i, j) <= (PI/4.0)){
                whereGrad.at<double>(i, j) = 0;
            }else if(PI/4.0 < thead.at<double>(i, j) <= (PI/2.0)){
                whereGrad.at<double>(i, j) = 1;
            }else if(-PI/2.0 <= thead.at<double>(i, j) <= (-PI/4.0)){
                whereGrad.at<double>(i, j) = 2;
            }else if(-PI/4.0 < thead.at<double>(i, j) < 0){
                whereGrad.at<double>(i, j) = 3;
            }
        }
    }
    //printf("success\n");
    //梯度归一化
    double gradMax;
    cv::minMaxLoc(grad, &gradMax);
    if(gradMax != 0){
        grad = grad / gradMax;
    }
    //双阈值确定
    cv::Mat caculateValue = cv::Mat::zeros(row, col, CV_64FC1); //grad变成一维
    resize(grad, caculateValue, Size(1, grad.rows * grad.cols));
    cv::sort(caculateValue, caculateValue, CV_SORT_EVERY_COLUMN + CV_SORT_ASCENDING);//升序
    long long highIndex= row * col * hightThres;
    double highValue = caculateValue.at<double>(highIndex, 0); //最大阈值
    double lowValue = highValue * lowThres;
    //NMS
    for(int i = 1 ; i < row-1; i++ ){
        for( int j = 1; j<col-1; j++){
            // 八个方位
            double N = grad.at<double>(i-1, j);
            double NE = grad.at<double>(i-1, j+1);
            double E = grad.at<double>(i, j+1);
            double SE = grad.at<double>(i+1, j+1);
            double S = grad.at<double>(i+1, j);
            double SW = grad.at<double>(i-1, j-1);
            double W = grad.at<double>(i, j-1);
            double NW = grad.at<double>(i -1, j -1); // 区域判断，线性插值处理
            double tanThead; // tan角度
            double Gp1; // 两个方向的梯度强度
            double Gp2; // 求角度，绝对值
            tanThead = abs(tan(thead.at<double>(i,j)));
            switch ((int)whereGrad.at<double>(i,j)) {
                case 0: Gp1 = (1- tanThead) * E + tanThead * NE; Gp2 = (1- tanThead) * W + tanThead * SW; break;
                case 1: Gp1 = (1- tanThead) * N + tanThead * NE; Gp2 = (1- tanThead) * S + tanThead * SW; break;
                case 2: Gp1 = (1- tanThead) * N + tanThead * NW; Gp2 = (1- tanThead) * S + tanThead * SE; break;
                case 3: Gp1 = (1- tanThead) * W + tanThead *NW; Gp2 = (1- tanThead) * E + tanThead *SE; break;
                default: break;
            }
            // NMS -非极大值抑制和双阈值检测
            if(grad.at<double>(i, j) >= Gp1 && grad.at<double>(i, j) >= Gp2){
                //双阈值检测
                if(grad.at<double>(i, j) >= highValue){
                    grad.at<double>(i, j) = highValue;
                    dst.at<double>(i, j) = 255;
                } else if(grad.at<double>(i, j) < lowValue){
                    grad.at<double>(i, j) = 0;
                } else{
                    grad.at<double>(i, j) = lowValue;
                }
            } else{
                grad.at<double>(i, j) = 0;
            }
        }
    }
    //抑制孤立低阈值点 3*3. 找到高阈值就255
    for(int i = 1; i < row - 1; i++){
        for(int j = 1; j < col - 1; j++){
            if(grad.at<double>(i, j) == lowValue){
                //3*3 区域强度
                rect.x = i-1;
                rect.y = j-1;
                rect.width = 3;
                rect.height = 3;
                for(int x = 0; x < 3; x++){
                    for(int y = 0; y < 3; y++){
                        if(grad(rect).at<double>(x, y)==highValue){
                            dst.at<double>(i, j) = 255;
                            break;
                        }
                    }
                }
            }
        }
    }
    return dst;
}

9. 效果

虞姬原图

边缘检测结果
边缘检测的效果不如OpenCV自带的，需要再研究研究。

10. 结论

本文介绍了图像处理算法中最常用的边缘检测算法的原理以及一个C++复现，然而可惜的是效果没有OpenCV自带算法的效果好，并且速度也会稍慢，一定是某个细节没有处理完美，但作为科普来讲大概已经够用了，如果想实现完美的Sobel边缘检测请查看OpenCV源码或者和我一起讨论。

11. 参考

  • https://blog.csdn.net/jmu201521121021/article/details/80622011

  • https://www.cnblogs.com/techyan1990/p/7291771.html

欢迎关注GiantPandaCV, 在这里你将看到独家的深度学习分享，坚持原创，每天分享我们学习到的新鲜知识。( • ̀ω•́ )✧

有对文章相关的问题，或者想要加入交流群，欢迎添加BBuf微信：

二维码

just_sort
关注
专栏目录
图像处理-基于OpenCV实现的边缘检测算法之Canny.zip
04-03
在图像处理领域，边缘检测是至关重要的一步，它能够帮助我们识别图像中的物体轮廓和特征。Canny边缘检测算法是一种广泛使用的经典算法，由John F. Canny在1986年提出。这个算法以其高精度和低错误率而著名，被应用...
canny算子边缘检测
cherry926的专栏
09-17 1569
canny算子边缘检测主要分为四步： 1、高斯滤波 2、
第10章：Canny图像边缘检测
weixin_57440207的博客
01-23 2818
第10章：Canny图像边缘检测一、Canny边缘检测的基础：1. 应用高斯滤波去除图像噪声：2. 计算梯度3.非极大值抑制4. 应用双阈值确定边缘：二、Canny函数使用： ​ Canny边缘检测是一种使用多级边缘检测算法检测边缘的方法。1986年，John F.Canny发表了著名论文A Computational Approach to Approach to Edge Detection，在该论文中详述了如何进行边缘检测。 OpenCV中提供了函数cv2.Canny()来实现Canny边缘检测。
5步轻松掌握C#中的Canny边缘检测：OpenCvSharp实战指南
最新发布
java专栏
09-28 670
Canny边缘检测算法由John F. Canny于1986年提出，是一种多阶段的边缘检测算法。噪声去除：使用高斯滤波器平滑图像，去除噪声。梯度计算：计算图像的梯度强度和方向。非极大值抑制：去除梯度方向上非最大的像素值。双阈值检测：使用高低阈值确定边缘。边缘连接：通过边缘跟踪连接边缘。OpenCvSharp是一个C#绑定库，用于调用OpenCV（Open Source Computer Vision Library）的功能。
Canny边缘检测
weixin_44863781的博客
04-20 2450
Canny边缘检测主要分为五个步骤：一、高斯滤波；二、计算图像大小和梯度方向；三、非极大值抑制；四、双阈值筛选边缘；五、连接边缘。 一、高斯滤波 高斯滤波的主要目的是对图像进行平滑处理，降低噪声。高斯滤波器模板的模板中各元素计算公式为： f(x,y)=12πσ2e−x2+y22σ2f(x,y)=\frac{1}{2πσ^2}e^{-\frac{x^2+y^2}{2σ^2}}f(x,y)=2πσ21...
opencv基础44- Canny边缘检测详解-cv.Canny()
小海聊智造
08-07 1万+
Canny边缘检测是一种经典的边缘检测算法，由John F.Canny在1986年提出。它被广泛应用于计算机视觉和图像处理领域，是一种多阶段的边缘检测算法，能够有效地检测图像中的边缘并抑制噪声。Canny边缘检测的主要步骤如下：噪声抑制：首先，通过使用高斯滤波器对图像进行平滑处理，以去除图像中的噪声。高斯滤波器可以有效地平滑图像，同时保持边缘的细节。计算梯度幅值和方向：使用Sobel算子计算图像中每个像素点的水平和垂直方向的梯度值。然后，根据梯度值计算每个像素点的梯度幅值和方向。
Canny边缘检测的步骤以及一些重要步骤的原理（个人理解）
Mr_zhubao的博客
02-05 1570
其中w = distance(dTmp1 , g2) / distance(g1 , g2) （即dTmp1和g2之间的距离比上g1和g2的距离），这样便可以得到dTmp1的梯度强度，同理也可以得到dTmp2的梯度强度，这样的话便可以通过比较dTmp1、dTmp2、c三点的梯度强度来对c点进行非极大值抑制，当c点梯度强度小于dTmp1 or dTmp2中任一点时则对c点进行抑制。（3）若梯度强度值处于二者中间则看此像素点是否和边界点相连，如果是相连的话则将此点作为边界点保留，反之则将此点视为边界内点舍弃。
opencv-基于c++实现的opencv图像处理算法之Canny边缘检测.zip
05-15
在"opencv_基于c++实现的opencv图像处理算法之Canny边缘检测"这个项目中，开发者将详细介绍如何使用OpenCV库进行Canny边缘检测的每一个步骤，并可能提供示例代码，帮助读者理解并应用到自己的项目中。通过学习这个...
基于python+opencv实现的Canny算子边缘检测识别滑动验证码+源码+文档+原理介绍（毕业设计&课程设计&项目开发）
06-18
基于python实现的Canny算子边缘检测识别滑动验证码+源码+文档+原理介绍，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 项目简介： 本项目是一个通过简单图片边缘...
基于canny算子的边缘检测源代码opencv c++
04-25
在这个基于Canny算子的边缘检测源代码中，我们可以通过以下关键步骤来理解其工作原理：** 1. **高斯滤波**： 在进行边缘检测之前，首先对图像应用高斯滤波器来平滑图像，消除高频噪声。在这个项目中，可能包含了...
OpenCv实现Canny边缘检测
05-04
Canny 边缘检测是 OpenCV 库中实现的一种经典边缘检测算法，它由 John F. Canny 在1986年提出，旨在提供一种准确且鲁棒的边缘检测方法。 Canny 边缘检测的主要目标是检测图像中亮度显著变化的地方，这些地方通常...
视觉媒体通信——图像处理算法之Canny边缘检测
liyang927的博客
07-02 1802
从Canny边缘检测的基本原理出发，逐步实现了图像的Canny边缘检测
Canny边缘检测算法的流程
import_torch_as_tf
02-13 7714
原文链接：https://www.cnblogs.com/techyan1990/p/7291771.html 介绍 边缘检测的一般标准包括： 1) 以低的错误率检测边缘，也即意味着需要尽可能准确的捕获图像中尽可能多的边缘。 2) 检测到的边缘应精确定位在真实边缘的中心。 3) 图像中给定的边缘应只被标记一次，并且在可能的情况下，图像的噪声不应产生假的边缘。 在目前常用的边缘检测方法中，Canny边缘检测算法是具有严格定义的，可以提供良好可靠检测的方法之...
Canny边缘检测算法
爱学习的小刘芒的博客
06-21 1万+
Canny边缘检测算法---matlab , lingo , python中应用
Canny 边缘检测算子 (Wikipedia)
isometric的博客
07-10 3001
Canny 边缘检测算子 是一种多阶段边缘检测的算法，在 1986 年由 John F. Canny 发明。Canny 同时发展了边缘检测的计算理论，解释了为什么这个技巧会有用。 Canny 算法的发展 Canny 边缘检测是一种从不同的视觉物体中抽取有用结构信息的技巧。它被广泛应用于各种计算机视觉系统中。Canny 发现不同视觉系统中的边缘检测都相对相似。于是他阐述了一种可以在广泛情形下应用的解...
基于Canny算子的边缘检测————MATLAB
Prince_IT的博客
05-14 2万+
一、概念 Canny算子是一种非常重要的边缘检测算子，是最优的阶梯型边缘检测算子。它的最优性主要表现在以下三个方面; 好的检测：Canny算子可以尽可能多地标识出原始图像中的实际边缘。 好的定位：它所标记出来的边缘尽可能给你地接近实际图像中的实际边缘。 最小响应：图像中的边缘只能标识一次，并且可能存在的图像噪声不标识成边缘。 二、Canny算子的具体实现步骤如下: ①去噪声：任何边缘检测算法都不可...
图像处理——Canny算子
热门推荐
fengye2two的专栏
01-28 9万+
首先感谢以下两位的渊博知识： （1）爱鱼         https://www.cnblogs.com/mightycode/p/6394810.html （2）mitutao   https://www.cnblogs.com/love6tao/p/5152020.html 图像边缘信息主要集中在高频段，通常说图像锐化或检测边缘，实质就是高频滤波。我们知道微分运算是求信号的变化率，具有加
OpenCV3学习笔记——边缘检测之Canny算法解析
凝望，划过星空的博客
06-21 2514
边缘检测（Canny,Sobel,Laplacian) 边缘检测出现在了图像变换的许多地方，前段时间我在学习这一部分的知识时，看着这些算法的源码，品味它们的思想，真的是一边学一边感叹到——太牛逼了！所以打算写一篇博文来记录这段时间的学习成果 预备知识： 1. 边缘检测的一般步骤： 滤波：因为边缘检测主要是基于图像强度的一阶导和二阶导（具体导数的意义咱们一会探讨一下)，然而导数对噪声非常敏感，因...
基于canny算子边缘检测c++代码
05-12
Canny算法是一种常用的边缘检测算法，它主要包含以下几个步骤： 1. 高斯滤波：对原图像进行高斯滤波，去除噪声干扰。 2. 梯度计算：对滤波后的图像进行梯度计算，得到梯度的幅值和方向。 3. 非极大值抑制：对梯度...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值