Canny边缘检测算法（C++实现）

最新推荐文章于 2024-05-17 18:43:47 发布
最新推荐文章于 2024-05-17 18:43:47 发布
阅读量7.2k 收藏 133
点赞数 18
分类专栏： 数字图像处理 文章标签： canny算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HUSTER_Gy/article/details/102942452
版权

步骤

  1. 用高斯滤波器平滑图像；
  2. 用一阶偏导有限差分计算梯度幅值和方向；
  3. 对梯度幅值应用非极大值抑制；
  4. 用双阈值算法检测和连接边缘。

 

一、openCV在C++中的应用

首先，在mac的Xcode上安装配置openCV库，参考一下链接（科学上网访问）https://medium.com/@jaskaranvirdi/setting-up-opencv-and-c-development-environment-in-xcode-b6027728003

using namespace cv; // 使用命名空间cv

如此可以减少输入，例如 cv :: Mat 就可省略为 Mat

Mat

Mat的优点是不再需要手动分配其内存，并在不需要它时立即发布它。在执行此操作仍然是可能的情况下，大多数OpenCV功能将自动分配其输出数据。

Mat作为一个类，包含

  • 矩阵头（包含矩阵的大小，用于存储的方法，存储在哪个地址的信息等等）
  • 指向包含像素值（取决于所选存储方法的任何维度）

从文件中加载图像：

Mat img = imread(filename);

如果需要加载灰度图：

Mat img = imread(filename, IMREAD_GRAYSCALE);

显示图像：

namedWindow("图片"); //打开名为“图片”的窗口
imshow("图片", img); //显示图像

 openCV加载图像显示

using namespace cv; // 使用命名空间cv

int main()
{
    Mat img = imread("building.jpg", IMREAD_GRAYSCALE); //从文件中加载灰度图像
    //显示图像
    namedWindow("原图");
    imshow("原图", img);

    waitKey(); //等待键值输入
    return 0;
}

如何访问图像每一个像素点

利用指针访问，调用 Mat::ptr(i) 来获取第i行的首地址，通过循环进行访问。

// 按行遍历所有点(单通道)
for (int j = 0; j < nr; j++) {
    for (int i = 0; i < nc; i++) {
        //每个点为 img.ptr<uchar>(j)[i]
    }
}

 

二、用高斯滤波器平滑图像

高斯滤波器（openCV）

openCV自带的高斯滤波器：cv :: GaussianBlur

void cv::GaussianBlur (InputArray src, 
  OutputArray dst, 
  Size ksize, 
  double sigmaX, 
  double sigmaY = 0, 
  int borderType = BORDER_DEFAULT 
 )

#include <opencv2/imgproc.hpp>

使用高斯滤镜模糊图像。

该函数将源图像与指定的高斯内核进行卷积。支持就地过滤。

参量

src输入图像；图像可以具有任意数量的通道，这些通道可以独立处理，但深度应为CV_8U，CV_16U，CV_16S，CV_32F或CV_64F。
dst输出与src大小和类型相同的图像。
size高斯核大小。ksize.width和ksize.height可以不同，但​​它们都必须为正数和奇数。或者，它们可以为零，然后根据sigma计算得出。
sigmaXX方向上的高斯核标准偏差。
sigmaYY方向的高斯核标准差；如果sigmaY为零，则将其设置为等于sigmaX；如果两个sigmas为零，则分别从ksize.width和ksize.height计算得出（有关详细信息，请参见getGaussianKernel）；为了完全控制结果，而不管将来可能对所有这些语义进行的修改，建议指定所有ksize，sigmaX和sigmaY。
borderType像素外推方法，请参见BorderTypes

高斯滤波器的C++实现

  1. 对图像使用一维高斯卷积模版，在一个方向上进行滤波（例如水平方向）；
  2. 转置图像；
  3. 对转置后的图像使用同一个高斯卷积模版，在同样的方向上进行滤波；
  4. 将图像转置回原来的位置，得到二维高斯滤波的图像。

一维高斯卷积模版可以由二项式展开的系数来模拟，如3*3模版:     1/4 * [1  2  1]

