opencv c++ canny 实现 以及与halcon canny的对比

Opencv和C++实现canny边缘检测_opencv边缘增强-CSDN博客

一、canny实现步骤

1、图像必须是单通道的，也就是说必须是灰度图像

2、图像进行高斯滤波，去掉噪点 

3、sobel 算子过程的实现，计算x y方向 、梯度（用不到，但是可以看看xy 两个组合起来的结果）

以及梯度方向（很重要）

4、局部非极大值抑制

5、双阈值连接处理

具体可以分为上面的5个步骤，下面一起边看原理边实现。

二、原理与实现

1、图像灰度化

如果是一张3通道的图像，也就是我们常见的彩色图，那么们就需要将其转换成一个灰度图，其规则如下：

             1.浮点算法：Gray = R*0.3 + G*0.59 + B*0.11
　　  2.整数方法：Gray = (R*30+G*59+B*11)/100
　　  3.移位方法：Gray = (R*28+G*151+B*77）>> 8
　　  4.平均值法：Gray = (R+G+B)/3
　　  5.仅取绿色：Gray = G
但是通常我们自己实现一般都是拿第一种实现的。

OpenCV转灰度图像特别简单，只需调用函数 cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 即可。

code：

void ConvertRGB2GRAY(const Mat& image, Mat& imageGray)
{if (!image.data || image.channels() != 3){return;}// 创建一个单通道的灰度图像imageGray = Mat::zeros(image.size(), CV_8UC1);//  取出存储图像的数组的指针 uchar* pointImage = image.data;uchar* pointImageGray = imageGray.data;int stepImage = image.step;int stepImageGray = imageGray.step;for (int i = 0; i < imageGray.rows; i++){for (int j = 0; j < imageGray.cols; j++){pointImageGray[i * stepImageGray + j] = 0.114 * pointImage[i * stepImage + 3 * j] + 0.587 * pointImage[i * stepImage + 3 * j + 1] + 0.299 * pointImage[i * stepImage + 3 * j + 2];}}
}

2、高斯滤波

在高斯滤波的时候先要生成一个2元高斯核，然后进行高斯滤波，其作用是去掉噪点，其图像变的平滑起来

二元高斯函数

  随着sigma的增大，整个高斯函数的尖峰逐渐减小，整体也变的更加平缓，则对图像的平滑效果越来越明显。

高斯核

代码里面最后一定要归一化


void  CreateGaussianKernel(int  kernel_size, int sigma, Mat& kernel)
{const   double  PI = 3.1415926;int  center = kernel_size / 2;kernel = Mat(kernel_size, kernel_size,CV_32FC1);float  segma_pow = 2 * sigma * sigma;   float  sum = 0;//  二元高斯函数for (size_t i = 0; i < kernel_size; i++){for (size_t j= 0; j < kernel_size; j++){float  temp = ((i - center) * (i - center) + (j - center) * (j - center) )/ segma_pow;kernel.at<float>(i, j) = 1 / (PI * segma_pow) * exp(-temp);sum += kernel.at<float>(i, j);}}// 归一化for (size_t i = 0; i < kernel_size; i++){for (size_t j = 0; j < kernel_size; j++){kernel.at<float>(i, j) = kernel.at<float>(i, j)/sum;}}}

5*5 的高斯核，那个核数一般是不能超过11 ，超过11 其效果均值一样了

高斯滤波


//******************高斯滤波*************************
//第一个参数imageSource是待滤波原始图像；
//第二个参数imageGaussian是滤波后输出图像；
//第三个参数 kernel 是一个指向含有N个double类型数组；
//第四个参数size是滤波核的尺寸
//*************************************************************
void  GaussianFilter(const Mat& imageSource, Mat& imageGaussian, Mat& kernel, int size)
{if (!imageSource.data|| imageSource.channels()!=1){return;}imageGaussian = Mat::zeros(imageSource.size(),CV_8UC1);float  gaussArray[100];// 将 kernel 的方阵 变成一个一维度数组 这样在循环的时候啊就少了一次内循环int m = 0;for (size_t i = 0; i < kernel.rows; i++){for (size_t j = 0; j < kernel.cols; j++){gaussArray[m] = kernel.at<float>(i,j);m++;}}//滤波for (int i = 0; i < imageSource.rows; i++){for (int j = 0; j < imageSource.cols; j++){int k = 0;for (int l = -size / 2; l <= size / 2; l++){for (int g = -size / 2; g <= size / 2; g++){//以下处理针对滤波后图像边界处理，为超出边界的值赋值为边界值int row = i + l;int col = j + g;row = row < 0 ? 0 : row;row = row >= imageSource.rows ? imageSource.rows - 1 : row;col = col < 0 ? 0 : col;col = col >= imageSource.cols ? imageSource.cols - 1 : col;//卷积和imageGaussian.at<uchar>(i, j) += gaussArray[k] * imageSource.at<uchar>(row, col);k++;}}}}}void  TestGaussian()
{Mat  kernel;CreateGaussianKernel(5, 1, kernel);// 打印 高斯核for (int i = 0; i < kernel.rows; i++){for (int j = 0; j < kernel.cols; j++){cout << "    " << kernel.at<float>(i, j);}cout << endl;}Mat  src = imread("C:\\Users\\alber\\Desktop\\opencv_images\\529.jpg");Mat  dst, imageGaussian;ConvertRGB2GRAY(src, dst);imwrite("C:\\Users\\alber\\Desktop\\opencv_images\\1\\1.jpg", dst);GaussianFilter(dst, imageGaussian, kernel, 5);imwrite("C:\\Users\\alber\\Desktop\\GaussianFilter.jpg", imageGaussian);
}

 

3、实现sobel 算子

推导出X Y方向的核 

【精选】Opencv 笔记5 边缘处理-canny、sobel、Laplacian、Prewitt_opencv 边缘处理_Σίσυφος1900的博客-CSDN博客

gradient =||dx||+||dy||

theta= atan(gradY / gradX) * 57.3  注意这里的角度转换


//******************Sobel算子计算X、Y方向梯度 以及  梯度方向角********************
//第一个参数imageSourc原始灰度图像；
//第二个参数imageSobelX是X方向梯度图像；
//第三个参数imageSobelY是Y方向梯度图像；
//第四个参数   theta  是梯度方向角数组指针  下一步很重要 就是要用这个值来计算
//*************************************************************
void  SobelGradDirction(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);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);
}

 

 这个不明显，所以我打算换个图像test

4、局部非极大值抑制

这里我们就要用到上面一步在sobel里面计算求得的x y 方向以及梯度方向的那些 东西了。

原理：

拿到当前点的梯度方向[0,360]，判断其在那个区域,计算梯度方向（一个方向，两个值）在不同权重下（w=dy/dx）的灰度值t1 t2， 最后判断当前点灰度值current 和t1 t2的大小比较，如果当前值current小于t1 t2中的任何一个那么，当前的点就不会是边缘的候选点，current=0；

下面我们看一下梯度的分布：

[0-45] U[180-225]

 [45-90] U[225-270]

 [90-135] U[270-315]

 [135-180] U[315-360]

code:

/// <summary>
///  局部极大值抑制 ，计算八领域  沿着该点梯度方向，比较前后两个点的幅值大小，若该点大于前后两点，则保留，若该点小于前后两点任意一点，则置为0；
/// </summary>
/// <param name="imageInput"> 输入的图像</param>
/// <param name="imageOutput"></param>
/// <param name="theta"></param>
/// <param name="imageX"> </param>
/// <param name="imageY"></param>
void NonLocalMaxValue(const Mat imageInput, Mat& imageOutput, const Mat& theta, const Mat& imageX, const Mat& imageY)
{if (!imageInput.data || imageInput.channels() != 1){return;}imageOutput = imageInput.clone();int  rows = imageOutput.rows;int  cols = imageOutput.cols;int  g00, g01, g02, g10, g11, g12, g20, g21, g22;int  g1, g2, g3, g4;for (size_t i = 1; i < rows-1; i++){for (size_t j = 1; j < cols-1; j++){// 第一行g00 = imageOutput.at<uchar>(i - 1, j - 1);g01 = imageOutput.at<uchar>(i - 1, j);g02 = imageOutput.at<uchar>(i - 1, j+1);// 第二行g10 = imageOutput.at<uchar>(i , j - 1);g11 = imageOutput.at<uchar>(i , j);g12 = imageOutput.at<uchar>(i, j + 1);// 第三行g20 = imageOutput.at<uchar>(i+1, j - 1);g21 = imageOutput.at<uchar>(i+1, j);g22 = imageOutput.at<uchar>(i+1, j + 1);// 当前点的梯度方向 int  direction = theta.at<int>(i, j);g1 = 0; g2 = 0;g3 = 0;g4 = 0;// 保存亚像素点插值得到的灰度值 double  t1 = 0;double  t2 = 0;// 计算权重 double  w = fabs((double)imageY.at<uchar>(i,j)  / (double)imageX.at<uchar>(i, j));if (w==0){w = 0.0000001;}if (w>1){w = 1 / w;}//  g00     g01   g02//  g10     g11   g12//  g20     g21   g22// ================================if ((0 <= direction && direction < 45) || 180 <= direction && direction < 225){t1 = g10 * (1 - w) + g20 * (w);t2 = g02 * (w)+g12 * (1 - w);}if ((45 <= direction && direction < 90) || 225 <= direction && direction < 270){t1  = g01 * (1 - w) + g02 * (w);t2  = g20 * (w)+g21 * (1 - w);}if ((90 <= direction && direction < 135) || 270 <= direction && direction < 315){t1  = g00 * (w)+g01 * (1 - w);t2  = g21 * (1 - w) + g22 * (w);}if ((135 <= direction && direction < 180) || 315 <= direction && direction < 360){t1  = g00 * (w)+g10 * (1 - w);t2  = g12 * (1 - w) + g22 * (w);}if (imageInput.at<uchar>(i,j)<t1 || imageInput.at<uchar>(i, j) < t2){imageOutput.at<uchar>(i, j) = 0;}}}}

5、 双阈值连接处理

双阈值处理

给定一个高阈值high   一个低阈值low, low*[1.5,2]=high 这个是给定规则

判断条件就是

                      当前current<low  ，那么current=0

                       low<current<hight  current 不处理 

                       current>hight   current=255

/// <summary>
///     双阈值原理：   
///   制定一个低阈值 L  一个 高阈值 H，一般取H为整体图像灰度分布的 7成 并且H为1.5-2L
///  灰度值<L   gray=0, gray>H gray=255;
/// </summary>
/// <param name="imageIn"></param>
/// <param name="low"></param>
/// <param name="hight"></param>
void DoubleThreshold(Mat& imageIn, const double low, const double hight)
{if (!imageIn.data || imageIn.channels() != 1){return;}int  rows = imageIn.rows;int  cols = imageIn.cols;double  gray;for (size_t i = 0; i < rows ; i++){for (size_t j = 0; j < cols ; j++){gray = imageIn.at<uchar>(i, j);gray = gray > hight ? (255) : (gray < low) ? (0) : gray;imageIn.at<uchar>(i, j) = gray;}}
}

 

 将边缘链接起来

经过上每一步的双阈值处理，我们基本上已经拿到了边缘点的候选点，下一步就是将这些边缘点联合起来，组成一个边缘轮廓

这里我们再次使用双阈值的机制  low  和 hight   和当前点的灰度值current 

规则如下： current  的8邻域的灰度值 M介于【low，hight】中，有，可能是边缘点，这个领域的点M=255 ，并且回退 ， 如果领域类没有 说明这个点是一个孤立的点 不做处理，

最后判断图像中所有的点，不是255 就是0 ，生成边缘

void DoubleThresholdLink(Mat& imageInput, double lowTh, double highTh)
{if (!imageInput.data || imageInput.channels() != 1){return;}int  rows = imageInput.rows;int  cols = imageInput.cols;double  gray;for (size_t i = 1; i < rows-1; i++){for (size_t j = 1; j < cols-1; j++){gray = imageInput.at<uchar>(i, j);if (gray==255){continue;}bool reback = false;// 寻找8领域中是否有介于low 和hight 的值 for (size_t k = -1; k < 2; k++){for (size_t  l= -1; l < 2; l++){if (k == 0 && l == 0)  //当前点 {continue;}double t = imageInput.at<uchar>(i + k, j + l);if (t>= lowTh&& t<highTh){imageInput.at<uchar>(i + k, j + l) = 255;reback = true;}}}// 回退 if (reback){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;}}}}

opencv 库结果：

还是用opencv库吧，结果比这个好多了 

三、halcon 效果对比

halcon的效果更好

code

read_image (Grayimage, 'C:/Users/alber/Desktop/opencv_images/1/grayImage.jpg')
edges_sub_pix (Grayimage, Edges, 'canny', 1, 20, 40)


 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/156152.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【机器学习】四、计算学习理论

【机器学习】四、计算学习理论

1 基础知识 计算学习理论&#xff08;computational learning theory&#xff09;&#xff1a;关于通过“计算”来进行“学习”的理论&#xff0c;即关于机器学习的理论基础&#xff0c;其目的是分析学习任务的困难本质&#xff0c;为学习算法体统理论保证&#xff0c;并根据结…
阅读更多...
如何远程访问具有多个显示器的计算机

如何远程访问具有多个显示器的计算机

留出扩展空间对身体和电脑屏幕都有好处。许多人受益于使用多台显示器或将笔记本电脑连接到外接显示器以扩展屏幕。对于使用屏幕的人来说&#xff0c;拥有这样的屏幕空间可能意味着更高效的工作流程和生产力。 但是&#xff0c;如果你需要远程访问那台计算机呢&#xff1f;是否…
阅读更多...
C++——类和对象之拷贝构造

C++——类和对象之拷贝构造

拷贝构造 本章思维导图&#xff1a; 注&#xff1a;本章思维导图对应的xmind文件和.png文件都已同步上传到”资源“ 如果我们想要用一个已经存在的对象实例化一个与之完全相同的对象&#xff0c;怎么做呢&#xff1f; C提供了一个简单的方法——拷贝构造 拷贝构造是C类里面默…
阅读更多...
Vue解决img路径报错

Vue解决img路径报错

问题&#xff1a; 我们有一组图片的地址&#xff0c;使用v-for遍历img标签&#xff0c;设置src属性&#xff0c;却无法获取图片 解决方法&#xff1a; 因为我们将图片路径放入data中后会被webpack进行打包&#xff0c;这时候的路径仅仅只是一个字符串&#xff0c;无法进行解析…
阅读更多...
使用vue3+vite+elctron构建小项目介绍Electron进程间通信

使用vue3+vite+elctron构建小项目介绍Electron进程间通信

进程间通信 (IPC) 是在 Electron 中构建功能丰富的桌面应用程序的关键部分之一。 由于主进程和渲染器进程在 Electron 的进程模型具有不同的职责&#xff0c;因此 IPC 是执行许多常见任务的唯一方法&#xff0c;例如从 UI 调用原生 API 或从原生菜单触发 Web 内容的更改。 在 …
阅读更多...
innovus: set_ccopt_property的基本用法

innovus: set_ccopt_property的基本用法

我正在「拾陆楼」和朋友们讨论有趣的话题&#xff0c;你⼀起来吧&#xff1f; 拾陆楼知识星球入口 clock route clock route的net type分为三种&#xff0c;分别是root、trunk和leaf&#xff0c;其中root是指fanout超过routing_top_fanout_count约束的net&#xff0c;leaf是指…
阅读更多...
ByteBuffer的原理和使用详解

ByteBuffer的原理和使用详解

ByteBuffer是字节缓冲区&#xff0c;主要用户读取和缓存字节数据&#xff0c;多用于网络编程&#xff0c;原生的类&#xff0c;存在不好用&#xff0c;Netty采用自己的ByteBuff&#xff0c;对其进行了改进 1.ByteBuffer的2种创建方式 1.ByteBuffer buf ByteBuffer.allocate(i…
阅读更多...
竞赛 深度学习手势识别 - yolo python opencv cnn 机器视觉

竞赛 深度学习手势识别 - yolo python opencv cnn 机器视觉

文章目录 0 前言1 课题背景2 卷积神经网络2.1卷积层2.2 池化层2.3 激活函数2.4 全连接层2.5 使用tensorflow中keras模块实现卷积神经网络 3 YOLOV53.1 网络架构图3.2 输入端3.3 基准网络3.4 Neck网络3.5 Head输出层 4 数据集准备4.1 数据标注简介4.2 数据保存 5 模型训练5.1 修…
阅读更多...
206.反转链表

206.反转链表

206.反转链表 力扣题目链接(opens new window) 题意&#xff1a;反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 双双指针法&#xff1a; 创建三个节点 pre(反转时的第一个节点)、cur(当前指向需要反转的节点…
阅读更多...
GB28181协议如何注册

GB28181协议如何注册

前言 GB28181协议是视频监控领域的国家标准&#xff0c;本文将解析如何在FFmpeg中增加对GB28181协议的支持&#xff0c;使其可以与支持GB28181协议的设备进行通信与控制&#xff0c;实现设备的注册、保活以及流媒体的传输。 1.背景介绍 GB28181协议指的是国家标准GB/T 28181…
阅读更多...
一文带你了解自动化测试是什么？

一文带你了解自动化测试是什么？

本章主要讲解自动化测试的含义、分类、项目使用&#xff0c;以及自动化测试工具的优势。 一、自动化测试概述 1、什么是自动化测试&#xff1f; 自动化测试是软件测试活动中的一个重要分支和组成部分。随着软件产业的不断发展&#xff0c;市场对软件周期的要求越来越高&…
阅读更多...
Java日志组件介绍之二

Java日志组件介绍之二

一、前言 Java日志组件介绍之一 主要介绍了JDK内置日志和Apache的common-logging通用日志接口&#xff0c;今天这篇我们继续了解Java其它一些日志组件。 二、slf4j slf4j即Simple Logging Facade for JAVA &#xff0c;简单日志门面&#xff0c;类似common-logging&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023