Opencv和C++实现canny边缘检测

最新推荐文章于 2024-02-26 18:07:38 发布
最新推荐文章于 2024-02-26 18:07:38 发布
阅读量7.7k 收藏 76
点赞数 13
分类专栏： 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010551600/article/details/80739610
版权

Canny边缘检测主要包括：

  1. 图像的灰度化；

  2. 图像的高斯滤波，来平滑图像，同时消除和降低图像噪声的影响；

  3. 计算出每一个像素点位置的梯度（X方向梯度、Y方向梯度、已经该点的梯度幅值）和方向角度；Y方向和X方向梯度的比值，得出梯度方向，X梯度的平方和+Y梯度的平方和的值，再进行求平方得到该点的梯度幅值。（Sobel算子等）

  4. 局部非极大值抑制处理；梯度方向垂直于边缘方向，在梯度方向上进行非极大值抑制可以细化边缘，在梯度方向上比较该点前后两个点的梯度的大小，如果大于两个点则保留，小于任意一个点则置为0。

  5. 双阈值处理和连接处理；指定高低阈值，然后高阈值直接赋值为255，低阈值为0，中间的值进行连接处理。如果中间的值八邻域内有255，则该值也变为255，也就是说255往周围进行扩张，收集边缘加闭合边缘。

Canny算法思路参考下面的博客：
https://blog.csdn.net/dcrmg/article/details/52344902
https://www.cnblogs.com/love6tao/p/5152020.html

我在下面直接给出可以运行的C++代码（Opencv2.4.9）

