Canny边缘检测算法的原理与实现

最新推荐文章于 2024-04-26 18:23:38 发布
最新推荐文章于 2024-04-26 18:23:38 发布
阅读量1.5w 收藏 109
点赞数 10
分类专栏： 图像处理 计算机视觉 文章标签： Canny
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianqing13579/article/details/51708493
版权

文章目录

Canny原理

Canny的原理就不细说了，冈萨雷斯的《数字图像处理》（中文第三版）P463~465讲解的比较清楚，主要就四个步骤：

  1. 对图像进行高斯滤波(由于实际实现的时候使用Sobel计算梯度，Sobel具有滤波作用，所以实际的实现省略了高斯滤波)
  2. 计算梯度大小和梯度方向
  3. 对梯度幅值图像进行非极大抑制
  4. 双阈值处理和连接性分析（通常这一步与非极大抑制并行，详见下面的代码）

下面重点说一下非极大抑制。

非极大抑制

对一幅图像计算梯度大小和梯度方向后，需要进行非极大抑制，一般都是通过计算梯度方向，沿着梯度方向，判断该像素点的梯度大小是否是极大值。这里主要说一下方向的判断。

图像坐标系

OpenCV中采用下面的坐标系
这里写图片描述
《数字图像处理》（中文第三版）这本书中图像坐标顺序与上述坐标系是相反的，看书的时候，注意一下坐标的顺序。

我们这里采用的图像坐标系与OpenCV一致。

本文中采用顺时针角度为正（OpenCV中规定逆时针为正）

这里写图片描述

边缘方向区间

非极大抑制中，通常将边缘量化为4个方向，水平，垂直，45°和-45°，实际中，通过定义一个方向角方位，在该方位内认为是某一方向的边缘，实现中，我们通过计算梯度方向的范围从而判断边缘的方向（边缘的方向与梯度方向垂直）。

这里写图片描述

由于边缘方向没有正负，梯度方向在-22.5°到+22.5和157.5°到-157.5°表示的是同一个边缘，所以这里梯度方向 θ \theta θ只考虑180°区间内。如上图所示：

  1. 当 − 22.5 ° < θ < 22.5 ° -22.5°<\theta<22.5° −22.5°<θ<22.5°的时候，梯度方向为0°，也就是垂直边缘
  2. 当 22.5 ° < θ < 67.5 ° 22.5°<\theta<67.5° 22.5°<θ<67.5°的时候，梯度方向为45°，也就是135°边缘
  3. 其他两个方向依次类推

实现中，通过三角函数的性质计算，比如第一种情况，使用下面条件来判断
− 22.5 ° < θ < 22.5 ° -22.5°<\theta<22.5° −22.5°<θ<22.5°
=> t a n ( − 22.5 ° ) < t a n θ < t a n ( 22.5 ° ) tan(-22.5°)<tan\theta<tan(22.5°) tan(−22.5°)<tanθ<tan(22.5°)
=> t a n ( − 22.5 ° ) < f y f x < t a n ( 22.5 ° ) tan(-22.5°)<{fy \over fx } <tan(22.5°) tan(−22.5°)<fxfy​<tan(22.5°)
=> f x ∗ t a n ( − 22.5 ° ) < f y < f x ∗ t a n ( 22.5 ° ) fx*tan(-22.5°)<{fy } <fx* tan(22.5°) fx∗tan(−22.5°)<fy<fx∗tan(22.5°)
其中 f x 和 f y fx和fy fx和fy表示x方向和y方向的偏导数。

其他三种情况读者可以自行推导。

判断出梯度方向后，就可以进行非极大值抑制了。还是以第一种情况为例，比如我计算出了P5这个像素点处的梯度方向为0°(180°)，则这个时候，我们要判断的条件就是if(M(P5)>=M(P4)&&M(P5)>=M(P6)),也就是P5处的梯度值是否是极大值，其中M（）表示该像素点的梯度大小。

这里写图片描述

Canny算法的实现(1.0版)

