【图像变换之边缘检测】

---

前言

图像变换(image transfrom),将一幅图像转换成图像数据的另一种表现形式。变换最常见的例子就是傅里叶变换(Fourier transform),即将图像转换成源图像数据的另一种表示形式。

• 基于OpenCV的边缘检测
• 霍夫变换
• 重映射
• 放射变换
• 直方图均衡变化

---

基于OpenCV的边缘检测

步骤

1. 滤波
2. 增强
3. 检测

经过增强的图像，往往领域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是要找的边缘，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。

一、Canny边缘检测算子的步骤

1. 第一步，消除噪声
   一般情况下，使用高斯平滑滤波器卷积降噪。以下显示了一个size = 5的高斯内核示例：

2. 第二步，计算梯度幅值和方向
   此处，按照Sobel滤波器的步骤来操作。

①运用一对卷积阵列(分别作用于x和y方向)

② 使用下列公式计算梯度幅值和方向

而梯度方向一般取这4个可能的角度之一——0°，45°，90°，135°

3. 第三步，非极大值抑制
   这一步排除非边缘像素，仅仅保留了一些细线条(候选边缘)
4. 第四步，滞后阈值

Canny 边缘检测示例

#include<opencv2/opencv.hpp>
#include<string>
using namespace cv;

static void test()
{
	//载入原始图  
	Mat srcImage = imread("56_1.jpg");
	Mat srcImage1 = srcImage.clone();

	//显示原始图 
	imshow("【原始图】Canny边缘检测", srcImage);

	Mat dstImage, edge, grayImage;

	// 【1】创建与src同类型和大小的矩阵(dst)
	dstImage.create(srcImage1.size(), srcImage1.type());

	// 【2】将原图像转换为灰度图像
	cvtColor(srcImage1, grayImage, COLOR_BGR2GRAY);

	// 【3】先用使用 3x3内核来降噪
	blur(grayImage, edge, Size(3, 3));

	// 【4】运行Canny算子
	Canny(edge, edge, 3, 9, 3);

	//【5】将g_dstImage内的所有元素设置为0 
	dstImage = Scalar::all(0);

	//【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
	srcImage1.copyTo(dstImage, edge);

	//【7】显示效果图 
	imshow("【效果图】Canny边缘检测2", dstImage);

	waitKey(0);
}

int main()
{
	test();
	system("pause");
	return 0;
}

结果

二、sobel算子

Sobel算子是一个主要用于边缘检测的离散微分算子。它结合了高斯平滑和微分求导，用来计算图像灰度函数的近似梯度。

Sobel算子的计算过程

1. 分别在x和y两个方向求导

① 水平变化：将I与一个奇数大小的内核Gx进行卷积。比如，当内核大小为3时，Gx的计算结果为：

② 垂直变化：将I与一个奇数大小的内核进行卷积。比如，当内核大小为3时，计算结果为：

2. 在图像的每一点，结合以上两个结果求出近似梯度

Sobel算子的使用示例

#include<opencv2/opencv.hpp>
#include<string>
using namespace cv;

static void test()
{
	//【0】创建 grad_x 和 grad_y 矩阵
	Mat grad_x, grad_y;
	Mat abs_grad_x, abs_grad_y, dst;

	//【1】载入原始图  
	Mat src = imread("57_1.jpg");

	//【2】显示原始图 
	imshow("【原始图】sobel边缘检测", src);

	//【3】求 X方向梯度
	Sobel(src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT);
	convertScaleAbs(grad_x, abs_grad_x);
	imshow("【效果图】 X方向Sobel", abs_grad_x);

	//【4】求Y方向梯度
	Sobel(src, grad_y, CV_16S, 0, 1, 3, 1, 1, BORDER_DEFAULT);
	convertScaleAbs(grad_y, abs_grad_y);
	imshow("【效果图】Y方向Sobel", abs_grad_y);

	//【5】合并梯度(近似)
	addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dst);
	imshow("【效果图】整体方向Sobel", dst);
	waitKey(0);

}

int main()
{
	test();
	system("pause");
	return 0;
}

结果

三、Laplacian算子

Laplacian算子的定义：

Laplacian算子的使用示例

#include<opencv2/opencv.hpp>
#include<string>
using namespace cv;

static int test()
{
	//【0】变量的定义
	Mat src, src_gray, dst, abs_dst;

	//【1】载入原始图  
	src = imread("renwu1.jpg"); 

	//【2】显示原始图 
	imshow("【原始图】图像Laplace变换", src);

	//【3】使用高斯滤波消除噪声
	GaussianBlur(src, src, Size(3, 3), 0, 0, BORDER_DEFAULT);

	//【4】转换为灰度图
	cvtColor(src, src_gray, COLOR_RGB2GRAY);

	//【5】使用Laplace函数
	Laplacian(src_gray, dst, CV_16S,3, 1, 0, BORDER_DEFAULT);

	//【6】计算绝对值，并将结果转换成8位
	convertScaleAbs(dst, abs_dst);

	//【7】显示效果图
	imshow("【效果图】图像Laplace变换", abs_dst);

	waitKey(0);

	return 0;
}

int main()
{
	test();
	system("pause");
	return 0;
}

scharr滤波器

我们一般直接称scharr为滤波器，而不是算子。使用Scharr滤波器运算计算x或y方向的图像差分。其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小。