/**
 高斯滤波器，利用3*3的高斯模版进行高斯卷积
 img 输入原图像
 dst  高斯滤波后的输出图像
*/
void gaussianFilter(Mat &img, Mat &dst) {
    // 对水平方向进行滤波
    Mat dst1 = img.clone();
    gaussianConvolution(img, dst1);
    //图像矩阵转置
    Mat dst2;
    transpose(dst1, dst2);
    // 对垂直方向进行滤波
    Mat dst3 = dst2.clone();
    gaussianConvolution(dst2, dst3);
    // 再次转置
    transpose(dst3, dst);
}
/**
 一维高斯卷积，对每行进行高斯卷积
 img 输入原图像
 dst  一维高斯卷积后的输出图像
 */
void gaussianConvolution(Mat &img, Mat &dst) {
    int nr = img.rows;
    int nc = img.cols;
    int templates[3] = {1, 2, 1};
    
    // 按行遍历除每行边缘点的所有点
    for (int j = 0; j < nr; j++) {
        uchar* data= img.ptr<uchar>(j); //提取该行地址
        for (int i = 1; i < nc-1; i++) {
            int sum = 0;
            for (int n = 0; n < 3; n++) {
                sum += data[i-1+n] * templates[n]; //相称累加
            }
            sum /= 4;
            dst.ptr<uchar>(j)[i] = sum;
        }
    }
}

高斯滤波前后的图像：

高斯滤波

 

 三、用一阶偏导有限差分计算梯度幅值和方向

用一阶偏导有限差分计算偏导数的两个阵列P与Q

P\left [ y,x \right ] \approx \left ( S\left [ y,x+1 \right ]-S\left [ y,x \right ] +S\left [ y+1,x+1 \right ]-S[y+1,x]\right )/2

Q\left [ y,x \right ] \approx \left ( S\left [ y+1,x \right ]-S\left [ y,x \right ] +S\left [ y+1,x+1 \right ]-S[y,x+1]\right )/2

再由P和Q算出梯度幅值和方向角

M\left [ y,x \right ]= \sqrt{P\left [ y,x \right ]^{2}+Q\left [ y,x \right ]^{2}}

\theta \left [ y,x \right ]=\arctan \left ( Q\left [ y,x \right ] /P\left [ y,x \right ]\right )

/**
 用一阶偏导有限差分计算梯度幅值和方向
 img 输入原图像
 gradXY 输出的梯度幅值
 theta 输出的梯度方向
 */
void getGrandient (Mat &img, Mat &gradXY, Mat &theta) {
    gradXY = Mat::zeros(img.size(), CV_8U);
    theta = Mat::zeros(img.size(), CV_8U);
    
    for (int i = 0; i < img.rows-1; i++) {
        for (int j = 0; j < img.cols-1; j++) {
            double p = (img.ptr<uchar>(j)[i+1] - img.ptr<uchar>(j)[i] + img.ptr<uchar>(j+1)[i+1] - img.ptr<uchar>(j+1)[i])/2;
            double q = (img.ptr<uchar>(j+1)[i] - img.ptr<uchar>(j)[i] + img.ptr<uchar>(j+1)[i+1] - img.ptr<uchar>(j)[i+1])/2;
            gradXY.ptr<uchar>(j)[i] = sqrt(p*p + q*q); //计算梯度
            theta.ptr<uchar>(j)[i] = atan(q/p);
        }
    }
}

此时输入输出图像为：

二维梯度算法

 可以看出，二维计算梯度只区分出了部分边界，边界损失过大，于是采用三维算法计算梯度((y,x)为a11)。

a00a01a02
a10a11a12
a20a21a22
double gradX = double(a02 + 2 * a12 + a22 - a00 - 2 * a10 - a20);
double gradY = double(a00 + 2 * a01 + a02 - a20 - 2 * a21 - a22);
/**
 用一阶偏导有限差分计算梯度幅值和方向
 img 输入原图像
 gradXY 输出的梯度幅值
 theta 输出的梯度方向
 */
void getGrandient (Mat &img, Mat &gradXY, Mat &theta) {
    gradXY = Mat::zeros(img.size(), CV_8U);
    theta = Mat::zeros(img.size(), CV_8U);
    
    for (int j = 1; j < img.rows-1; j++) {
        for (int i = 1; i < img.cols-1; i++) {
            double gradY = double(img.ptr<uchar>(j-1)[i-1] + 2 * img.ptr<uchar>(j-1)[i] + img.ptr<uchar>(j-1)[i+1] - img.ptr<uchar>(j+1)[i-1] - 2 * img.ptr<uchar>(j+1)[i] - img.ptr<uchar>(j+1)[i+1]);
            double gradX = double(img.ptr<uchar>(j-1)[i+1] + 2 * img.ptr<uchar>(j)[i+1] + img.ptr<uchar>(j+1)[i+1] - img.ptr<uchar>(j-1)[i-1] - 2 * img.ptr<uchar>(j)[i-1] - img.ptr<uchar>(j+1)[i-1]);

            gradXY.ptr<uchar>(j)[i] = sqrt(gradX*gradX + gradY*gradY); //计算梯度
            theta.ptr<uchar>(j)[i] = atan(gradY/gradX); //计算梯度方向
        }
    }
}