#define CANNY_SHIFT 16
#define TAN_225  (int)(0.4142135623730950488016887242097*(1 << CANNY_SHIFT));
#define TAN_675  (int)(2.4142135623730950488016887242097*(1 << CANNY_SHIFT));
void Canny1(const Mat &srcImage, Mat &dstImage, double lowThreshold, double highThreshold, int sizeOfAperture, bool L2)
{
    // 只支持灰度图
    CV_Assert(srcImage.type() == CV_8UC1);
    dstImage.create(srcImage.size(), srcImage.type());

    // L2范数计算边缘强度的时候，距离采用平方的方式，所以阈值也需要采用平方
    if (L2)
    {
        lowThreshold = std::min(32767.0, lowThreshold);
        highThreshold = std::min(32767.0, highThreshold);

        if (lowThreshold > 0) lowThreshold *= lowThreshold;
        if (highThreshold > 0) highThreshold *= highThreshold;
    }

    // 计算fx,fy,强度图
    Mat fx(srcImage.size(), CV_32SC1);
    Mat fy(srcImage.size(), CV_32SC1);
    Mat enlargedImage;
    Mat magnitudeImage(srcImage.rows + 2, srcImage.cols + 2, CV_32SC1);
    magnitudeImage.setTo(Scalar(0));
    copyMakeBorder(srcImage, enlargedImage, 1, 1, 1, 1, cv::BORDER_REPLICATE);
    int stepOfEnlargedImage = enlargedImage.cols;
    int stepOffx = fx.cols;
    int height = srcImage.rows;
    int width = srcImage.cols;
    uchar *rowOfEnlargedImage = enlargedImage.data + stepOfEnlargedImage + 1;
    int *rowOffx = (int *)fx.data;
    int *rowOffy = (int *)fy.data;
    int *rowOfMagnitudeImage = (int *)magnitudeImage.data + stepOfEnlargedImage + 1;
    for (int y = 0; y <= height - 1; ++y, rowOfEnlargedImage += stepOfEnlargedImage, rowOfMagnitudeImage += stepOfEnlargedImage, rowOffx += stepOffx, rowOffy += stepOffx)
    {
        uchar *colOfEnlargedImage = rowOfEnlargedImage;
        int *colOffx = rowOffx;
        int *colOffy = rowOffy;
        int *colOfMagnitudeImage = rowOfMagnitudeImage;
        for (int x = 0; x <= width - 1; ++x, ++colOfEnlargedImage, ++colOffx, ++colOffy, ++colOfMagnitudeImage)
        {
            // fx
            colOffx[0] = colOfEnlargedImage[1 - stepOfEnlargedImage] + 2 * colOfEnlargedImage[1] + colOfEnlargedImage[1 + stepOfEnlargedImage] -
                colOfEnlargedImage[-1 - stepOfEnlargedImage] - 2 * colOfEnlargedImage[-1] - colOfEnlargedImage[-1 + stepOfEnlargedImage];

            // fy
            colOffy[0] = colOfEnlargedImage[stepOfEnlargedImage - 1] + 2 * colOfEnlargedImage[stepOfEnlargedImage] + colOfEnlargedImage[stepOfEnlargedImage + 1] -
                colOfEnlargedImage[-stepOfEnlargedImage - 1] - 2 * colOfEnlargedImage[-stepOfEnlargedImage] - colOfEnlargedImage[-stepOfEnlargedImage + 1];

            // 计算边缘强度，由于只是用于比较，为了加快速度，只计算平方和
            if (L2)
            {
                colOfMagnitudeImage[0] = colOffx[0] * colOffx[0] + colOffy[0] * colOffy[0];
            }
            else
            {
                colOfMagnitudeImage[0] = std::abs(colOffx[0]) + std::abs(colOffy[0]);
            }

        }
    }


    // 非极大抑制，同时标记图做标记,双阈值处理
    //   0 - 可能是边缘
    //   1 - 不是边缘
    //   2 - 一定是边缘
    Mat labelImage(srcImage.rows + 2, srcImage.cols + 2, CV_8UC1);
    memset(labelImage.data, 1, labelImage.rows*labelImage.cols);
    rowOffx = (int *)fx.data;
    rowOffy = (int *)fy.data;
    rowOfMagnitudeImage = (int *)magnitudeImage.data + stepOfEnlargedImage + 1;
    uchar *rowOfLabelImage = labelImage.data + stepOfEnlargedImage + 1;
    queue<uchar*> queueOfEdgePixel;
    for (int y = 0; y <= height - 1; ++y, rowOfMagnitudeImage += stepOfEnlargedImage, rowOffx += stepOffx, rowOffy += stepOffx, rowOfLabelImage += stepOfEnlargedImage)
    {
        int *colOffx = rowOffx;
        int *colOffy = rowOffy;
        int *colOfMagnitudeImage = rowOfMagnitudeImage;
        uchar *colOfLabelImage = rowOfLabelImage;
        for (int x = 0; x <= width - 1; ++x, ++colOffx, ++colOffy, ++colOfMagnitudeImage, ++colOfLabelImage)
        {
            int fx = colOffx[0];
            int fy = colOffy[0];

            // 该像素点才有可能是边缘点
            if (colOfMagnitudeImage[0] > lowThreshold)
            {
                // 非极大抑制
                fy = fy*(1 << CANNY_SHIFT);

                int tan225 = fx * TAN_225;
                int tan675 = fx * TAN_675;

                // 梯度方向0
                if (fy>-1 * tan225 && fy < tan225)
                {
                    // 极大值，有可能是边缘
                    if (colOfMagnitudeImage[0] >= colOfMagnitudeImage[-1] && colOfMagnitudeImage[0] >= colOfMagnitudeImage[1])
                    {
                        // 大于高阈值，是边缘，标记为2
                        if (colOfMagnitudeImage[0] > highThreshold)
                        {
                            // 进入队列，并设置标记
                            colOfLabelImage[0] = 2;
                            queueOfEdgePixel.push(colOfLabelImage);
                        }
                        else
                        {
                            // 有可能是边缘，标记为0
                            colOfLabelImage[0] = 0;

                        }
                    }
                }

                // 梯度方向45
                if (fy > tan225&&fy < tan675)
                {
                    // 极大值，有可能是边缘
                    if (colOfMagnitudeImage[0] >= colOfMagnitudeImage[stepOfEnlargedImage + 1] && colOfMagnitudeImage[0]  >= colOfMagnitudeImage[-stepOfEnlargedImage - 1])
                    {
                        // 大于高阈值，是边缘，标记为2
                        if (colOfMagnitudeImage[0] > highThreshold)
                        {
                            // 进入队列，并设置标记
                            colOfLabelImage[0] = 2;
                            queueOfEdgePixel.push(colOfLabelImage);
                        }
                        else
                        {
                            // 有可能是边缘，标记为0
                            colOfLabelImage[0] = 0;

                        }

                    }

                }

                // 梯度方向90
                if (fy>tan675 || fy<-tan675)
                {
                    // 极大值，有可能是边缘
                    if (colOfMagnitudeImage[0] >= colOfMagnitudeImage[stepOfEnlargedImage] && colOfMagnitudeImage[0] >= colOfMagnitudeImage[-stepOfEnlargedImage])
                    {
                        // 大于高阈值，是边缘，标记为2
                        if (colOfMagnitudeImage[0] > highThreshold)
                        {
                            // 进入队列，并设置标记
                            colOfLabelImage[0] = 2;
                            queueOfEdgePixel.push(colOfLabelImage);
                        }
                        else
                        {
                            // 有可能是边缘，标记为0
                            colOfLabelImage[0] = 0;

                        }

                    }

                }

                // 梯度方向135
                if (fy >= -1 * tan675&&fy <= -1 * tan225)
                {
                    // 极大值，有可能是边缘
                    if (colOfMagnitudeImage[0] >=colOfMagnitudeImage[stepOfEnlargedImage - 1] && colOfMagnitudeImage[0]  >= colOfMagnitudeImage[-stepOfEnlargedImage + 1])
                    {
                        // 大于高阈值，是边缘，标记为2
                        if (colOfMagnitudeImage[0] > highThreshold)
                        {
                            // 进入队列，并设置标记
                            colOfLabelImage[0] = 2;
                            queueOfEdgePixel.push(colOfLabelImage);
                        }
                        else
                        {
                            // 有可能是边缘，标记为0
                            colOfLabelImage[0] = 0;

                        }

                    }

                }

            }
        }

    }

    // 连接性分析,这里采用队列实现
    while (!queueOfEdgePixel.empty())
    {
        uchar *m = queueOfEdgePixel.front();
        queueOfEdgePixel.pop();

        // 在8领域搜索
        if (!m[-1])
        {
            m[-1] = 2;
            queueOfEdgePixel.push(m - 1);
        }

        if (!m[1])
        {
            m[1] = 2;
            queueOfEdgePixel.push(m + 1);
        }
        if (!m[-stepOfEnlargedImage - 1])
        {
            m[-stepOfEnlargedImage - 1] = 2;
            queueOfEdgePixel.push(m - stepOfEnlargedImage - 1);
        }
        if (!m[-stepOfEnlargedImage])
        {
            m[-stepOfEnlargedImage] = 2;
            queueOfEdgePixel.push(m - stepOfEnlargedImage);
        }
        if (!m[-stepOfEnlargedImage + 1])
        {
            m[-stepOfEnlargedImage + 1] = 2;
            queueOfEdgePixel.push(m - stepOfEnlargedImage + 1);
        }
        if (!m[stepOfEnlargedImage - 1])
        {
            m[stepOfEnlargedImage - 1] = 2;
            queueOfEdgePixel.push(m + stepOfEnlargedImage - 1);
        }
        if (!m[stepOfEnlargedImage])
        {
            m[stepOfEnlargedImage] = 2;
            queueOfEdgePixel.push(m + stepOfEnlargedImage);
        }
        if (!m[stepOfEnlargedImage + 1])
        {
            m[stepOfEnlargedImage + 1] = 2;
            queueOfEdgePixel.push(m + stepOfEnlargedImage + 1);
        }
    }

    // 最后生成边缘图
    rowOfLabelImage = labelImage.data + stepOfEnlargedImage + 1;
    uchar *rowOfDst = dstImage.data;
    for (int y = 0; y <= height - 1; ++y, rowOfLabelImage += stepOfEnlargedImage, rowOfDst += stepOffx)
    {
        uchar *colOfLabelImage = rowOfLabelImage;
        uchar *colOfDst = rowOfDst;
        for (int x = 0; x <= width - 1; ++x, ++colOfDst, ++colOfLabelImage)
        {
            if (colOfLabelImage[0] == 2)
                colOfDst[0] = 255;
            else
            {
                colOfDst[0] = 0;
            }
        }
    }

}

