手写Canny C++

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量789 收藏 5
点赞数 2
分类专栏： 数字图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vegetablemwj/article/details/126128367
版权

c++ 计算机视觉 图像处理

Canny边缘检测原理

1.使用高斯滤波器平滑噪声
2.计算图像中每个像素点的梯度强度和方向
3. 应用非极大值抑制，消除边缘检测带来的杂散响应
4.应用双阈值来确定真实的和潜在的边缘

1. 高斯滤波

高斯滤波器是一种可以使图像平滑的滤波器，用于去除噪声
它是一种线性平滑滤波
流程：对整张图像进行加权平均的过程，每一个像素点，都由其本身和邻域内像素的加权平均值取替代模板中心的像素值。
在这里插入图片描述

高斯滤波的权重服从二维正态分布，越靠近窗口中心点（也即当前滤波点），权重越大。对于(2n+1)*(2n+1)窗口，其权重计算公式如下，其中σ为标准差，σ越大，权重分布越均匀，滤波效果越好，同时图像越模糊，反之，σ越小，权重分布越偏向于窗口中心点，滤波效果越差，同时图像越能保留其原有清晰度。
在这里插入图片描述实际上，为了使加权和之后的值不超过像素值本来的最大范围，需要对上式做一下归一化，使0<w(i,j)<1。如下式
在这里插入图片描述

2.计算梯度强度和方向

计算梯度幅值和方向.可选用soble算子、Prewitt算子、Roberts模板等等.这样就可以得图像在x和y方向梯度.如x和y方向的Sobel算子分别为:
在这里插入图片描述
其中梯度G和方向θ 如下图所示
在这里插入图片描述当然,对梯度幅值也可以采用近似求法:
在这里插入图片描述

3.非极大值抑制

⾮极⼤值抑制是对除去⾮极⼤值以外的值的操作的总称，在这⾥，我们⽐较我们我们所关注的地⽅梯度的法线⽅向邻接的三个像素点的梯度幅值，如果该点的梯度值不⽐其它两个像素⼤，那么这个地⽅的值设置为0。
通俗意义上是指寻找像素点局部最大值.在每一点上,领域中心x与沿着其对应的梯度方向的两个像素相比,若中心像素为最大值,则保留,否则中心置0,这样可以抑制非极大值,保留局部梯度最大的点,以细化边缘.
在这里插入图片描述
如上图所示,需要将中心像素与其梯度方向的两个像素进行比较.但是,由于图像中的像素点是离散的二维矩阵,其梯度方向两侧并没有真实存在的像素,或者说是一个亚像素(sub pixel)点,对于这个不存在的点的位置与梯度就必须通过对其两侧的点进行插值来得到

由于利用插值求解梯度,运算量比较大,在John Canny提出Canny算子的论文中,非极大值抑制时,他采用了近似处理的方法**.将各点的梯度方向近似/量化到0°、90°、45°、135°四个梯度方向上进行**,每个像素点梯度方向按照距离这四个方向的相近程度用这四个方向来代替.通过量化,意味着图像中各点的梯度方向只能沿着0°、90°、45°、135°四个方向中的某一个.
如下图所示为选择的4个量化方向,每个方向对应邻域内的两个点,4个方向正好将邻域内的8个点应用完毕
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如下为非极大值抑制示意图.图中以颜色深浅表示梯度幅值大小.经过NMS后,原边缘被细化.意味着在真实边缘处是单点响应.
在这里插入图片描述

4.应用双阈值来确定真实的和潜在的边缘

在施加非极大值抑制之后,剩余的像素可以更准确地表示图像中的实际边缘.然而,仍然存在由于噪声和颜色变化引起的一些边缘像素.为了解决这些杂散响应,必须用弱梯度值过滤边缘像素,并保留具有高梯度值的边缘像素,可以通过选择高低阈值来实现.
Canny 推荐的 高:低 阈值比在 2:1 到3:1之间
在这里插入图片描述
在这里插入图片描述

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>


// RGB to Gray scale
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);
  
  // BGR -> Gray
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      out.at<uchar>(y, x) = (int)((float)img.at<cv::Vec3b>(y, x)[0] * 0.0722 + \
				  (float)img.at<cv::Vec3b>(y, x)[1] * 0.7152 + \
				  (float)img.at<cv::Vec3b>(y, x)[2] * 0.2126);
    }
  }
  return out;
}

float clip(float value, float min, float max){
  return fmin(fmax(value, 0), 255);
}