三维梯度算法的输入输出图像：

三维梯度算法

 

四、对梯度幅值应用非极大值抑制

仅仅得到全局梯度并不足以确定边缘，保留局部梯度最大的点，而抑制非极大点。

  1. 将梯度角的变化范围减小到圆周的四个扇区之一；
  2. 四个扇区的标号为0到3，对应3*3领域的四种可能组合方向；
  3. 每一个点上领域的中心像素M与沿着梯度线的两个像素比较；
  4. 如果M梯度值不比沿梯度线的两个相邻像素梯度值大，则令M=0。    

      由 atan() 得到的角度在 \left [ -\pi /2, \pi /2\right ] 范围内，将此范围均分为四个等份。

 

                                                           

/**
 局部非极大值抑制
 gradXY 输入的梯度幅值
 theta 输入的梯度方向
 dst 输出的经局部非极大值抑制后的图像
 */
void nonLocalMaxValue (Mat &gradXY, Mat &theta, Mat &dst) {
    dst = gradXY.clone();
    for (int j = 1; j < gradXY.rows-1; j++) {
        for (int i = 1; i < gradXY.cols-1; i++) {
            double t = double(theta.ptr<uchar>(j)[i]);
            double g = double(dst.ptr<uchar>(j)[i]);
            if (g == 0.0) {
                continue;
            }
            double g0, g1;
            if ((t >= -(3*M_PI/8)) && (t < -(M_PI/8))) {
                g0 = double(dst.ptr<uchar>(j-1)[i-1]);
                g1 = double(dst.ptr<uchar>(j+1)[i+1]);
            }
            else if ((t >= -(M_PI/8)) && (t < M_PI/8)) {
                g0 = double(dst.ptr<uchar>(j)[i-1]);
                g1 = double(dst.ptr<uchar>(j)[i+1]);
            }
            else if ((t >= M_PI/8) && (t < 3*M_PI/8)) {
                g0 = double(dst.ptr<uchar>(j-1)[i+1]);
                g1 = double(dst.ptr<uchar>(j+1)[i-1]);
            }
            else {
                g0 = double(dst.ptr<uchar>(j-1)[i]);
                g1 = double(dst.ptr<uchar>(j+1)[i]);
            }
            
            if (g <= g0 || g <= g1) {
                dst.ptr<uchar>(j)[i] = 0.0;
            }
        }
    }
}

输入的经梯度计算后的图像和输出的局部非极大值抑制后的图像：

局部非极大值抑制

五、用双阈值算法检测和连接边缘

1、Canny算法采用双阈值，高阈值一般是低阈值的两倍，遍历所有像素点：

X < 低阈值 ，像素点置0，被抑制掉；

低阈值 < X <高阈值，像素点为弱边缘点，像素点值先不变；

X > 高阈值，像素点为强边缘点，置255。

2、弱边缘点补充连接强边缘点：

如果弱边缘点的8邻点域存在强边缘点，则将此点置255，用以连接强边缘点；如果不存在强边缘点，则这是一个孤立的弱边缘点，此点置0。

/**
 用双阈值算法检测和连接边缘
 low 输入的低阈值
 high 输入的高阈值
 img 输入的原图像
 dst 输出的用双阈值算法检测和连接边缘后的图像
 */
void doubleThreshold (double low, double high, Mat &img, Mat &dst) {
    dst = img.clone();
    
    // 区分出弱边缘点和强边缘点
    for (int j = 0; j < img.rows-1; j++) {
        for (int i = 0; i < img.cols-1; i++) {
            double x = double(dst.ptr<uchar>(j)[i]);
            // 像素点为强边缘点，置255
            if (x > high) {
                dst.ptr<uchar>(j)[i] = 255;
            }
            // 像素点置0，被抑制掉
            else if (x < low) {
                dst.ptr<uchar>(j)[i] = 0;
            }
        }
    }
    
    // 弱边缘点补充连接强边缘点
    doubleThresholdLink(dst);
}
/**
 弱边缘点补充连接强边缘点
 img 弱边缘点补充连接强边缘点的输入和输出图像
 */