#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 = 3.1415926;
    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("test.jpg");
    imshow("origin image", image);

    //转换为灰度图
    Mat grayImage;
    cvtColor(image, grayImage, CV_RGB2GRAY);
    imshow("gray image", grayImage);

    //高斯滤波
    Mat gausKernel;
    int kernel_size = 5;
    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);

    Mat temMat;
    Canny(image, temMat, 60, 100);
    imshow("opencv canny image", temMat);

    waitKey(0);
    return 0;
}
阿桑-
关注
  • 13
    点赞
  • 踩
  • 76
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
opencv之Canny()函数
duwangthefirst的博客
04-18 9万+
概述 Canny()函数可以使用canny算法对输入图像进行边缘检测。 API说明 C++ API： void cv::Canny ( InputArray image, （输入图像：8-bit） OutputArray edges, （输出边缘图像：单通道，8-bit，size与输入图像一致） double ...
【OpenCV 4开发详解】Canny算法
小白学视觉
02-07 1482
本文首发于“小白学视觉”微信公众号，欢迎关注公众号 本文作者为小白，版权归人民邮电出版社发行所有，禁止转载，侵权必究！ 经过几个月的努力，小白终于完成了市面上第一本OpenCV 4入门书籍《OpenCV 4开发详解》。为了更让小伙伴更早的了解最新版的OpenCV 4，小白与出版社沟通，提前在公众号上连载部分内容，请持续关注小白。 本节中最后介绍的边缘检测算法是Canny算法，该算法不容易受...
OpenCV实现canny边缘检测（C++实现）.zip
04-12
C++ OpenCV驱动程序，OpenCV beta工程环境。 项目代码可直接编译运行~
基于C++ Canny实现边缘检测【100012619】
06-05
本项目为Canny边缘检测。本项目的实验环境为：操作系统：Ubuntu 18.04 LTS、 IDE：Qt Creator (with CMake)、 第三方库：OpenCV 4.1.1。Canny算法采用先平滑后求导数的方法，先用高斯模板进行平滑处理，以减弱噪声的干扰。 编译器：g++。
使用C++与OpenCV的边缘检测和图像匹配策略
tmocr的博客
02-26 381
滑块验证码通常由两部分组成：一张具有明显缺口的背景图和一张需要被正确放置的滑块图像。自动化地解决滑块验证码挑战的关键在于准确地定位背景图中的缺口。本文采用的方法基于C++和OpenCV，通过边缘检测和图像匹配技术来实现这一目标。
wrf模式数据变量说明
yangwy012210的博客
09-27 1万+
以下是WRF输出变量的一个翻译，由于不是所有的变量都接触过，也仅仅是就字面意思翻译，所以有的变量的意义难免是不对的（拿不准的，我会用红色标出），因此请用过其中变量的朋友和我一起来完善它： float LU_INDEX(Time, south_north, west_east) ; LU_INDEX:description = "LAND USE CATEGORY" ; LU_INDE
Canny边缘检测算法解析
qq_29462849的博客
07-15 9131
前言 最近在做边缘检测方面的一些工作，在网络上也找了很多有用的资料，感谢那些积极分享知识的先辈们，自己在理解Canny边缘检测算法的过程中也走了一些弯路。就此写下此文，作为后记，也希望此篇文章可以帮助那些在理解Canny算法的道路上暂入迷途的童鞋。废话少说，上干货。 Canny边缘检测算法的发展历史 Canny边缘检测于1986年由JOHN CANNY首次在论文《A Computatio...
OpenCV之Canny边缘检测（C++实现）
xddwz的博客
12-23 1万+
canny算子简介 首先看一下最有边缘检测的三个主要评价标准： 低错误率：标出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。 高定位性：标识出的边缘要与图像中的实际边缘尽可能接近。 最小响应：图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。 为了满足这些要求，canny使用的变分法，这是一种寻找满足特定功能的函数的方法。最优检测用4个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。 canny边缘检测的步骤 第一步：消除噪声 一般情况下，使用高斯平滑滤波器降噪，以
OpenCV图像增强（二）——Retinex图像增强
知来者逆的博客
07-18 7520
Retinex图像增强是一种高动态范围图像的新色调映射技术。
如何使用OpenCV进行图像的边缘检测和边缘增强？
gp16674213804的博客
03-07 2251
OpenCV提供了几种常见的边缘检测算法，包括Sobel、Scharr、Laplacian和Canny等。这些算法可以帮助我们找到图像中的边缘并增强它们，以提取有用的特征或分割图像中的对象。
图像处理——基于OpenCV的canny边缘检测
知来者逆的博客
02-25 1057
前言 边缘检测是处理图像里面的比较重要的一个概念，现在的边缘有传统的处理算法，也有加入深度学习的边缘检测算法，这里把我用过的几种边缘检测做个对比。 canny算子 1.OpenCV canny() C++ API void Canny(InputArray image, OutputArray edges, double threshold,double threshold2,int apertu...
C++OpenCV3源代码canny边缘检测
最新发布
04-28
C++OpenCV3编程源代码canny边缘检测提取方式是百度网盘分享地址
Canny边缘检测实现.rar_C++_opencv_opencv 检测 c++_边缘检测
07-14
数字图像课程作业,C++实现Canny边缘检测;注意代码中使用了一阶有限差分计算梯度,而opencv中使用的是Sobel算子,所以此代码检测出来的边缘相对更细一些.使用递归检测连接边缘
基于canny算子的边缘检测源代码opencv c++
04-25
包含canny算子的边缘检测源代码，以及在不同噪声下的响应。 自己编写的canny检测各种参数和步骤，可以与opencv自带的canny算子进行比较
计算机视觉三大顶级会议ICCV,CVPR,ECCV网址
热门推荐
阿桑的专栏
06-25 3万+
CVPR: http://dblp.uni-trier.de/db/conf/cvpr/index.html 还可以找到一些代码： http://www.cvpapers.com/ 这个网站的所有文章都附带有C/C++源代码。 http://www.ipol.im/
图像的几种变换简单介绍
阿桑的专栏
01-15 7419
刚体变换 平移+旋转 保持欧式距离的变换，这意味着图像只进行2D平移和2D旋转运动。它只有3个自由度。 相似变换 平移+旋转+缩放 相比刚体变换增加了均匀的缩放。均匀的意思是各个方向的缩放比例相同。尺度变换增加了一个自由度，所以自由度为4。和刚体一样，具有保角性。点之间的距离不再保持不变，但距离比保持不变。 仿射变换 平移+旋转+缩放+拉伸（像是矩形框被拉伸
图像拼接---图片柱面投影简单实现
阿桑的专栏
11-06 4535
算法思想参考：http://blog.csdn.net/weixinhum/article/details/50611750 柱面投影是图片拼接的前期的一部分工作，以下代码只是简单的实现了投影，还可以优化， 柱面半径设置位图片宽度的一半，即 R = width/2 代码运算流程是 对于dst图片上的每一个像素点，通过公式计算出src上对应的位置(hnum,wnum)，把src上这个位置的像素...
泊松融合
阿桑的专栏
03-30 1694
泊松融合是一种很重要的图像融合算法，该算法选自论文（[Poisson Image Editing]2003年发表），关于算法中的很多基础概念可以参考如下博客： https://blog.csdn.net/hjimce/article/details/45716603 https://blog.csdn.net/zxpddfg/article/details/75825965 还有另一个博客，...
使用C++进行canny边缘检测
11-28
以下是使用C++进行Canny边缘检测的步骤和代码示例： 1.读取图像并转换为灰度图像 ```c++ Mat src = imread("image.jpg"); Mat gray; cvtColor(src, gray, COLOR_BGR2GRAY); ``` 2.对灰度图像进行高斯滤波 ```c++ Mat blur; GaussianBlur(gray, blur, Size(3, 3), 0, 0); ``` 3.使用Canny函数进行边缘检测 ```c++ Mat edges; Canny(blur, edges, 50, 150); ``` 4.显示结果 ```c++ imshow("Edges", edges); waitKey(0); ``` 完整代码示例： ```c++ #include <opencv2/opencv.hpp> using namespace cv; int main() { Mat src = imread("image.jpg"); if (src.empty()) { std::cout << "Failed to read image file." << std::endl; return -1; } Mat gray; cvtColor(src, gray, COLOR_BGR2GRAY); Mat blur; GaussianBlur(gray, blur, Size(3, 3), 0, 0); Mat edges; Canny(blur, edges, 50, 150); imshow("Edges", edges); waitKey(0); return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值