// gaussian filter
cv::Mat gaussian_filter(cv::Mat img, double sigma, int kernel_size){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC3);
  if (channel == 1) {
    out = cv::Mat::zeros(height, width, CV_8UC1);
  }

  // prepare kernel
  int pad = floor(kernel_size / 2);
  int _x = 0, _y = 0;
  double kernel_sum = 0;
  
  // get gaussian kernel
  float kernel[kernel_size][kernel_size];

  for (int y = 0; y < kernel_size; y++){
    for (int x = 0; x < kernel_size; x++){
      _y = y - pad;
      _x = x - pad; 
      kernel[y][x] = 1 / (2 * M_PI * sigma * sigma) * exp( - (_x * _x + _y * _y) / (2 * sigma * sigma));
      kernel_sum += kernel[y][x];
    }
  }

  for (int y = 0; y < kernel_size; y++){
    for (int x = 0; x < kernel_size; x++){
      kernel[y][x] /= kernel_sum;
    }
  }

  // filtering
  double v = 0;
  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // for BGR
      if (channel == 3){
        for (int c = 0; c < channel; c++){
          v = 0;
          for (int dy = -pad; dy < pad + 1; dy++){
            for (int dx = -pad; dx < pad + 1; dx++){
              if (((x + dx) >= 0) && ((y + dy) >= 0) && ((x + dx) < width) && ((y + dy) < height)){
                v += (double)img.at<cv::Vec3b>(y + dy, x + dx)[c] * kernel[dy + pad][dx + pad];
              }
            }
          }
          out.at<cv::Vec3b>(y, x)[c] = (uchar)clip(v, 0, 255);
        }
      } else {
        // for Gray
        v = 0;
        for (int dy = -pad; dy < pad + 1; dy++){
          for (int dx = -pad; dx < pad + 1; dx++){
            if (((x + dx) >= 0) && ((y + dy) >= 0) && ((x + dx) < width) && ((y + dy) < height)){
              v += (double)img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
            }
          }
        }
        out.at<uchar>(y, x) = (uchar)clip(v, 0, 255);
      }
    }
  }
  return out;
}

// Sobel filter
cv::Mat sobel_filter(cv::Mat img, int kernel_size, bool horizontal){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  double kernel[kernel_size][kernel_size] = {{1, 2, 1}, {0, 0, 0}, {-1, -2, -1}};

  if (horizontal){
    kernel[0][1] = 0;
    kernel[0][2] = -1;
    kernel[1][0] = 2;
    kernel[1][2] = -2;
    kernel[2][0] = 1;
    kernel[2][1] = 0;
  }

  int pad = floor(kernel_size / 2);

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += (double)img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      out.at<uchar>(y, x) = (uchar)clip(v, 0, 255);
    }
  }
  return out;
}

// get edge
cv::Mat get_edge(cv::Mat fx, cv::Mat fy){
  // get height and width
  int height = fx.rows;
  int width = fx.cols;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  double _fx, _fy;

  for(int y = 0; y < height; y++){
    for(int x = 0; x < width; x++){
      _fx = (double)fx.at<uchar>(y, x);
      _fy = (double)fy.at<uchar>(y, x);

      out.at<uchar>(y, x) = (uchar)clip(sqrt(_fx * _fx + _fy * _fy), 0, 255);
    }
  }

  return out;
}

// get angle
cv::Mat get_angle(cv::Mat fx, cv::Mat fy){
  // get height and width
  int height = fx.rows;
  int width = fx.cols;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  double _fx, _fy;
  double angle;

  for(int y = 0; y < height; y++){
    for(int x = 0; x < width; x++){
      _fx = fmax((double)fx.at<uchar>(y, x), 0.000001);
      _fy = (double)fy.at<uchar>(y, x);

      angle = atan2(_fy, _fx);
      angle = angle / M_PI * 180;

      if(angle < -22.5){
        angle = 180 + angle;
      } else if (angle >= 157.5) {
        angle = angle - 180;
      }

      //std::cout << angle << " " ;

      // quantization
      if (angle <= 22.5){
        out.at<uchar>(y, x) = 0;
      } else if (angle <= 67.5){
        out.at<uchar>(y, x) = 45;
      } else if (angle <= 112.5){
        out.at<uchar>(y, x) = 90;
      } else {
        out.at<uchar>(y, x) = 135;
      }
    }
  }

  return out;
}