Canny算法的实现(2.0版)

后来发现非极大抑制中梯度方向区间的计算可以使用绝对值求解，而且采用绝对值求解后，检测效果要好于1.0版本，修改后程序如下

#define CANNY_SHIFT 16
#define TAN_225  (int)(0.4142135623730950488016887242097*(1 << CANNY_SHIFT));
#define TAN_675  (int)(2.4142135623730950488016887242097*(1 << CANNY_SHIFT));
// 转为绝对值求解
void Canny2(const Mat &srcImage, Mat &dstImage, double lowThreshold, double highThreshold, int sizeOfAperture, bool L2)
{
	// 只支持灰度图
	CV_Assert(srcImage.type() == CV_8UC1);
	dstImage.create(srcImage.size(), srcImage.type());

	// L2范数计算边缘强度的时候，距离采用平方的方式，所以阈值也需要采用平方
	if (L2)
	{
		lowThreshold = std::min(32767.0, lowThreshold);
		highThreshold = std::min(32767.0, highThreshold);

		if (lowThreshold > 0) lowThreshold *= lowThreshold;
		if (highThreshold > 0) highThreshold *= highThreshold;
	}

	// 计算fx,fy,强度图
	Mat fx(srcImage.size(), CV_32SC1);
	Mat fy(srcImage.size(), CV_32SC1);
	Mat enlargedImage;
	Mat magnitudeImage(srcImage.rows + 2, srcImage.cols + 2, CV_32SC1);
	magnitudeImage.setTo(Scalar(0));
	copyMakeBorder(srcImage, enlargedImage, 1, 1, 1, 1, cv::BORDER_REPLICATE);
	int stepOfEnlargedImage = enlargedImage.cols;
	int stepOffx = fx.cols;
	int height = srcImage.rows;
	int width = srcImage.cols;
	uchar *rowOfEnlargedImage = enlargedImage.data + stepOfEnlargedImage + 1;
	int *rowOffx = (int *)fx.data;
	int *rowOffy = (int *)fy.data;
	int *rowOfMagnitudeImage = (int *)magnitudeImage.data + stepOfEnlargedImage + 1;
	for (int y = 0; y <= height - 1; ++y, rowOfEnlargedImage += stepOfEnlargedImage, rowOfMagnitudeImage += stepOfEnlargedImage, rowOffx += stepOffx, rowOffy += stepOffx)
	{
		uchar *colOfEnlargedImage = rowOfEnlargedImage;
		int *colOffx = rowOffx;
		int *colOffy = rowOffy;
		int *colOfMagnitudeImage = rowOfMagnitudeImage;
		for (int x = 0; x <= width - 1; ++x, ++colOfEnlargedImage, ++colOffx, ++colOffy, ++colOfMagnitudeImage)
		{
			// fx
			colOffx[0] = colOfEnlargedImage[1 - stepOfEnlargedImage] + 2 * colOfEnlargedImage[1] + colOfEnlargedImage[1 + stepOfEnlargedImage] -
				colOfEnlargedImage[-1 - stepOfEnlargedImage] - 2 * colOfEnlargedImage[-1] - colOfEnlargedImage[-1 + stepOfEnlargedImage];

			// fy
			colOffy[0] = colOfEnlargedImage[stepOfEnlargedImage - 1] + 2 * colOfEnlargedImage[stepOfEnlargedImage] + colOfEnlargedImage[stepOfEnlargedImage + 1] -
				colOfEnlargedImage[-stepOfEnlargedImage - 1] - 2 * colOfEnlargedImage[-stepOfEnlargedImage] - colOfEnlargedImage[-stepOfEnlargedImage + 1];

			// 计算边缘强度，由于只是用于比较，为了加快速度，只计算平方和
			if (L2)
			{
				colOfMagnitudeImage[0] = colOffx[0] * colOffx[0] + colOffy[0] * colOffy[0];
			}
			else
			{
				colOfMagnitudeImage[0] = std::abs(colOffx[0]) + std::abs(colOffy[0]);
			}

		}
	}


	// 非极大抑制，同时标记图做标记,双阈值处理
	//   0 - 可能是边缘
	//   1 - 不是边缘
	//   2 - 一定是边缘
	Mat labelImage(srcImage.rows + 2, srcImage.cols + 2, CV_8UC1);
	memset(labelImage.data, 1, labelImage.rows*labelImage.cols);
	rowOffx = (int *)fx.data;
	rowOffy = (int *)fy.data;
	rowOfMagnitudeImage = (int *)magnitudeImage.data + stepOfEnlargedImage + 1;
	uchar *rowOfLabelImage = labelImage.data + stepOfEnlargedImage + 1;
	queue<uchar*> queueOfEdgePixel;
	for (int y = 0; y <= height - 1; ++y, rowOfMagnitudeImage += stepOfEnlargedImage, rowOffx += stepOffx, rowOffy += stepOffx, rowOfLabelImage += stepOfEnlargedImage)
	{
		int *colOffx = rowOffx;
		int *colOffy = rowOffy;
		int *colOfMagnitudeImage = rowOfMagnitudeImage;
		uchar *colOfLabelImage = rowOfLabelImage;
		for (int x = 0; x <= width - 1; ++x, ++colOffx, ++colOffy, ++colOfMagnitudeImage, ++colOfLabelImage)
		{
			int fx = colOffx[0];
			int fy = colOffy[0];
			int abs_fx = std::abs(fx);
			int abs_fy = std::abs(fy);

			// 该像素点才有可能是边缘点
			if (colOfMagnitudeImage[0] > lowThreshold)
			{
				// 非极大抑制
				abs_fy = abs_fy << CANNY_SHIFT;

				int tan225 = abs_fx * TAN_225;
				int tan675 = abs_fx * TAN_675;

				// 梯度方向0°
				if (abs_fy< tan225)
				{
					// 极大值，有可能是边缘
					if (colOfMagnitudeImage[0] >= colOfMagnitudeImage[-1] && colOfMagnitudeImage[0] >= colOfMagnitudeImage[1])
					{
						// 大于高阈值，是边缘，标记为2
						if (colOfMagnitudeImage[0] > highThreshold)
						{
							// 进入队列，并设置标记
							colOfLabelImage[0] = 2;
							queueOfEdgePixel.push(colOfLabelImage);
						}
						else
						{
							// 有可能是边缘，标记为0
							colOfLabelImage[0] = 0;

						}
					}
				}

				// 梯度方向90°
				if (abs_fy>tan675)
				{
					// 极大值，有可能是边缘
					if (colOfMagnitudeImage[0] >= colOfMagnitudeImage[stepOfEnlargedImage] && colOfMagnitudeImage[0] >= colOfMagnitudeImage[-stepOfEnlargedImage])
					{
						// 大于高阈值，是边缘，标记为2
						if (colOfMagnitudeImage[0] > highThreshold)
						{
							// 进入队列，并设置标记
							colOfLabelImage[0] = 2;
							queueOfEdgePixel.push(colOfLabelImage);
						}
						else
						{
							// 有可能是边缘，标记为0
							colOfLabelImage[0] = 0;

						}

					}

				}

				// 梯度方向45°/-45°
				if (abs_fy > tan225&&abs_fy<tan675)
				{
					int s = (fy*fx) < 0 ? -1 : 1;
					// 极大值，有可能是边缘
					if (colOfMagnitudeImage[0] >= colOfMagnitudeImage[-stepOfEnlargedImage - s] && colOfMagnitudeImage[0]  >= colOfMagnitudeImage[stepOfEnlargedImage + s])
					{
						// 大于高阈值，是边缘，标记为2
						if (colOfMagnitudeImage[0] > highThreshold)
						{
							// 进入队列，并设置标记
							colOfLabelImage[0] = 2;
							queueOfEdgePixel.push(colOfLabelImage);
						}
						else
						{
							// 有可能是边缘，标记为0
							colOfLabelImage[0] = 0;

						}

					}

				}

			}
		}

	}

	// 连接性分析,这里采用队列实现
	while (!queueOfEdgePixel.empty())
	{
		uchar *m = queueOfEdgePixel.front();
		queueOfEdgePixel.pop();

		// 在8领域搜索
		if (!m[-1])
		{
			m[-1] = 2;
			queueOfEdgePixel.push(m - 1);
		}

		if (!m[1])
		{
			m[1] = 2;
			queueOfEdgePixel.push(m + 1);
		}
		if (!m[-stepOfEnlargedImage - 1])
		{
			m[-stepOfEnlargedImage - 1] = 2;
			queueOfEdgePixel.push(m - stepOfEnlargedImage - 1);
		}
		if (!m[-stepOfEnlargedImage])
		{
			m[-stepOfEnlargedImage] = 2;
			queueOfEdgePixel.push(m - stepOfEnlargedImage);
		}
		if (!m[-stepOfEnlargedImage + 1])
		{
			m[-stepOfEnlargedImage + 1] = 2;
			queueOfEdgePixel.push(m - stepOfEnlargedImage + 1);
		}
		if (!m[stepOfEnlargedImage - 1])
		{
			m[stepOfEnlargedImage - 1] = 2;
			queueOfEdgePixel.push(m + stepOfEnlargedImage - 1);
		}
		if (!m[stepOfEnlargedImage])
		{
			m[stepOfEnlargedImage] = 2;
			queueOfEdgePixel.push(m + stepOfEnlargedImage);
		}
		if (!m[stepOfEnlargedImage + 1])
		{
			m[stepOfEnlargedImage + 1] = 2;
			queueOfEdgePixel.push(m + stepOfEnlargedImage + 1);
		}
	}

	// 最后生成边缘图
	rowOfLabelImage = labelImage.data + stepOfEnlargedImage + 1;
	uchar *rowOfDst = dstImage.data;
	for (int y = 0; y <= height - 1; ++y, rowOfLabelImage += stepOfEnlargedImage, rowOfDst += stepOffx)
	{
		uchar *colOfLabelImage = rowOfLabelImage;
		uchar *colOfDst = rowOfDst;
		for (int x = 0; x <= width - 1; ++x, ++colOfDst, ++colOfLabelImage)
		{
			if (colOfLabelImage[0] == 2)
				colOfDst[0] = 255;
			else
			{
				colOfDst[0] = 0;
			}
		}
	}

}

