Canny边缘检测算法原理及其VC实现详解(三)

2024-06-15 13:08
文章标签 算法 实现 详解 原理 检测 canny 边缘 vc

本文主要是介绍Canny边缘检测算法原理及其VC实现详解(三)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

转载自：http://blog.csdn.net/likezhaobin/article/details/6892629

3.3 图像增强——计算图像梯度及其方向

      根据上文分析可知，实现代码如下
  1. //同样可以用不同的检测器/  
  2. /    P[i,j]=(S[i,j+1]-S[i,j]+S[i+1,j+1]-S[i+1,j])/2     /  
  3. /    Q[i,j]=(S[i,j]-S[i+1,j]+S[i,j+1]-S[i+1,j+1])/2     /  
  4. /  
  5. double* P = new double[nWidth*nHeight];                 //x向偏导数  
  6. double* Q = new double[nWidth*nHeight];                 //y向偏导数  
  7. int* M = new int[nWidth*nHeight];                       //梯度幅值  
  8. double* Theta = new double[nWidth*nHeight];             //梯度方向  
  9. //计算x,y方向的偏导数  
  10. for(i=0; i<(nHeight-1); i++)  
  11. {  
  12.         for(j=0; j<(nWidth-1); j++)  
  13.         {  
  14.               P[i*nWidth+j] = (double)(pCanny[i*nWidth + min(j+1, nWidth-1)] - pCanny[i*nWidth+j] + pCanny[min(i+1, nHeight-1)*nWidth+min(j+1, nWidth-1)] - pCanny[min(i+1, nHeight-1)*nWidth+j])/2;  
  15.               Q[i*nWidth+j] = (double)(pCanny[i*nWidth+j] - pCanny[min(i+1, nHeight-1)*nWidth+j] + pCanny[i*nWidth+min(j+1, nWidth-1)] - pCanny[min(i+1, nHeight-1)*nWidth+min(j+1, nWidth-1)])/2;  
  16.     }  
  17. }  
  18. //计算梯度幅值和梯度的方向  
  19. for(i=0; i<nHeight; i++)  
  20. {  
  21.         for(j=0; j<nWidth; j++)  
  22.         {  
  23.               M[i*nWidth+j] = (int)(sqrt(P[i*nWidth+j]*P[i*nWidth+j] + Q[i*nWidth+j]*Q[i*nWidth+j])+0.5);  
  24.               Theta[i*nWidth+j] = atan2(Q[i*nWidth+j], P[i*nWidth+j]) * 57.3;  
  25.               if(Theta[i*nWidth+j] < 0)  
  26.                     Theta[i*nWidth+j] += 360;              //将这个角度转换到0~360范围  
  27.     }  
  28. }  