void doubleThresholdLink (Mat &img) {
    // 循环找到强边缘点，把其领域内的弱边缘点变为强边缘点
    for (int j = 1; j < img.rows-2; j++) {
        for (int i = 1; i < img.cols-2; i++) {
            // 如果该点是强边缘点
            if (img.ptr<uchar>(j)[i] == 255) {
                // 遍历该强边缘点领域
                for (int m = -1; m < 1; m++) {
                    for (int n = -1; n < 1; n++) {
                        // 该点为弱边缘点（不是强边缘点，也不是被抑制的0点）
                        if (img.ptr<uchar>(j+m)[i+n] != 0 && img.ptr<uchar>(j+m)[i+n] != 255) {
                            img.ptr<uchar>(j+m)[i+n] = 255; //该弱边缘点补充为强边缘点
                        }
                    }
                }
            }
        }
    }
    
    for (int j = 0; j < img.rows-1; j++) {
        for (int i = 0; i < img.cols-1; i++) {
            // 如果该点依旧是弱边缘点，及此点是孤立边缘点
            if (img.ptr<uchar>(j)[i] != 255 && img.ptr<uchar>(j)[i] != 255) {
                img.ptr<uchar>(j)[i] = 0; //该孤立弱边缘点抑制
            }
        }
    }
}

双阈值算法前后的输入输出图像 ：

双阈值算法

 

Canny边缘检测代码

#include <opencv2/opencv.hpp>
#include <math.h>

#define _USE_MATH_DEFINES

using namespace cv;// 使用命名空间cv


/**
 将两个图像拼接，以便在同一个窗口显示
 dst 输出的拼接后的图像
 src1 拼接的第一幅图
 src2 拼接的第二幅图
 */
void mergeImg(Mat & dst,Mat &src1,Mat &src2) {
    int rows = src1.rows;
    int cols = src1.cols+5+src2.cols;
    CV_Assert(src1.type () == src2.type ());
    dst.create (rows,cols,src1.type ());
    src1.copyTo (dst(Rect(0,0,src1.cols,src1.rows)));
    src2.copyTo (dst(Rect(src1.cols+5,0,src2.cols,src2.rows)));
}


/**
 一维高斯卷积，对每行进行高斯卷积
 img 输入原图像
 dst  一维高斯卷积后的输出图像
 */
void gaussianConvolution(Mat &img, Mat &dst) {
    int nr = img.rows;
    int nc = img.cols;
    int templates[3] = {1, 2, 1};
    
    // 按行遍历除每行边缘点的所有点
    for (int j = 0; j < nr; j++) {
        uchar* data= img.ptr<uchar>(j); //提取该行地址
        for (int i = 1; i < nc-1; i++) {
            int sum = 0;
            for (int n = 0; n < 3; n++) {
                sum += data[i-1+n] * templates[n]; //相称累加
            }
            sum /= 4;
            dst.ptr<uchar>(j)[i] = sum;
        }
    }
}


/**
 高斯滤波器，利用3*3的高斯模版进行高斯卷积
 img 输入原图像
 dst  高斯滤波后的输出图像
*/
void gaussianFilter(Mat &img, Mat &dst) {
    // 对水平方向进行滤波
    Mat dst1 = img.clone();
    gaussianConvolution(img, dst1);
    //图像矩阵转置
    Mat dst2;
    transpose(dst1, dst2);
    // 对垂直方向进行滤波
    Mat dst3 = dst2.clone();
    gaussianConvolution(dst2, dst3);
    // 再次转置
    transpose(dst3, dst);
}


/**
 用一阶偏导有限差分计算梯度幅值和方向
 img 输入原图像
 gradXY 输出的梯度幅值
 theta 输出的梯度方向
 */