scharr代码示例

#include<opencv2/opencv.hpp>
#include<string>
using namespace cv;

static int test()
{
	//【0】创建 grad_x 和 grad_y 矩阵
	Mat grad_x, grad_y;
	Mat abs_grad_x, abs_grad_y, dst;

	//【1】载入原始图  
	Mat src = imread("59_1.jpg");

	//【2】显示原始图 
	imshow("【原始图】Scharr滤波器", src);

	//【3】求 X方向梯度
	Scharr(src, grad_x, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT);
	convertScaleAbs(grad_x, abs_grad_x);
	imshow("【效果图】 X方向Scharr", abs_grad_x);

	//【4】求Y方向梯度
	Scharr(src, grad_y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT);
	convertScaleAbs(grad_y, abs_grad_y);
	imshow("【效果图】Y方向Scharr", abs_grad_y);

	//【5】合并梯度(近似)
	addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dst);

	//【6】显示效果图
	imshow("【效果图】合并梯度后Scharr", dst);

	waitKey(0);
	return 0;
}

int main()
{
	test();
	system("pause");
	return 0;
}

边缘检测综合示例

#include<opencv2/opencv.hpp>
#include<string>
using namespace cv;

//原图，原图的灰度版，目标图
static Mat g_srcImage, g_srcGrayImage, g_dstImage;

//Canny边缘检测相关变量
static Mat g_cannyDetectedEdges;
static int g_cannyLowThreshold = 1;//TrackBar位置参数  

//Sobel边缘检测相关变量
static Mat g_sobelGradient_X, g_sobelGradient_Y;
static Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
static int g_sobelKernelSize = 1;//TrackBar位置参数  

//Scharr滤波器相关变量
static Mat g_scharrGradient_X, g_scharrGradient_Y;
static Mat g_scharrAbsGradient_X, g_scharrAbsGradient_Y;


static void on_Canny(int, void*);//Canny边缘检测窗口滚动条的回调函数
static void on_Sobel(int, void*);//Sobel边缘检测窗口滚动条的回调函数
void Scharr();                   //封装了Scharr边缘检测相关代码的函数



static int test()
{
	//改变console字体颜色
	system("color 2F");

	//载入原图
	g_srcImage = imread("60_1.jpg");
	if (!g_srcImage.data) { printf("Oh，no，读取srcImage错误~！ \n"); return false; }

	//显示原始图
	namedWindow("【原始图】");
	imshow("【原始图】", g_srcImage);

	// 创建与src同类型和大小的矩阵(dst)
	g_dstImage.create(g_srcImage.size(), g_srcImage.type());

	// 将原图像转换为灰度图像
	cvtColor(g_srcImage, g_srcGrayImage, COLOR_BGR2GRAY);

	// 创建显示窗口
	namedWindow("【效果图】Canny边缘检测", WINDOW_AUTOSIZE);
	namedWindow("【效果图】Sobel边缘检测", WINDOW_AUTOSIZE);

	// 创建trackbar
	createTrackbar("参数值：", "【效果图】Canny边缘检测", &g_cannyLowThreshold, 120, on_Canny);
	createTrackbar("参数值：", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel);

	// 调用回调函数
	on_Canny(0, 0);
	on_Sobel(0, 0);

	//调用封装了Scharr边缘检测代码的函数
	Scharr();

	//轮询获取按键信息，若按下Q，程序退出
	while ((char(waitKey(1)) != 'q')) {}

	return 0;
}


void on_Canny(int, void*)
{
	// 先使用 3x3内核来降噪
	blur(g_srcGrayImage, g_cannyDetectedEdges, Size(3, 3));

	// 运行我们的Canny算子
	Canny(g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold * 3, 3);

	//先将g_dstImage内的所有元素设置为0 
	g_dstImage = Scalar::all(0);

	//使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
	g_srcImage.copyTo(g_dstImage, g_cannyDetectedEdges);

	//显示效果图
	imshow("【效果图】Canny边缘检测", g_dstImage);
}


void on_Sobel(int, void*)
{
	// 求 X方向梯度
	Sobel(g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2 * g_sobelKernelSize + 1), 1, 1, BORDER_DEFAULT);
	convertScaleAbs(g_sobelGradient_X, g_sobelAbsGradient_X);//计算绝对值，并将结果转换成8位

	// 求Y方向梯度
	Sobel(g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2 * g_sobelKernelSize + 1), 1, 1, BORDER_DEFAULT);
	convertScaleAbs(g_sobelGradient_Y, g_sobelAbsGradient_Y);//计算绝对值，并将结果转换成8位

	// 合并梯度
	addWeighted(g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage);

	//显示效果图
	imshow("【效果图】Sobel边缘检测", g_dstImage);

}


void Scharr()
{
	// 求 X方向梯度
	Scharr(g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT);
	convertScaleAbs(g_scharrGradient_X, g_scharrAbsGradient_X);//计算绝对值，并将结果转换成8位

	// 求Y方向梯度
	Scharr(g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT);
	convertScaleAbs(g_scharrGradient_Y, g_scharrAbsGradient_Y);//计算绝对值，并将结果转换成8位

	// 合并梯度
	addWeighted(g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage);

	//显示效果图
	imshow("【效果图】Scharr滤波器", g_dstImage);
}


int main()
{
	test();
	system("pause");
	return 0;
}