// non maximum suppression
cv::Mat non_maximum_suppression(cv::Mat angle, cv::Mat edge){
  int height = angle.rows;
  int width = angle.cols;
  int channel = angle.channels();

  int dx1, dx2, dy1, dy2;
  int now_angle;

  // prepare output
  cv::Mat _edge = cv::Mat::zeros(height, width, CV_8UC1);

  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      now_angle = angle.at<uchar>(y, x);
      // angle condition
      if (now_angle == 0){
        dx1 = -1;
        dy1 = 0;
        dx2 = 1;
        dy2 = 0;
      } else if(now_angle == 45) {
        dx1 = -1;
        dy1 = 1;
        dx2 = 1;
        dy2 = -1;
      } else if(now_angle == 90){
        dx1 = 0;
        dy1 = -1;
        dx2 = 0;
        dy2 = 1;
      } else {
        dx1 = -1;
        dy1 = -1;
        dx2 = 1;
        dy2 = 1;
      }

      if (x == 0){
        dx1 = fmax(dx1, 0);
        dx2 = fmax(dx2, 0);
      }
      if (x == (width - 1)){
        dx1 = fmin(dx1, 0);
        dx2 = fmin(dx2, 0);
      }
      if (y == 0){
        dy1 = fmax(dy1, 0);
        dy2 = fmax(dy2, 0);
      }
      if (y == (height - 1)){
        dy1 = fmin(dy1, 0);
        dy2 = fmin(dy2, 0);
      }

      // if pixel is max among adjuscent pixels, pixel is kept
      if (fmax(fmax(edge.at<uchar>(y, x), edge.at<uchar>(y + dy1, x + dx1)), edge.at<uchar>(y + dy2, x + dx2)) == edge.at<uchar>(y, x)) {
        _edge.at<uchar>(y, x) = edge.at<uchar>(y, x);
      }
    }
  }

  return _edge;
}