void getGrandient (Mat &img, Mat &gradXY, Mat &theta) {
    gradXY = Mat::zeros(img.size(), CV_8U);
    theta = Mat::zeros(img.size(), CV_8U);
    
    for (int j = 1; j < img.rows-1; j++) {
        for (int i = 1; i < img.cols-1; i++) {
            double gradY = double(img.ptr<uchar>(j-1)[i-1] + 2 * img.ptr<uchar>(j-1)[i] + img.ptr<uchar>(j-1)[i+1] - img.ptr<uchar>(j+1)[i-1] - 2 * img.ptr<uchar>(j+1)[i] - img.ptr<uchar>(j+1)[i+1]);
            double gradX = double(img.ptr<uchar>(j-1)[i+1] + 2 * img.ptr<uchar>(j)[i+1] + img.ptr<uchar>(j+1)[i+1] - img.ptr<uchar>(j-1)[i-1] - 2 * img.ptr<uchar>(j)[i-1] - img.ptr<uchar>(j+1)[i-1]);

            gradXY.ptr<uchar>(j)[i] = sqrt(gradX*gradX + gradY*gradY); //计算梯度
            theta.ptr<uchar>(j)[i] = atan(gradY/gradX); //计算梯度方向
        }
    }
}


/**
 局部非极大值抑制
 gradXY 输入的梯度幅值
 theta 输入的梯度方向
 dst 输出的经局部非极大值抑制后的图像
 */
void nonLocalMaxValue (Mat &gradXY, Mat &theta, Mat &dst) {
    dst = gradXY.clone();
    for (int j = 1; j < gradXY.rows-1; j++) {
        for (int i = 1; i < gradXY.cols-1; i++) {
            double t = double(theta.ptr<uchar>(j)[i]);
            double g = double(dst.ptr<uchar>(j)[i]);
            if (g == 0.0) {
                continue;
            }
            double g0, g1;
            if ((t >= -(3*M_PI/8)) && (t < -(M_PI/8))) {
                g0 = double(dst.ptr<uchar>(j-1)[i-1]);
                g1 = double(dst.ptr<uchar>(j+1)[i+1]);
            }
            else if ((t >= -(M_PI/8)) && (t < M_PI/8)) {
                g0 = double(dst.ptr<uchar>(j)[i-1]);
                g1 = double(dst.ptr<uchar>(j)[i+1]);
            }
            else if ((t >= M_PI/8) && (t < 3*M_PI/8)) {
                g0 = double(dst.ptr<uchar>(j-1)[i+1]);
                g1 = double(dst.ptr<uchar>(j+1)[i-1]);
            }
            else {
                g0 = double(dst.ptr<uchar>(j-1)[i]);
                g1 = double(dst.ptr<uchar>(j+1)[i]);
            }
            
            if (g <= g0 || g <= g1) {
                dst.ptr<uchar>(j)[i] = 0.0;
            }
        }
    }
}


/**
 弱边缘点补充连接强边缘点
 img 弱边缘点补充连接强边缘点的输入和输出图像
 */
void doubleThresholdLink (Mat &img) {
    // 循环找到强边缘点，把其领域内的弱边缘点变为强边缘点
    for (int j = 1; j < img.rows-2; j++) {
        for (int i = 1; i < img.cols-2; i++) {
            // 如果该点是强边缘点
            if (img.ptr<uchar>(j)[i] == 255) {
                // 遍历该强边缘点领域
                for (int m = -1; m < 1; m++) {
                    for (int n = -1; n < 1; n++) {
                        // 该点为弱边缘点（不是强边缘点，也不是被抑制的0点）
                        if (img.ptr<uchar>(j+m)[i+n] != 0 && img.ptr<uchar>(j+m)[i+n] != 255) {
                            img.ptr<uchar>(j+m)[i+n] = 255; //该弱边缘点补充为强边缘点
                        }
                    }
                }
            }
        }
    }
    
    for (int j = 0; j < img.rows-1; j++) {
        for (int i = 0; i < img.cols-1; i++) {
            // 如果该点依旧是弱边缘点，及此点是孤立边缘点
            if (img.ptr<uchar>(j)[i] != 255 && img.ptr<uchar>(j)[i] != 255) {
                img.ptr<uchar>(j)[i] = 0; //该孤立弱边缘点抑制
            }
        }
    }
}


/**
 用双阈值算法检测和连接边缘
 low 输入的低阈值
 high 输入的高阈值
 img 输入的原图像
 dst 输出的用双阈值算法检测和连接边缘后的图像
 */
