OpenCV-基本边缘检测算子Sobel实现

简要描述

sobel算子主要用于获得数字图像的一阶梯度，常见的应用是边缘检测。

原理

算子使用两个3*3的矩阵（图1）算子使用两个3*3的矩阵（图1）去和原始图片作卷积，分别得到横向Ｇ（ｘ）和纵向Ｇ（ｙ）的梯度值，如果梯度值大于某一个阈值，则认为该点为边缘点

　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　图1：卷积矩阵

　　　　　　　　
　　　　　　　　　　　　 　　　　　　　　　　　　　　　图2：卷积运算　　

图像直接卷积实现Sobel：

//图像直接卷积实现Sobel
bool sobelEdge(const cv::Mat image, cv::Mat &result, uchar threshold)
{
	CV_Assert(image.channels() == 1);
	//初始化水平核因子
	cv::Mat sobelx = (cv::Mat_<float>(3, 3) << 1, 0, -1, 2, 0, -2, 1, 0, -1);
	//初始化垂直核因子
	cv::Mat sobely = (cv::Mat_<float>(3, 3) << 1, 2, 1, 0, 0, 0, -1, -2, -1);
	result = cv::Mat::zeros(image.rows - 2, image.cols - 2, image.type());
	double graMag = 0;
	for (int i = 1; i < image.rows - 1; i++)
	{
		for (int j = 1; j < image.cols - 1; j++)
		{
			float edgex = 0, edgey = 0;
			//遍历计算水平与垂直梯度
			for (int k = -1; k < 2; k++)
			{
				for (int p = -1; p < 2; p++)
				{
					edgex += (float)image.at<uchar>(k + i, p + j) * sobelx.at<float>(1 + k, 1 + p);
					edgey += (float)image.at<uchar>(k + i, p + j) * sobely.at<float>(1 + k, 1 + p);
				}
			}
			//计算梯度模长
			graMag = sqrt(pow(edgex, 2) + pow(edgey, 2));
			//二值化
			result.at<uchar>(i - 1, j - 1) = ((graMag > threshold) ? 255 : 0);
		}
	}
	return true;
}

运行结果：

非极大值抑制Sobel边缘实现：

//非极大值抑制实现Sobel竖直细化边缘
bool SobelVerEdge(cv::Mat image, cv::Mat &result)
{
	CV_Assert(image.channels() == 1);
	image.convertTo(image, CV_32FC1);
	//水平方向的Sobel算子
	cv::Mat sobelx = (cv::Mat_<float>(3, 3) << -0.125, 0, 0.125, -0.25, 0, 0.25, -0.125, 0, 0.125);
	//卷积操作
	cv::Mat ConResMat;
	cv::filter2D(image, ConResMat, image.type(), sobelx);
	//计算梯度的幅度
	cv::Mat graMagMat;
	cv::multiply(ConResMat, ConResMat, graMagMat);
	//根据梯度幅度及参数设置阈值(mean获取各个通道的均值)
	int scaleVal = 4;
	double thresh = scaleVal * cv::mean(graMagMat).val[0];
	cv::Mat resulttempMat = cv::Mat::zeros(graMagMat.size(), graMagMat.type());
	float *pDataMag = (float*)graMagMat.data;
	float *pDataRes = (float*)resulttempMat.data;
	const int rows = ConResMat.rows, cols = ConResMat.cols;
	for (int i = 1; i != rows - 1; i++)
	{
		for (int j = 1; j != cols - 1; j++)
		{
			//计算该点梯度与水平或垂直梯度值的大小并比较结果
			bool b1 = (pDataMag[i * cols + j] > pDataMag[i * cols + j - 1]);
			bool b2 = (pDataMag[i * cols + j] > pDataMag[i * cols + j + 1]);
			bool b3 = (pDataMag[i * cols + j] > pDataMag[(i - 1) * cols + j]);
			bool b4 = (pDataMag[i * cols + j] > pDataMag[(i - 1) * cols + j]);
			//判断邻域梯度是否满足大于水平或垂直的条件
			//并根据自适应阈值参数进行二值化
			pDataRes[i * cols + j] = 255 * ((pDataMag[i * cols + j] > thresh) && ((b1 && b2) || (b3 && b4)));
		}
	}
	resulttempMat.convertTo(resulttempMat, CV_8UC1);
	result = resulttempMat.clone();
	return true;
}

运行结果：

在OpenCV中，sobel算子在C++中的函数原型如下： 

void Sobel(InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) 

InputArray src：输入的原图像，Mat类型 
OutputArray dst：输出的边缘检测结果图像，Mat型，大小与原图像相同。 
int ddepth：输出图像的深度，针对不同的输入图像，输出目标图像有不同的深度，具体组合如下： 
- 若src.depth() = CV_8U, 取ddepth =-1/CV_16S/CV_32F/CV_64F 
- 若src.depth() = CV_16U/CV_16S, 取ddepth =-1/CV_32F/CV_64F 
- 若src.depth() = CV_32F, 取ddepth =-1/CV_32F/CV_64F 
- 若src.depth() = CV_64F, 取ddepth = -1/CV_64F 
注：ddepth =-1时，代表输出图像与输入图像相同的深度。 
int dx：int类型dx，x 方向上的差分阶数，1或0 
int dy：int类型dy，y 方向上的差分阶数，1或0 
其中，dx=1，dy=0，表示计算X方向的导数，检测出的是垂直方向上的边缘；dx=0，dy=1，表示计算Y方向的导数，检测出的是水平方向上的边缘。 
int ksize：为进行边缘检测时的模板大小为ksize*ksize，取值为1、3、5和7，其中默认值为3。

代码实现：

int main()
{
	cv::Mat image = cv::imread("1.jpg", 0);
	if (image.empty()) return -1;
	cv::imshow("image", image);
	cv::Mat edgeMat, edgexMat, edgeyMat;
	//求x方向Sobel边缘
	cv::Sobel(image, edgexMat, CV_16S, 1, 0, 3, 1, 0, cv::BORDER_DEFAULT);
	//求y方向Sobel边缘
	cv::Sobel(image, edgeyMat, CV_16S, 0, 1, 3, 1, 0, cv::BORDER_DEFAULT);
	//线性变换，转换输入数组元素为8位无符号整形
	cv::convertScaleAbs(edgexMat, edgexMat);
	cv::convertScaleAbs(edgeyMat, edgeyMat);
	//x与y方向边缘叠加
	cv::addWeighted(edgexMat, 0.5, edgeyMat, 0.5, 0, edgeMat);
	cv::imshow("edgeMat", edgeMat);
	cv::waitKey(0);
	return 0;
}

运行结果：