// Canny step 2
int Canny_step2(cv::Mat img){
  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // gaussian filter
  cv::Mat gaussian = gaussian_filter(gray, 1.4, 5);

  // sobel filter (vertical)
  cv::Mat fy = sobel_filter(gaussian, 3, false);

  // sobel filter (horizontal)
  cv::Mat fx = sobel_filter(gaussian, 3, true);

  // get edge
  cv::Mat edge = get_edge(fx, fy);

  // get angle
  cv::Mat angle = get_angle(fx, fy);

  // edge non-maximum suppression
  edge = non_maximum_suppression(angle, edge);
  
  //cv::imwrite("out.jpg", out);
  cv::imshow("answer(edge)", edge);
  cv::imshow("answer(angle)", angle);
  cv::waitKey(0);
  cv::destroyAllWindows();

  return 0;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("test.jpg", cv::IMREAD_COLOR);

  // Canny step 2
  Canny_step2(img);

  return 0;
}
三维重建及点云
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用c++实现Canny算子
06-30
主要用C++实现canny算子。没有直接调用opencv的canny算子，自己实现canny算子的函数。
C++实现Canny边缘检测（原理+底层代码）
shinuone的博客
05-27 1896
检测步骤：1、使用高斯滤波器进行平滑处理；2、利用一阶偏导计算x与y方向的梯度幅值和方向；3、对梯度幅值进行NMS非极大值抑制；4、用双阈值算法检测和边缘连接。
图像处理之边缘检测（C++）
qq_45045175的博客
05-17 1441
本文介绍了图像处理中的边缘检测算法，包括了Roberts、Sobel、Prewitt、laplacian、DOG、LOG等算子的C++实现和原理介绍，欢迎大家指出问题和交流讨论。
边缘检测
weixin_33819479的博客
10-01 1928
1. 边缘检测的概念 边缘检测是图像处理与计算机视觉中极为重要的一种分析图像的方法，至少在我做图像分析与识别时，边缘是我最喜欢的图像特征。边缘检测的目的就是找到图像中亮度变化剧烈的像素点构成的集合，表现出来往往是轮廓。如果图像中边缘能够精确的测量和定位，那么，就意味着实际的物体能够被定位和测量，包括物体的面积、物体的直径、物体的形状等就能被测量。在对现实世界的图像采集中，有下面4种情况会表现在图...
canny算法:边界检测算法C++代码
thank3194003824的博客
09-07 1049
一、算法原理 canny边缘检测算法原理 二、程序分块介绍 1、高斯模糊。 float GasArray[9]= {0.0751,0.1238,0.0571,0.1238,0.2043,0.1238,0.0751,0.1238,0.0751};\\高斯模糊算子 两个矩阵的卷积（未采用傅里叶变换） float *Array_Cov_f_f_f(float *input,int input_x,int input_y,float *cov,int cov_x,int cov_y) { if(inp
Canny边缘检测算法（C++实现）
HUSTER_Gy的博客
12-07 7307
步骤 用高斯滤波器平滑图像； 用一阶偏导有限差分计算梯度幅值和方向； 对梯度幅值应用非极大值抑制； 用双阈值算法检测和连接边缘。 一、openCV在C++中的应用 首先，在mac的Xcode上安装配置openCV库，参考一下链接（科学上网访问）https://medium.com/@jaskaranvirdi/setting-up-opencv-and-c-developme...
C++编程实现的手写数字识别
05-07
总的来说，C++实现手写数字识别是一个涉及多领域知识的综合项目，需要理解和运用图像处理、机器学习以及编程技巧。通过这个项目，不仅可以提升编程技能，还能深入理解图像识别背后的原理和技术。在实践中，你将不断...
模拟手写字源代码 C++
04-20
在本文中，我们将深入探讨如何使用C++编程语言来实现模拟手写字源代码。这个项目主要涉及到了图像处理、手写字模拟以及GDI+库的使用。GDI+（Graphics Device Interface Plus）是Windows应用程序中用于图形绘制的一种...
手写数字识别
03-01
常见的方法有边缘检测（如Sobel或Canny算子）、轮廓追踪、连通成分分析等。这些特征可能包括线条、拐点、封闭区域等。对于特定的应用，还可以使用结构元素进行形态学操作，例如膨胀和腐蚀，以改善数字的形状。 然后...
基于Opencv实现简易的手写汉字识别.zip
11-23
OpenCV提供了多种边缘检测算法，如Canny、Sobel、Laplacian等。在本项目中，可能会用到这些方法来找到汉字的边界。轮廓提取能帮助我们确定每个汉字的形状，为后续的特征提取和识别打下基础。 3. **特征提取**： ...
手写字符识别
10-24
常用的方法有边缘检测（如Canny算法）、轮廓提取和结构元素分析。 3. **模板库建立**：预先创建一个包含所有可能数字（0-9）的标准模板库。每个模板代表一个清晰的手写数字，这些模板经过同样的预处理步骤，以确保...
Canny的C++实现
liugan528的博客
02-08 3286
好的图像边缘检测应该满足 尽可能的标记处所有的边缘； 标记出的边缘就是实际图像内容的边缘； 图像中的边缘只标记一次。 Canny边缘检测的步骤 图像灰度化； 高斯滤波（不限制）降噪； 使用简单的算子（如Sobel、Prewitt等）检测图像水平grad_xgrad\_xgrad_x、垂直梯度grad_ygrad\_ygrad_y，并求出梯度grad_x2+grad_y2\sqrt{grad\_x^2 + grad\_y^2}grad_x2+grad_y2​和梯度方向（角度）grad_y/grad_xg
Canny边缘检测及利用C++实现
Ring__Rain的博客
05-16 1080
Canny算子边缘检测的具体步骤如下： 一、用高斯滤波器平滑图像 二、用Sobel等梯度算子计算梯度幅值和方向 三、对梯度幅值进行非极大值抑制 四、用双阈值算法检测和连接边缘 一、用高斯滤波器平滑图像 高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，特别是对抑制或消除服从正态分布的噪声非常有效。滤波可以消除或降低图像中噪声的影响，使用高斯滤波器主要是基于在滤波降噪的同时也可以最大限度保...
基于C++的Canny边缘检测（数字图像处理）
毕业作品网站
05-09 1562
数字图像处理—Canny边缘检测 一、实验环境 操作系统：Ubuntu 18.04 LTS IDE：Qt Creator (with CMake) 第三方库：OpenCV 4.1.1 编译器：g++ 二、实验目的 通过课堂的学习，已经对图像分割的相关理论知识已经有了全面的了解，知道了许多图像分割的算法及算子，了解到不同的算子算法有着不同的优缺点，为了更好更直观地对图像分割进行深入理解，达到理论联系实际的目的，现实现Canny算子 三、实验原理 Canny算法采用先平滑后求导数的方法，先用高斯模板进行平
【C++】【Opencv】cv::Canny()边缘检测函数详解和示例
不定时分享，互相学习，共同进步
11-19 4992
Canny边缘检测是一种流行的边缘检测算法，由John F. Canny在1986年开发。它是一种多阶段过程，包括噪声滤波、计算图像强度的梯度、非最大值抑制以及双阈值检测。本文通过函数原型解读和示例对cv::Canny()函数进行详解，以帮助大家理解和使用。
基于C++的OpenCV4入门基础--边缘检测之 Canny 算子
jiangchaobing_2017的博客
10-20 151
基于C++的OpenCV4的Canny用法说明
图像处理之Canny边缘检测（C++）
qq_45045175的博客
04-18 1161
本文主要介绍了手动实现的Canny边缘检测和OpenCV实现的Canny边缘调用并且对比，欢迎大家阅读。
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 137
C语言 | Leetcode C语言题解之第337题打家劫舍III
canny c++ 实现
05-28
Canny算法是一种边缘检测算法，可以在图像上找到边缘。以下是C++实现的基本步骤： 1. 对图像进行灰度化处理。 2. 对灰度图像进行高斯滤波，以去除噪声。 3. 计算图像中每个像素的梯度幅值和方向。 4. 对梯度方向...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值