void doubleThreshold (double low, double high, Mat &img, Mat &dst) {
    dst = img.clone();
    
    // 区分出弱边缘点和强边缘点
    for (int j = 0; j < img.rows-1; j++) {
        for (int i = 0; i < img.cols-1; i++) {
            double x = double(dst.ptr<uchar>(j)[i]);
            // 像素点为强边缘点，置255
            if (x > high) {
                dst.ptr<uchar>(j)[i] = 255;
            }
            // 像素点置0，被抑制掉
            else if (x < low) {
                dst.ptr<uchar>(j)[i] = 0;
            }
        }
    }
    
    // 弱边缘点补充连接强边缘点
    doubleThresholdLink(dst);
}


int main () {
    Mat img = imread("woman.jpg", IMREAD_GRAYSCALE); //从文件中加载灰度图像

    // 读取图片失败，则停止
    if (img.empty()) {
        printf("读取图像文件失败");
        system("pause");
        return 0;
    }
    
    // 高斯滤波
    Mat gauss_img;
    gaussianFilter(img, gauss_img); //高斯滤波器
    
    // 用一阶偏导有限差分计算梯度幅值和方向
    Mat gradXY, theta;
    getGrandient(gauss_img, gradXY, theta);
    
    // 局部非极大值抑制
    Mat local_img;
    nonLocalMaxValue(gradXY, theta, local_img);
    
    // 用双阈值算法检测和连接边缘
    Mat dst;
    doubleThreshold(40, 80, local_img, dst);

    // 图像显示
    Mat outImg;
    mergeImg (outImg,img,dst); //图像拼接
    namedWindow("img");
    imshow("img",outImg);// 图像显示
    imwrite("canny算法.jpg", outImg);

    waitKey(); //等待键值输入
    return 0;
}

Canny边缘检测的前后图像

Canny边缘检测算法

 

参考资源：

【1】Setting up OpenCV and C++ development environment in Xcode for Computer Vision projects，地址：https://medium.com/@jaskaranvirdi/setting-up-opencv-and-c-development-environment-in-xcode-b6027728003

【2】OpenCV Tutorials，地址：https://docs.opencv.org/master/d9/df8/tutorial_root.html

【3】OpenCV教程，地址：https://www.w3cschool.cn/opencv/opencv-2gnx28u3.html

 

 