实验结果

实验代码

int main(int argc, char *argv[])
{
	Mat srcImage = imread("D:/Image/Gray/Lena512.bmp", -1);
	Mat canny1,canny,canny2;
	Canny1(srcImage, canny1, 50, 150, 3, false);
	Canny2(srcImage, canny3, 50, 150, 3, false);
	Canny(srcImage, canny, 50, 150);
	imwrite("D:/Canny.bmp", canny);
	imwrite("D:/Canny1.bmp", canny1);
	imwrite("D:/Canny2.bmp", canny2);
	return 0;
}

使用的是标准的Lena图
这里写图片描述

OpenCV 的处理结果为：

这里写图片描述

Canny1 的结果:

这里写图片描述

Canny2 的结果:

这里写图片描述

结果可以看出，Canny1丢失了一些垂直边缘，改进后的Canny2与OpenCV处理结果基本一致。

完整工程见github项目：QQImageProcess_OpenCV
其中Canny边缘检测的实现在 Src/ImageProcess/Edge.h中的Canny_系列函数中。

2016-6-19 01:54:58
Last Updated: 2016-9-3 09:11:58

非常感谢您的阅读，如果您觉得这篇文章对您有帮助，欢迎扫码进行赞赏。
这里写图片描述

qianqing13579
关注
  • 10
    点赞
  • 踩
  • 109
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
图像处理——Canny边缘检测算法（原理+代码演示）
minjiuhong的博客
04-15 1万+
Canny边缘检测Canny算法介绍Canny算法原理第一步：高斯模糊第二步：Sobel梯度算子第三步：非极大值抑制（NMS）第四步：双阈值连接视频流Canny边缘检测（阈值可调） Canny算法介绍 Canny边缘检测算法是一种多级边缘检测算法，John F. Canny于 1986 年开发出来。在许多方面的应用都有着它的身影。因此，不管是为了学习或者工作，学习Canny算法的原理和实现都是非常...
Canny边缘检测算法原理及其VC实现详解
04-15
在本文中，我们将深入探讨Canny边缘检测的原理，并介绍如何在Visual C++（VC）环境中实现这一算法。 Canny算法主要包括以下几个步骤： 1. **高斯滤波**：首先，对输入图像进行高斯平滑处理，以消除噪声。高斯...
【思维导图】canny滤波 原理步骤细致剖析
weixin_46306002的博客
11-01 2841
canny滤波 原理步骤细致剖析 制作人 霏儿，百度飞桨PPDE开发者技术专家，计算机视觉、虚拟现实、元宇宙，欢迎技术交流 目的 最优边缘检测 含义 最优检测 算法能够尽可能多地标识出图像中的实际边缘 最优定位准则 标识出的边缘要尽可能与实际图像中的实际边缘尽可能接近 检测点与边缘点一一对应 图像中的边缘只能标识一次 步骤 转为灰度图 减少计算开销 滤波 高斯滤波 卷积核满足正态分布 核越大，图像越模糊 高斯核大小将影响canny滤波器的性能 尺寸越大，滤波器对噪声的敏感.
C++实现Canny边缘检测（原理+底层代码）
shinuone的博客
05-27 1800
检测步骤：1、使用高斯滤波器进行平滑处理；2、利用一阶偏导计算x与y方向的梯度幅值和方向；3、对梯度幅值进行NMS非极大值抑制；4、用双阈值算法检测和边缘连接。
Canny 算法
最新发布
策马扬尘，江湖逐浪。
04-26 921
这一过程的思路是首先选定边缘强度大于高阈值的所有确定边缘点，然后在边缘强度大于低阈值的情况下尽可能延长边缘，如果最终能够连接到强边缘点，则这些点保留。然后根据得到的方向，对该方向的值进行比对，非极大值要抑制为0，极大值保留。高斯模板来源于高斯函数，通过选取不同的sigma，得到不同的模板，得到模板后，进行归一化，成为最终的现在我用使用的高斯滤波模板。根据angle来进行相应方向上的大小比较，如果和相应方向上的两个值进行对比，不是极大值，那么这一点置零；然后进行归一化处理，然后进行约等于，得到5*5模板。
Canny边缘检测
健身房
11-30 717
图像的边缘检测的原理是检测出图像中所有灰度值变化较大的点，而且这些点连接起来就构成了若干线条，这些线条就可以称为图像的边缘。Canny边缘检测算子是于1986年开发出来的一个多级边缘检测算法。
视觉媒体通信——图像处理算法之Canny边缘检测
liyang927的博客
07-02 1721
从Canny边缘检测的基本原理出发，逐步实现了图像的Canny边缘检测
canny边缘检测算子，C++算法实现
08-29
Canny边缘检测算子是计算机视觉领域中一种经典的边缘检测算法，由John F. Canny在1986年提出。这个算法以其高效性和准确性而著名，被广泛应用于图像处理和计算机视觉系统中。Canny边缘检测的目标是找出图像中的强度...
Canny多级边缘检测算法的C语言实现.doc
05-08
在上面的代码中，我们可以使用Canny边缘检测算法的实现代码来检测图像中的边缘。 Canny多级边缘检测算法的C语言实现需要完成图像读取和灰度化、高斯滤波和边缘检测三个步骤。通过使用OpenCV库和C语言，我们可以轻松...
canny边缘检测算法的matlab实现
11-02
以下是关于Canny边缘检测算法及其MATLAB实现的详细解释： 一、Canny边缘检测算法的基本步骤 1. **高斯滤波**：首先，对输入图像进行高斯滤波，目的是消除图像中的噪声，同时保持边缘信息不受影响。高斯滤波器具有...
Canny 边缘检测算法
绯雨千叶的博客
02-21 1710
Canny 边缘检测算法（学习笔记）
基于Canny算子的图像边缘检测与提取的算法.
09-15
基于的图像边缘检测与提取的算法.matlab
canny算子的使用
06-08
利用canny算子进行边缘检测，生成的边缘图可以是灰度图，也可以是彩色图。用户可以自行选择。
OpenCV边缘检测（三）——Canny边缘检测
m0_48748418的博客
04-13 250
双阈值检测：将像素分为强边缘、弱边缘和非边缘三类。强边缘像素是梯度值最大的像素，弱边缘像素是梯度值次大的像素，非边缘像素是梯度值较小的像素。如果一个像素的梯度值大于高阈值，则将其标记为强边缘像素；如果一个像素的梯度值小于低阈值，则将其标记为非边缘像素；如果一个像素的梯度值介于两个阈值之间，则将其标记为弱边缘像素。如果是，则保留该像素作为可能的边缘像素。Canny边缘检测具有较高的准确率和稳定性，能够检测到细节和噪声较少的边缘。边缘连接：将强边缘像素与其周围的弱边缘像素连接起来形成完整的边缘。
边缘检测（Canny算子）实现原理
小白学视觉
03-16 653
点击上方“小白学视觉”，选择加"星标"或“置顶” 重磅干货，第一时间送达当前，边缘检测算法在实际应用中越加广泛，技术趋势也是快速发展，热火朝天。很多朋友或多或少了解，需要实现各类功能，尤其是一些复杂的需求，实现更好的滤波、满足更佳的提取效果，一时半会儿无从下手。下面小编就带大家了解关于边缘检测算子的实现原理。由于边缘检测算子常用方法较多（Sobel算子，Kirsch算子，Laplacian算子，C...
边缘检测算子之Canny
Jacky_Ponder的博客
03-20 4792
1.1Canny算法简介 Canny 边缘检测算子是 JohnF. Canny 在 1986 年提出的一个多级边缘检测算子。Canny算法与简单的基于拉普拉斯算法的不同点之一是在Canny算法中，首先在x和y方向求一阶导数，然后组合为4个方向的导数。这些方向导数达到局部最大值的点就是组成边缘的候选点。 然而，Canny算法最重要的一个新特点是其试图将独立边的候选像素拼装成轮廓。轮廓的形成是对这
Canny边缘检测算法原理
梦沁清风
04-01 2824
2、Canny边缘检测算法原理         JohnCanny于1986年提出Canny算子，它与Marr（LoG）边缘检测方法类似，也属于是先平滑后求导数的方法。本节对根据上述的边缘检测过程对Canny检测算法的原理进行介绍。 2.1 对原始图像进行灰度化         Canny算法通常处理的图像为灰度图，因此如果摄像机获取的是彩色图像，那首先就得进行灰度化。对一幅彩色
Canny边缘检测算法原理及其VC实现详解(一)
Go Forward Forever!
09-14 1050
图象的边缘部分集中了图象的大部分信息，图象边缘的确定与提取对于整个图象场景的识别与理解是非常重要的，同时也是图象分割所依赖的重要特征，边缘检测主要是图象的灰度变化的度量、检测和定位，自从1959提出边缘检测以来，经过五十多年的发展，已有许多中不同的边缘检测方法。结论是：实现图像的边缘检测，就是要用离散化梯度逼近函数根据二维灰度矩阵梯度向量来寻找图像灰度矩阵的灰度跃变位置，然后在图像中将这些位置的点连起来就构成了所谓的图像边缘（图像边缘在这里是一个统称，包括了二维图像上的边缘、角点、纹理等基元图）。
Canny边缘检测算法实现和优化分析
weixin_39450742的博客
07-10 1333
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/10664478.html 侵删 　以前的博文大部分都写的非常详细，有很多分析过程，不过写起来确实很累人，一般一篇好的文章要整理个三四天，但是，时间越来越紧张，后续的一些算法可能就以随记的方式，把实现过程的一些比较容易出错和有价值的细节部分加以描述，并且可能需要对算法本身有一定了解的朋友才能明白我所描述的一些过程了。 　　那这个.
canny边缘检测算法原理
05-13
Canny边缘检测算法是一种经典的边缘检测算法，其基本原理如下： 1. 噪声抑制：使用高斯滤波器对图像进行平滑处理，以抑制噪声。 2. 梯度计算：使用Sobel算子计算图像中每个像素点的梯度大小和方向。 3. 非极大值抑制：对梯度图像进行处理，将非极大值点（即不是该方向上的局部最大值）的像素值设置为0，以保留边缘的细节信息。 4. 双阈值处理：将边缘像素分为强边缘和弱边缘两类，根据设定的高低阈值进行划分。高于高阈值的像素点被认定为强边缘，低于低阈值的像素点被排除，介于两者之间的像素点被认定为弱边缘。 5. 边缘连接：将弱边缘与其相邻的强边缘连接起来，形成一条完整的边缘。 Canny边缘检测算法的优点是能够检测出较细的边缘，而且对噪声比较稳健。它的缺点是计算量较大，对图像中的细节信息比较敏感，因此在实际应用中需要根据具体情况进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值