3.4 非极大值抑制

      根据上文所述的工作原理，这部分首先需要求解每个像素点在其邻域内的梯度方向的两个灰度值，然后判断是否为潜在的边缘，如果不是则将该点灰度值设置为0.

      首先定义相关的参数如下：

 

  1. unsigned char* N = new unsigned char[nWidth*nHeight];  //非极大值抑制结果  
  2. int g1=0, g2=0, g3=0, g4=0;                            //用于进行插值，得到亚像素点坐标值  
  3. double dTmp1=0.0, dTmp2=0.0;                           //保存两个亚像素点插值得到的灰度数据  
  4. double dWeight=0.0;                                    //插值的权重  
      其次，对边界进行初始化：

 

  1. for(i=0; i<nWidth; i++)  
  2. {  
  3.         N[i] = 0;  
  4.         N[(nHeight-1)*nWidth+i] = 0;  
  5. }  
  6. for(j=0; j<nHeight; j++)  
  7. {  
  8.         N[j*nWidth] = 0;  
  9.         N[j*nWidth+(nWidth-1)] = 0;  
  10. }  
      进行局部最大值寻找，根据上文图1所述的方案进行插值，然后判优，实现代码如下：
  1. for(i=1; i<(nWidth-1); i++)  
  2. {  
  3.     for(j=1; j<(nHeight-1); j++)  
  4.     {  
  5.         int nPointIdx = i+j*nWidth;       //当前点在图像数组中的索引值  
  6.         if(M[nPointIdx] == 0)  
  7.             N[nPointIdx] = 0;         //如果当前梯度幅值为0，则不是局部最大对该点赋为0  
  8.         else  
  9.         {  
  10.         首先判断属于那种情况，然后根据情况插值///  
  11.         第一种情况///  
  12.         /       g1  g2                  /  
  13.         /           C                   /  
  14.         /           g3  g4              /  
  15.         /  
  16.         if( ((Theta[nPointIdx]>=90)&&(Theta[nPointIdx]<135)) ||   
  17.                 ((Theta[nPointIdx]>=270)&&(Theta[nPointIdx]<315)))  
  18.             {  
  19.                 //根据斜率和四个中间值进行插值求解  
  20.                 g1 = M[nPointIdx-nWidth-1];  
  21.                 g2 = M[nPointIdx-nWidth];  
  22.                 g3 = M[nPointIdx+nWidth];  
  23.                 g4 = M[nPointIdx+nWidth+1];  
  24.                 dWeight = fabs(P[nPointIdx])/fabs(Q[nPointIdx]);   //反正切  
  25.                 dTmp1 = g1*dWeight+g2*(1-dWeight);  
  26.                 dTmp2 = g4*dWeight+g3*(1-dWeight);  
  27.             }  
  28.         第二种情况///  
  29.         /       g1                      /  
  30.         /       g2  C   g3              /  
  31.         /               g4              /  
  32.         /  
  33.             else if( ((Theta[nPointIdx]>=135)&&(Theta[nPointIdx]<180)) ||   
  34.                 ((Theta[nPointIdx]>=315)&&(Theta[nPointIdx]<360)))  
  35.             {  
  36.                 g1 = M[nPointIdx-nWidth-1];  
  37.                 g2 = M[nPointIdx-1];  
  38.                 g3 = M[nPointIdx+1];  
  39.                 g4 = M[nPointIdx+nWidth+1];  
  40.                 dWeight = fabs(Q[nPointIdx])/fabs(P[nPointIdx]);   //正切  
  41.                 dTmp1 = g2*dWeight+g1*(1-dWeight);  
  42.                 dTmp2 = g4*dWeight+g3*(1-dWeight);  
  43.             }  
  44.         第三种情况///  
  45.         /           g1  g2              /  
  46.         /           C                   /  
  47.         /       g4  g3                  /  
  48.         /  
  49.             else if( ((Theta[nPointIdx]>=45)&&(Theta[nPointIdx]<90)) ||   
  50.                 ((Theta[nPointIdx]>=225)&&(Theta[nPointIdx]<270)))  
  51.             {  
  52.                 g1 = M[nPointIdx-nWidth];  
  53.                 g2 = M[nPointIdx-nWidth+1];  
  54.                 g3 = M[nPointIdx+nWidth];  
  55.                 g4 = M[nPointIdx+nWidth-1];  
  56.                 dWeight = fabs(P[nPointIdx])/fabs(Q[nPointIdx]);   //反正切  
  57.                 dTmp1 = g2*dWeight+g1*(1-dWeight);  
  58.                 dTmp2 = g3*dWeight+g4*(1-dWeight);  
  59.             }  
  60.             第四种情况///  
  61.             /               g1              /  
  62.             /       g4  C   g2              /  
  63.             /       g3                      /  
  64.             /  
  65.             else if( ((Theta[nPointIdx]>=0)&&(Theta[nPointIdx]<45)) ||   
  66.                 ((Theta[nPointIdx]>=180)&&(Theta[nPointIdx]<225)))  
  67.             {  
  68.                 g1 = M[nPointIdx-nWidth+1];  
  69.                 g2 = M[nPointIdx+1];  
  70.                 g3 = M[nPointIdx+nWidth-1];  
  71.                 g4 = M[nPointIdx-1];  
  72.                 dWeight = fabs(Q[nPointIdx])/fabs(P[nPointIdx]);   //正切  
  73.                 dTmp1 = g1*dWeight+g2*(1-dWeight);  
  74.                 dTmp2 = g3*dWeight+g4*(1-dWeight);  
  75.             }  
  76.         }         
  77.         //进行局部最大值判断，并写入检测结果  
  78.         if((M[nPointIdx]>=dTmp1) && (M[nPointIdx]>=dTmp2))  
  79.             N[nPointIdx] = 128;  
  80.         else  
  81.             N[nPointIdx] = 0;  
  82.         }  
  83. }  

这篇关于Canny边缘检测算法原理及其VC实现详解(三)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1063539。

相关文章

Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...
深入探索协同过滤：从原理到推荐模块案例

深入探索协同过滤：从原理到推荐模块案例

文章目录 前言一、协同过滤1. 基于用户的协同过滤（UserCF）2. 基于物品的协同过滤（ItemCF）3. 相似度计算方法 二、相似度计算方法1. 欧氏距离2. 皮尔逊相关系数3. 杰卡德相似系数4. 余弦相似度 三、推荐模块案例1.基于文章的协同过滤推荐功能2.基于用户的协同过滤推荐功能 前言     在信息过载的时代，推荐系统成为连接用户与内容的桥梁。本文聚焦于
阅读更多...
csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

这是一道扩展欧几里得算法的简单应用题，这题是在湖南多校训练赛中队友ac的一道题，在比赛之后请教了队友，然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意：把题意转变下就变成了：求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点：求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息，即可快速实现设备配网，是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递，利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力，实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后，即可发送相关配网数据。同时还支持与常规Sof
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2