HUSTER_Gy
关注
  • 18
    点赞
  • 踩
  • 133
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
基于C++的OpenCV4入门基础--边缘检测之 Canny 算子
jiangchaobing_2017的博客
10-20 133
基于C++的OpenCV4的Canny用法说明
Canny边缘检测
FLR的博客
07-29 311
Canny边缘检测 \1) 使用高斯滤波器，以平滑图像，滤除噪声。 \2) 计算图像中每个像素点的梯度强度和方向。 \3) 应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。 \4) 应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。 \5) 通过抑制孤立的弱边缘最终完成边缘检测。 1:高斯滤波器 2:梯度和方向 3：非极大值抑制 4：双阈值检测 img
用c++实现Canny算子
06-30
主要用C++实现canny算子。没有直接调用opencv的canny算子，自己实现canny算子的函数。
图像处理之边缘检测（C++）
最新发布
qq_45045175的博客
05-17 1353
本文介绍了图像处理中的边缘检测算法，包括了Roberts、Sobel、Prewitt、laplacian、DOG、LOG等算子的C++实现和原理介绍，欢迎大家指出问题和交流讨论。
C++实现Canny边缘检测（原理+底层代码）
shinuone的博客
05-27 1759
检测步骤：1、使用高斯滤波器进行平滑处理；2、利用一阶偏导计算x与y方向的梯度幅值和方向；3、对梯度幅值进行NMS非极大值抑制；4、用双阈值算法检测和边缘连接。
基于C++的Canny边缘检测（数字图像处理）
毕业作品网站
05-09 1546
数字图像处理—Canny边缘检测 一、实验环境 操作系统：Ubuntu 18.04 LTS IDE：Qt Creator (with CMake) 第三方库：OpenCV 4.1.1 编译器：g++ 二、实验目的 通过课堂的学习，已经对图像分割的相关理论知识已经有了全面的了解，知道了许多图像分割的算法及算子，了解到不同的算子算法有着不同的优缺点，为了更好更直观地对图像分割进行深入理解，达到理论联系实际的目的，现实现Canny算子 三、实验原理 Canny算法采用先平滑后求导数的方法，先用高斯模板进行平
c++视觉检测-----Canny边缘算子
qq_46107892的博客
10-10 494
c++视觉检测-----Canny边缘算子
canny边缘检测算子，C++算法实现
08-29
**二、C++实现Canny边缘检测** 在C++中实现Canny边缘检测，通常会涉及到OpenCV库，这是一个强大的开源计算机视觉库，提供了许多预定义的函数来实现图像处理任务，包括Canny边缘检测。以下是一般步骤： 1. 导入必要...
Canny边缘检测算法原理及其VC实现详解
04-15
在本文中，我们将深入探讨Canny边缘检测的原理，并介绍如何在Visual C++（VC）环境中实现这一算法。 Canny算法主要包括以下几个步骤： 1. **高斯滤波**：首先，对输入图像进行高斯平滑处理，以消除噪声。高斯...
Canny边缘检测c++代码
08-18
在C++中实现Canny边缘检测，通常会涉及到OpenCV库，这是一个强大的计算机视觉库，提供了许多预定义的图像处理函数，包括Canny边缘检测。在源代码中，你可能会看到如下关键函数的调用： ```cpp cv::Canny(image, ...
OpenCV实现canny边缘检测（C++实现）.zip
04-12
本项目以C++语言为基础，利用OpenCV库实现了Canny边缘检测算法，这是一种经典的图像边缘检测技术，适用于在图像中寻找清晰的边界。 Canny边缘检测算法由John F. Canny于1986年提出，其主要目标是高效地检测图像中的...
哈夫变换和Canny边缘检测算法及其实现代码.docx
07-03
本文将深入探讨两种常用的边缘检测算法：哈夫变换（Hough Transform）和Canny边缘检测算法，并提供它们的实现代码概述。 1. 哈夫变换： 哈夫变换是一种寻找图像中直线或曲线的方法，通过将像素空间中的点映射到参数...
Canny的C++实现
liugan528的博客
02-08 3264
好的图像边缘检测应该满足 尽可能的标记处所有的边缘； 标记出的边缘就是实际图像内容的边缘； 图像中的边缘只标记一次。 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++代码
thank3194003824的博客
09-07 967
一、算法原理 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
OpenCV之Canny边缘检测（C++实现）
热门推荐
xddwz的博客
12-23 1万+
canny算子简介 首先看一下最有边缘检测的三个主要评价标准： 低错误率：标出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。 高定位性：标识出的边缘要与图像中的实际边缘尽可能接近。 最小响应：图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。 为了满足这些要求，canny使用的变分法，这是一种寻找满足特定功能的函数的方法。最优检测用4个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。 canny边缘检测的步骤 第一步：消除噪声 一般情况下，使用高斯平滑滤波器降噪，以
Canny边缘检测及C++实现(转载)
enjoyxiong的博客
06-09 1581
Canny边缘检测算法是澳大利亚科学家John F. Canny在1986年提出来的，不得不提一下的是当年John Canny本人才28岁！到今天已经30年过去了，Canny算法仍然是图像边缘检测算法中最经典、有效的算法之一。 一起睹一下大家Canny的风采： John Canny研究了最优边缘检测方法所需的特性，给出了评价边缘检测性能优劣的3个指标： 1  好的信噪比，即将非边缘点判定为边缘点的概率要低，将边缘点判为非边缘点的概率要...
【C++】【Opencv】cv::Canny()边缘检测函数详解和示例
不定时分享，互相学习，共同进步
11-19 4437
Canny边缘检测是一种流行的边缘检测算法，由John F. Canny在1986年开发。它是一种多阶段过程，包括噪声滤波、计算图像强度的梯度、非最大值抑制以及双阈值检测。本文通过函数原型解读和示例对cv::Canny()函数进行详解，以帮助大家理解和使用。
opencv c++ canny 实现 以及与halcon canny的对比
weixin_39354845的博客
10-30 1170
halcon canny
图像处理知识点1：Canny算子C++实现（纯C++）
Scream1314的博客
05-24 443
Canny算子的原理已经有很多博文在叙述了，在这里就不做过多介绍。以下是我将opencv的程序转为c++的结果。最近整理了不少传统图像的算法及优化都是底层C++实现的。大部分都是照着opencv改的，看懂了改一改就行了，以后有时间更新吧。
Canny边缘检测c++
07-28
Python中的Canny边缘检测算法是一种基于图像梯度的边缘检测算法，它可以在图像中检测出边缘，并将其转换为二值图像。该算法的主要步骤包括高斯滤波、计算图像梯度、非极大值抑制、双阈值处理和边缘连接等。Canny边缘检测算法在图像处理领域中得到了广泛的应用，可以用于图像分割、目标检测、图像识别等方面。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值