《Opencv3编程入门》学习笔记
记录一下在学习《Opencv3编程入门》这本书时遇到的问题或重要的知识点。
第七章 图像变换
图像变换：即将一幅图像转变成图像数据的另一种表现形式。
一、基于OpenCV的边缘检测
OpenCV中边缘检测的各种算子和滤波器：Canny算子、Sobel算子、Laplacian算子、Scharr滤波器
（一）边缘检测的一般步骤
【第一步：滤波】
边缘检测的算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此必须采用滤波器来改善与噪声有关的边缘检测器的性能。常见的滤波方法主要有高斯滤波，即采用离散化的高斯函数产生一组归一化的高斯核，然后基于高斯核函数对图像灰度矩阵的每一点进行加权求和。
【第二步：增强】
增强边缘的基础是确定图像各点邻域强度的变化值。增强算法可以将图像灰度点邻域强度值有显著变化的点凸显出来。在具体编程实现时，可通过计算梯度幅值来确定。
【第三步：检测】
经过增强的图像，往往邻域中有很多点的梯度值比较大，而在特定的应用中，这些点并不是我们要找的边缘点，所以应该采用某种方法来对这些点进行取舍。实际工程中，常用的方法是通过阈值化方法来检测。
另外，需要注意，下文中讲到的Laplace算子，sobel算子和Scharr算子都是带方向的，所以，示例中我们分别写了X方向,Y方向和最终合成的的效果图。
（二）canny算子
1、canny算子简介
Canny 的目标是找到一个最优的边缘检测算法，让我们看一下最优边缘检测的三个主要评价标准:
- 低错误率: 标识出尽可能多的实际边缘，同时尽可能的减少噪声产生的误报。
- 高定位性: 标识出的边缘要与图像中的实际边缘尽可能接近。
- 最小响应: 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。
为了满足这些要求 Canny 使用了变分法，这是一种寻找满足特定功能的函数的方法。最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
2、Canny边缘检测的步骤
【1】消除噪声
一般情况下，使用高斯平滑滤波器卷积降噪。 如下显示了一个 size = 5 的高斯内核示例:
【2】计算梯度幅值和方向
此处，按照Sobel滤波器的步骤。
Ⅰ.运用一对卷积阵列 (分别作用于 x 和 y 方向)
Ⅱ.使用下列公式计算梯度幅值和方向
梯度方向近似到四个可能角度之一(一般为0, 45, 90, 135)
【3】非极大值抑制
这一步排除非边缘像素，仅仅保留了一些细线条(候选边缘)。
【4】滞后阈值
最后一步，Canny 使用了滞后阈值，滞后阈值需要两个阈值(高阈值和低阈值):
Ⅰ.如果某一像素位置的幅值超过 高 阈值, 该像素被保留为边缘像素。
Ⅱ.如果某一像素位置的幅值小于 低 阈值, 该像素被排除。
Ⅲ.如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于 高 阈值的像素时被保留。
3、Canny边缘检测：Canny()函数
Canny函数利用Canny算法来进行图像的边缘检测。
void Canny(InputArray image,OutputArray edges, double threshold1, double threshold2, int apertureSize=3,bool L2gradient=false)
- 第一个参数，InputArray类型的image，输入图像，即源图像，填Mat类的对象即可，且需为单通道8位图像。
- 第二个参数，OutputArray类型的edges，输出的边缘图，需要和源图片有一样的尺寸和类型。
- 第三个参数，double类型的threshold1，第一个滞后性阈值。
- 第四个参数，double类型的threshold2，第二个滞后性阈值。
- 第五个参数，int类型的apertureSize，表示应用Sobel算子的孔径大小，其有默认值3。
- 第六个参数，bool类型的L2gradient，一个计算图像梯度幅值的标识，有默认值false。
需要注意的是，这个函数阈值1和阈值2两者的小者用于边缘连接，而大者用来控制强边缘的初始段，推荐的高低阈值比在2:1到3:1之间。
//载入原始图
Mat src = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Canny(src, src, 3, 9,3 );
imshow("【效果图】Canny边缘检测", src);
4、示例程序：Canny边缘检测
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//载入原始图
Mat src = imread("D://lili/Desktop/jpg/opencv/6.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat src1=src.clone();
//显示原始图
imshow("【原始图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 一、最简单的canny用法，拿到原图后直接用。
//----------------------------------------------------------------------------------
Canny( src, src, 150, 100,3 );
imshow("【效果图】Canny边缘检测", src);
//----------------------------------------------------------------------------------
// 二、高阶的canny用法，转成灰度图，降噪，用canny，最后将得到的边缘作为掩码，拷贝原图到效果图上，得到彩色的边缘图
//----------------------------------------------------------------------------------
Mat dst,edge,gray;
// 【1】创建与src同类型和大小的矩阵(dst)
dst.create( src1.size(), src1.type() );
// 【2】将原图像转换为灰度图像
cvtColor( src1, gray, CV_BGR2GRAY );
// 【3】先用使用 3x3内核来降噪
blur( gray, edge, Size(3,3) );
// 【4】运行Canny算子
Canny( edge, edge, 3, 9,3 );
//【5】将g_dstImage内的所有元素设置为0
dst = Scalar::all(0);
//【6】使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码，来将原图g_srcImage拷到目标图g_dstImage中
src1.copyTo( dst, edge);
//【7】显示效果图
imshow("【效果图】Canny边缘检测2", dst);
waitKey(0);
return 0;
}
运行效果
（三）sobel算子
1、sobel算子的基本概念
Sobel 算子是一个主要用作边缘检测的离散微分算子 (discrete differentiation operator)。 Sobel算子结合了高斯平滑和微分求导，用来计算图像灰度函数的近似梯度。在图像的任何一点使用此算子，将会产生对应的梯度矢量或是其法矢量。
2、sobel算子的计算过程
我们假设被作用图像为 I，然后进行如下的操作：
（1）分别在x和y两个方向求导。
Ⅰ.水平变化: 将 I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时, 
的计算结果为:
Ⅱ.垂直变化: 将: I 与一个奇数大小的内核
进行卷积。比如，当内核大小为3时, 
的计算结果为:
2.在图像的每一点，结合以上两个结果求出近似梯度:
另外有时，也可用下面更简单公式代替:
3、使用Sobel算子：Sobel()函数
Sobel函数使用扩展的 Sobel 算子，来计算一阶、二阶、三阶或混合图像差分。
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 );
（1）第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
（2）第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
（3）第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和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
（4）第四个参数，int类型dx，x 方向上的差分阶数。
（5）第五个参数，int类型dy，y方向上的差分阶数。
（6）第六个参数，int类型ksize，有默认值3，表示Sobel核的大小;必须取1，3，5或7。
（7）第七个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
（8）第八个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
（9）第九个参数， int类型的borderType，我们的老朋友了（万年是最后一个参数），边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate处得到更详细的信息。
一般情况下，都是用ksize x ksize内核来计算导数的。然而，有一种特殊情况——当ksize为1时，往往会使用3 x 1或者1 x 3的内核。且这种情况下，并没有进行高斯平滑操作。
补充说明：
（1）当内核大小为 3 时, 我们的Sobel内核可能产生比较明显的误差(毕竟，Sobel算子只是求取了导数的近似值而已)。 为解决这一问题，OpenCV提供了Scharr 函数，但该函数仅作用于大小为3的内核。该函数的运算与Sobel函数一样快，但结果却更加精确，其内核是这样的:
（2）因为Sobel算子结合了高斯平滑和分化（differentiation），因此结果会具有更多的抗噪性。大多数情况下，我们使用sobel函数时，取【xorder = 1，yorder = 0，ksize = 3】来计算图像X方向的导数，【xorder = 0，yorder = 1，ksize = 3】来计算图像y方向的导数。
计算图像X方向的导数，取【xorder= 1，yorder = 0，ksize = 3】情况对应的内核：
而计算图像Y方向的导数，取【xorder= 0，yorder = 1，ksize = 3】对应的内核：
4、示例程序：Sobel算子的使用
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("D://lili/Desktop/jpg/opencv/7.jpg"); //工程目录下应该有一张名为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);
return 0;
}
运行效果
（四）Laplacian算子
1、Laplacian算子简介
Laplacian 算子是n维欧几里德空间中的一个二阶微分算子，定义为梯度grad()的散度div()。因此如果f是二阶可微的实函数，则f的拉普拉斯算子定义为：
(1) f的拉普拉斯算子也是笛卡儿坐标系xi中的所有非混合二阶偏导数求和：
(2) 作为一个二阶微分算子，拉普拉斯算子把C函数映射到C函数，对于k ≥ 2。表达式(1)（或(2)）定义了一个算子Δ :C® → C®，或更一般地，定义了一个算子Δ : C(Ω) → C(Ω)，对于任何开集Ω。
根据图像处理的原理我们知道，二阶导数可以用来进行检测边缘 。 因为图像是 “二维”, 我们需要在两个方向进行求导。使用Laplacian算子将会使求导过程变得简单。
Laplacian 算子的定义：
由于 Laplacian使用了图像梯度，它内部的代码其实是调用了 Sobel 算子的。
2、计算拉普拉斯变换：Laplacian()函数
Laplacian函数可以计算出图像经过拉普拉斯变换后的结果。
void Laplacian(InputArray src,OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, intborderType=BORDER_DEFAULT );
- 第一个参数，InputArray类型的image，输入图像，即源图像，填Mat类的对象即可，且需为单通道8位图像。
- 第二个参数，OutputArray类型的edges，输出的边缘图，需要和源图片有一样的尺寸和通道数。
- 第三个参数，int类型的ddept，目标图像的深度。
- 第四个参数，int类型的ksize，用于计算二阶导数的滤波器的孔径尺寸，大小必须为正奇数，且有默认值1。
- 第五个参数，double类型的scale，计算拉普拉斯值的时候可选的比例因子，有默认值1。
- 第六个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
- 第七个参数， int类型的borderType，边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate()处得到更详细的信息。
Laplacian( )函数其实主要是利用sobel算子的运算。它通过加上sobel算子运算出的图像x方向和y方向上的导数，来得到我们载入图像的拉普拉斯变换结果。
其中，sobel算子（ksize>1）如下：
而当ksize=1时，Laplacian()函数采用以下3x3的孔径：
3、示例程序：Laplacian算子的使用
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】变量的定义
Mat src,src_gray,dst, abs_dst;
//【1】载入原始图
src = imread("D://lili/Desktop/jpg/opencv/7.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//【2】显示原始图
imshow("【原始图】图像Laplace变换", src);
//【3】使用高斯滤波消除噪声
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
//【4】转换为灰度图
cvtColor( src, src_gray, CV_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;
}
运行效果
（五）scharr滤波器
Scharr()函数在OpenCV中主要是配合Sobel算子的运算而存在的。
1、计算图像差分：Scharr()函数
用Scharr滤波器运算符计算x或y方向的图像差分。其实它的参数变量和Sobel基本上是一样的，除了没有ksize核的大小。
void Scharr(
InputArray src, //源图
OutputArray dst, //目标图
int ddepth,//图像深度
int dx,// x方向上的差分阶数
int dy,//y方向上的差分阶数
double scale=1,//缩放因子
double delta=0,// delta值
intborderType=BORDER_DEFAULT )// 边界模式
（1）第一个参数，InputArray 类型的src，为输入图像，填Mat类型即可。
（2）第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。
（3）第三个参数，int类型的ddepth，输出图像的深度，支持如下src.depth()和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
（4）第四个参数，int类型dx，x方向上的差分阶数。
（5）第五个参数，int类型dy，y方向上的差分阶数。
（6）第六个参数，double类型的scale，计算导数值时可选的缩放因子，默认值是1，表示默认情况下是没有应用缩放的。我们可以在文档中查阅getDerivKernels的相关介绍，来得到这个参数的更多信息。
（7）第七个参数，double类型的delta，表示在结果存入目标图（第二个参数dst）之前可选的delta值，有默认值0。
（8）第八个参数， int类型的borderType，我们的老朋友了（万年是最后一个参数），边界模式，默认值为BORDER_DEFAULT。这个参数可以在官方文档中borderInterpolate处得到更详细的信息。
不难理解，如下两者是等价的：
Scharr(src, dst, ddepth, dx, dy, scale,delta, borderType);
与
Sobel(src, dst, ddepth, dx, dy, CV_SCHARR,scale, delta, borderType);
2、示例程序：Scharr滤波器
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】创建 grad_x 和 grad_y 矩阵
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y,dst;
//【1】载入原始图
Mat src = imread("D://lili/Desktop/jpg/opencv/7.jpg"); //工程目录下应该有一张名为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;
}
运行效果
（六）综合示例：边缘检测
示例代码
//-----------------------------------【程序说明】----------------------------------------------
// 程序名称:：《【OpenCV入门教程之十二】OpenCV边缘检测：Canny算子,Sobel算子,Laplace算子,Scharr滤波器合辑合辑》
// 开发所用IDE版本：Visual Studio 2010
// 开发所用OpenCV版本： 2.4.9
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【全局变量声明部分】--------------------------------------
// 描述：全局变量声明
//-----------------------------------------------------------------------------------------------
//原图，原图的灰度版，目标图
Mat g_srcImage, g_srcGrayImage,g_dstImage;
//Canny边缘检测相关变量
Mat g_cannyDetectedEdges;
int g_cannyLowThreshold=1;//TrackBar位置参数
//Sobel边缘检测相关变量
Mat g_sobelGradient_X, g_sobelGradient_Y;
Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
int g_sobelKernelSize=1;//TrackBar位置参数
//Scharr滤波器相关变量
Mat g_scharrGradient_X, g_scharrGradient_Y;
Mat g_scharrAbsGradient_X, g_scharrAbsGradient_Y;
//-----------------------------------【全局函数声明部分】--------------------------------------
// 描述：全局函数声明
//-----------------------------------------------------------------------------------------------
static void ShowHelpText( );
static void on_Canny(int, void*);//Canny边缘检测窗口滚动条的回调函数
static void on_Sobel(int, void*);//Sobel边缘检测窗口滚动条的回调函数
void Scharr( );//封装了Scharr边缘检测相关代码的函数
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( int argc, char** argv )
{
//改变console字体颜色
system("color 2F");
//显示欢迎语
ShowHelpText();
//载入原图
g_srcImage = imread("D://lili/Desktop/jpg/opencv/7.jpg");
if( !g_srcImage.data ) { printf("读取srcImage错误！ \n"); return false; }
//显示原始图
namedWindow("【原始图】");
imshow("【原始图】", g_srcImage);
//创建与src同类型和大小的矩阵(dst)
g_dstImage.create(g_srcImage.size(), g_srcImage.type());
// 将原图像转换为灰度图像
cvtColor( g_srcImage, g_srcGrayImage, CV_BGR2GRAY );
// 创建显示窗口
namedWindow( "【效果图】Canny边缘检测", CV_WINDOW_AUTOSIZE );
namedWindow( "【效果图】Sobel边缘检测", CV_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;
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf( "\n\n\t嗯。运行成功，请调整滚动条观察图像效果~\n\n"
"\t按下“q”键时，程序退出~!\n"
"\n\n\t\t\t\t by浅墨" );
}
//-----------------------------------【on_Canny( )函数】----------------------------------
// 描述：Canny边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------------
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 );
}
//-----------------------------------【on_Sobel( )函数】----------------------------------
// 描述：Sobel边缘检测窗口滚动条的回调函数
//-----------------------------------------------------------------------------------------
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);
}
//-----------------------------------【Scharr( )函数】----------------------------------
// 描述：封装了Scharr边缘检测相关代码的函数
//-----------------------------------------------------------------------------------------
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);
}
运行效果
二、霍夫变换
- 在图像处理和计算机视觉领域中，如何从当前的图像中提取所需要的特征信息是图像识别的关键所在。
- 在许多应用场合中需要快速准确地检测出直线或者圆。其中一种非常有效的解决问题的方法是霍夫（Hough）变换，其为图像处理中从图像中识别几何形状的基本方法之一，应用很广泛，也有很多改进算法。
- 最基本的霍夫变换是从黑白图像中检测直线(线段)。
（一）霍夫变换概述
-
霍夫变换(Hough Transform)是图像处理中的一种特征提取技术，该过程在一个参数空间中通过计算累计结果的局部最大值得到一个符合该特定形状的集合作为霍夫变换结果。
-
霍夫变换于1962年由PaulHough首次提出，最初的Hough变换是设计用来检测直线和曲线，起初的方法要求知道物体边界线的解析方程，但不需要有关区域位置的先验知识。这种方法的一个突出优点是分割结果的Robustness,即对数据的不完全或噪声不是非常敏感。然而，要获得描述边界的解析表达常常是不可能的。后于1972年由Richard Duda & Peter Hart推广使用，经典霍夫变换用来检测图像中的直线，后来霍夫变换扩展到任意形状物体的识别，多为圆和椭圆。霍夫变换运用两个坐标空间之间的变换将在一个空间中具有相同形状的曲线或直线映射到另一个坐标空间的一个点上形成峰值，从而把检测任意形状的问题转化为统计峰值问题。
霍夫变换在OpenCV中分为霍夫线变换和霍夫圆变换两种。
（二）OpenCV中的霍夫线变换
我们知道，霍夫线变换是一种用来寻找直线的方法. 在使用霍夫线变换之前, 首先要对图像进行边缘检测的处理，也即霍夫线变换的直接输入只能是边缘二值图像。
OpenCV支持三种不同的霍夫线变换，它们分别是：标准霍夫变换(Standard Hough Transform，SHT)和多尺度霍夫变换（Multi-Scale Hough Transform，MSHT）和累计概率霍夫变换(Progressive Probabilistic Hough Transform ，PPHT)。
其中，多尺度霍夫变换（MSHT）为经典霍夫变换（SHT）在多尺度下的一个变种。累计概率霍夫变换(PPHT）算法是标准霍夫变换（SHT）算法的一个改进，它在一定的范围内进行霍夫变换，计算单独线段的方向以及范围，从而减少计算量，缩短计算时间。之所以称PPHT为“概率”的，是因为并不将累加器平面内的所有可能的点累加，而只是累加其中的一部分，该想法是如果峰值如果足够高，只用一小部分时间去寻找它就够了。这样猜想的话，可以实质性地减少计算时间。
在OpenCV中，我们可以用HoughLines函数来调用标准霍夫变换SHT和多尺度霍夫变换MSHT。
而HoughLinesP函数用于调用累计概率霍夫变换PPHT。累计概率霍夫变换执行效率很高，所有相比于HoughLines函数，我们更倾向于使用HoughLinesP函数。
OpenCV中的霍夫线变换有如下三种：
- 标准霍夫变换（StandardHough Transform，SHT），由HoughLines函数调用。
- 多尺度霍夫变换（Multi-ScaleHough Transform，MSHT），由HoughLines函数调用。
- 累计概率霍夫变换（ProgressiveProbabilistic Hough Transform，PPHT），由HoughLinesP函数调用。
（三）霍夫线变换的原理（太复杂了看不懂）
1、众所周知, 一条直线在图像二维空间可由两个变量表示. 如:
（1）在笛卡尔坐标系: 可由参数斜率和截距(m,b) 表示。
（2）在极坐标系: 可由参数极径和极角
表示。
对于霍夫变换, 我们将采用第二种方式极坐标系来表示直线. 因此, 直线的表达式可为:
化简便可得到:
2、一般来说对于点(x0,y0), 我们可以将通过这个点的一族直线统一定义为:
这就意味着每一对
代表一条通过点(x0,y0)的直线。
3、如果对于一个给定点(x0,y0)我们在极坐标对极径极角平面绘出所有通过它的直线, 将得到一条正弦曲线. 例如, 对于给定点X_0= 8 和Y_0= 6 我们可以绘出下图 (在平面):
只绘出满足下列条件的点 
和
。
4、我们可以对图像中所有的点进行上述操作.。如果两个不同点进行上述操作后得到的曲线在平面
相交, 这就意味着它们通过同一条直线. 例如,接上面的例子我们继续对点x1=9,y1=4和点 x2=12,y2=3绘图, 得到下图:
这三条曲线在平面相交于点 (0.925, 9.6), 坐标表示的是参数对或者是说点(x0,y0), 点(x1,y1)和点(x2,y2)组成的平面内的的直线。
5、以上的说明表明，一般来说, 一条直线能够通过在平面寻找交于一点的曲线数量来检测。而越多曲线交于一点也就意味着这个交点表示的直线由更多的点组成. 一般来说我们可以通过设置直线上点的阈值来定义多少条曲线交于一点我们才认为检测到了一条直线。
6、这就是霍夫线变换要做的. 它追踪图像中每个点对应曲线间的交点. 如果交于一点的曲线的数量超过了阈值, 那么可以认为这个交点所代表的参数对
nn在原图像中为一条直线。
（四）标准霍夫变换：HoughLines()函数
此函数可以找出采用标准霍夫变换的二值图像线条。在OpenCV中，我们可以用其来调用标准霍夫变换SHT和多尺度霍夫变换MSHT的OpenCV内建算法。
void HoughLines(InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 )
- 第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的单通道二进制图像，可以将任意的源图载入进来后由函数修改成此格式后，再填在这里。
- 第二个参数，InputArray类型的lines，经过调用HoughLines函数后储存了霍夫线变换检测到线条的输出矢量。每一条线由具有两个元素的矢量表示，其中，是离坐标原点((0,0)（也就是图像的左上角）的距离。 是弧度线条旋转角度（0垂直线，π/2水平线）。
- 第三个参数，double类型的rho，以像素为单位的距离精度。另一种形容方式是直线搜索时的进步尺寸的单位半径。PS:Latex中/rho就表示 。
- 第四个参数，double类型的theta，以弧度为单位的角度精度。另一种形容方式是直线搜索时的进步尺寸的单位角度。
- 第五个参数，int类型的threshold，累加平面的阈值参数，即识别某部分为图中的一条直线时它在累加平面中必须达到的值。大于阈值threshold的线段才可以被检测通过并返回到结果中。
- 第六个参数，double类型的srn，有默认值0。对于多尺度的霍夫变换，这是第三个参数进步尺寸rho的除数距离。粗略的累加器进步尺寸直接是第三个参数rho，而精确的累加器进步尺寸为rho/srn。
- 第七个参数，double类型的stn，有默认值0，对于多尺度霍夫变换，srn表示第四个参数进步尺寸的单位角度theta的除数距离。且如果srn和stn同时为0，就表示使用经典的霍夫变换。否则，这两个参数应该都为正数。
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【1】载入原始图和Mat变量定义
Mat srcImage = imread("D://lili/Desktop/jpg/opencv/6.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat midImage,dstImage;//临时变量和目标图的定义
//【2】进行边缘检测和转化为灰度图
Canny(srcImage, midImage, 50, 200, 3);//进行一此canny边缘检测
cvtColor(midImage,dstImage, CV_GRAY2BGR);//转化边缘检测后的图为灰度图
//【3】进行霍夫线变换
vector<Vec2f> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
HoughLines(midImage, lines, 1, CV_PI/180, 150, 0, 0 );
//【4】依次在图中绘制出每条线段
for( size_t i = 0; i < lines.size(); i++ )
{
float rho = lines[i][0], theta = lines[i][1];
Point pt1, pt2;
double a = cos(theta), b = sin(theta);
double x0 = a*rho, y0 = b*rho;
pt1.x = cvRound(x0 + 1000*(-b));
pt1.y = cvRound(y0 + 1000*(a));
pt2.x = cvRound(x0 - 1000*(-b));
pt2.y = cvRound(y0 - 1000*(a));
line( dstImage, pt1, pt2, Scalar(55,100,195), 1, CV_AA);
}
//【5】显示原始图
imshow("【原始图】", srcImage);
//【6】边缘检测后的图
imshow("【边缘检测后的图】", midImage);
//【7】显示效果图
imshow("【效果图】", dstImage);
waitKey(0);
return 0;
}
运行效果
（五）累计概率霍夫变换：HoughLinesP( )函数
此函数在HoughLines的基础上末尾加了一个代表Probabilistic（概率）的P，表明它可以采用累计概率霍夫变换（PPHT）来找出二值图像中的直线。
void HoughLinesP(InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 )
- 第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的单通道二进制图像，可以将任意的源图载入进来后由函数修改成此格式后，再填在这里。
- 第二个参数，InputArray类型的lines，经过调用HoughLinesP函数后后存储了检测到的线条的输出矢量，每一条线由具有四个元素的矢量(x_1,y_1, x_2, y_2） 表示，其中，(x_1, y_1)和(x_2, y_2) 是是每个检测到的线段的结束点。
- 第三个参数，double类型的rho，以像素为单位的距离精度。另一种形容方式是直线搜索时的进步尺寸的单位半径。
- 第四个参数，double类型的theta，以弧度为单位的角度精度。另一种形容方式是直线搜索时的进步尺寸的单位角度。
- 第五个参数，int类型的threshold，累加平面的阈值参数，即识别某部分为图中的一条直线时它在累加平面中必须达到的值。大于阈值threshold的线段才可以被检测通过并返回到结果中。
- 第六个参数，double类型的minLineLength，有默认值0，表示最低线段的长度，比这个设定参数短的线段就不能被显现出来。
- 第七个参数，double类型的maxLineGap，有默认值0，允许将同一行点与点之间连接起来的最大的距离。
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【1】载入原始图和Mat变量定义
Mat srcImage = imread("D://lili/Desktop/jpg/opencv/8.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat midImage,dstImage;//临时变量和目标图的定义
//【2】进行边缘检测和转化为灰度图
Canny(srcImage, midImage, 50, 200, 3);//进行一此canny边缘检测
cvtColor(midImage,dstImage, CV_GRAY2BGR);//转化边缘检测后的图为灰度图
//【3】进行霍夫线变换
vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
HoughLinesP(midImage, lines, 1, CV_PI/180, 80, 50, 10 );
//【4】依次在图中绘制出每条线段
for( size_t i = 0; i < lines.size(); i++ )
{
Vec4i l = lines[i];
line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(186,88,255), 1, CV_AA);
}
//【5】显示原始图
imshow("【原始图】", srcImage);
//【6】边缘检测后的图
imshow("【边缘检测后的图】", midImage);
//【7】显示效果图
imshow("【效果图】", dstImage);
waitKey(0);
return 0;
}
运行效果
（六）霍夫圆变换
霍夫圆变换的基本原理和上面讲的霍夫线变化大体上是很类似的，只是点对应的二维极径极角空间被三维的圆心点x, y还有半径r空间取代。说“大体上类似”的原因是，如果完全用相同的方法的话，累加平面会被三维的累加容器所代替：在这三维中，一维是x，一维是y，另外一维是圆的半径r。这就意味着需要大量的内存而且执行效率会很低，速度会很慢。
对直线来说, 一条直线能由参数极径极角
表示. 而对圆来说, 我们需要三个参数来表示一个圆, 也就是：
这里的 表示圆心的位置 (下图中的绿点) 而 r 表示半径, 这样我们就能唯一的定义一个圆了, 见下图:
在OpenCV中，我们一般通过一个叫做“霍夫梯度法”的方法来解决圆变换的问题。
（七）霍夫梯度法的原理
霍夫梯度法的原理是这样的。
（1）首先对图像应用边缘检测，比如用canny边缘检测。
（2）然后，对边缘图像中的每一个非零点，考虑其局部梯度，即用Sobel()函数计算x和y方向的Sobel一阶导数得到梯度。
（3）利用得到的梯度，由斜率指定的直线上的每一个点都在累加器中被累加，这里的斜率是从一个指定的最小值到指定的最大值的距离。
（4）同时，标记边缘图像中每一个非0像素的位置。
（5）然后从二维累加器中这些点中选择候选的中心，这些中心都大于给定阈值并且大于其所有近邻。这些候选的中心按照累加值降序排列，以便于最支持像素的中心首先出现。
（6）接下来对每一个中心，考虑所有的非0像素。
（7）这些像素按照其与中心的距离排序。从到最大半径的最小距离算起，选择非0像素最支持的一条半径。
（8）如果一个中心收到边缘图像非0像素最充分的支持，并且到前期被选择的中心有足够的距离，那么它就会被保留下来。
这个实现可以使算法执行起来更高效，或许更加重要的是，能够帮助解决三维累加器中会产生许多噪声并且使得结果不稳定的稀疏分布问题。
（八）霍夫梯度法的缺点
（1）在霍夫梯度法中，我们使用Sobel导数来计算局部梯度，那么随之而来的假设是，其可以视作等同于一条局部切线，并这个不是一个数值稳定的做法。在大多数情况下，这样做会得到正确的结果，但或许会在输出中产生一些噪声。
（2）在边缘图像中的整个非0像素集被看做每个中心的候选部分。因此，如果把累加器的阈值设置偏低，算法将要消耗比较长的时间。第三，因为每一个中心只选择一个圆，如果有同心圆，就只能选择其中的一个。
（3）因为中心是按照其关联的累加器值的升序排列的，并且如果新的中心过于接近之前已经接受的中心的话，就不会被保留下来。且当有许多同心圆或者是近似的同心圆时，霍夫梯度法的倾向是保留最大的一个圆。可以说这是一种比较极端的做法，因为在这里默认Sobel导数会产生噪声，若是对于无穷分辨率的平滑图像而言的话，这才是必须的。
（九）霍夫圆变换：HoughCircles( )函数
HoughCircles函数可以利用霍夫变换算法检测出灰度图中的圆。它和之前的HoughLines和HoughLinesP比较明显的一个区别是它不需要源图是二值的，而HoughLines和HoughLinesP都需要源图为二值图像。
void HoughCircles(InputArray image,OutputArray circles, int method, double dp, double minDist, double param1=100,double param2=100, int minRadius=0, int maxRadius=0 )
第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的灰度单通道图像。
第二个参数，InputArray类型的circles，经过调用HoughCircles函数后此参数存储了检测到的圆的输出矢量，每个矢量由包含了3个元素的浮点矢量(x, y, radius)表示。
第三个参数，int类型的method，即使用的检测方法，目前OpenCV中就霍夫梯度法一种可以使用，它的标识符为CV_HOUGH_GRADIENT，在此参数处填这个标识符即可。
第四个参数，double类型的dp，用来检测圆心的累加器图像的分辨率于输入图像之比的倒数，且此参数允许创建一个比输入图像分辨率低的累加器。上述文字不好理解的话，来看例子吧。例如，如果dp= 1时，累加器和输入图像具有相同的分辨率。如果dp=2，累加器便有输入图像一半那么大的宽度和高度。
第五个参数，double类型的minDist，为霍夫变换检测到的圆的圆心之间的最小距离，即让我们的算法能明显区分的两个不同圆之间的最小距离。这个参数如果太小的话，多个相邻的圆可能被错误地检测成了一个重合的圆。反之，这个参数设置太大的话，某些圆就不能被检测出来了。
第六个参数，double类型的param1，有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示传递给canny边缘检测算子的高阈值，而低阈值为高阈值的一半。
第七个参数，double类型的param2，也有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示在检测阶段圆心的累加器阈值。它越小的话，就可以检测到更多根本不存在的圆，而它越大的话，能通过检测的圆就更加接近完美的圆形了。
第八个参数，int类型的minRadius,有默认值0，表示圆半径的最小值。
第九个参数，int类型的maxRadius,也有默认值0，表示圆半径的最大值。
需要注意的是，使用此函数可以很容易地检测出圆的圆心，但是它可能找不到合适的圆半径。我们可以通过第八个参数minRadius和第九个参数maxRadius指定最小和最大的圆半径，来辅助圆检测的效果。或者，我们可以直接忽略返回半径，因为它们都有着默认值0，单单用HoughCircles函数检测出来的圆心，然后用额外的一些步骤来进一步确定半径。
示例代码
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】---------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//【1】载入原始图和Mat变量定义
Mat srcImage = imread("D://lili/Desktop/jpg/opencv/10.jpg"); //工程目录下应该有一张名为1.jpg的素材图
Mat midImage,dstImage;//临时变量和目标图的定义
//【2】显示原始图
imshow("【原始图】", srcImage);
//【3】转为灰度图，进行图像平滑
cvtColor(srcImage,midImage, CV_BGR2GRAY);//转化边缘检测后的图为灰度图
GaussianBlur( midImage, midImage, Size(9, 9), 2, 2 );
//【4】进行霍夫圆变换
vector<Vec3f> circles;
HoughCircles( midImage, circles, CV_HOUGH_GRADIENT,1.5, 10, 200, 150, 0, 0 );
//【5】依次在图中绘制出圆
for( size_t i = 0; i < circles.size(); i++ )
{
Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
//绘制圆心
circle( srcImage, center, 3, Scalar(0,255,0), -1, 8, 0 );
//绘制圆轮廓
circle( srcImage, center, radius, Scalar(155,50,255), 3, 8, 0 );
}
//【6】显示效果图
imshow("【效果图】", srcImage);
waitKey(0);
return 0;
}
运行效果
（十）综合示例：霍夫变换
示例代码
//-----------------------------------【程序说明】----------------------------------------------
//《【OpenCV入门教程之十四】OpenCV霍夫变换：霍夫线变换，霍夫圆变换合辑 》
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace std;
using namespace cv;
//-----------------------------------【全局变量声明部分】--------------------------------------
// 描述：全局变量声明
//-----------------------------------------------------------------------------------------------
Mat g_srcImage, g_dstImage,g_midImage;//原始图、中间图和效果图
vector<Vec4i> g_lines;//定义一个矢量结构g_lines用于存放得到的线段矢量集合
//变量接收的TrackBar位置参数
int g_nthreshold=100;
//-----------------------------------【全局函数声明部分】--------------------------------------
// 描述：全局函数声明
//-----------------------------------------------------------------------------------------------
static void on_HoughLines(int, void*);//回调函数
static void ShowHelpText();
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main( )
{
//改变console字体颜色
system("color 3F");
ShowHelpText();
//载入原始图和Mat变量定义
Mat g_srcImage = imread("1.jpg"); //工程目录下应该有一张名为1.jpg的素材图
//显示原始图
imshow("【原始图】", g_srcImage);
//创建滚动条
namedWindow("【效果图】",1);
createTrackbar("值", "【效果图】",&g_nthreshold,200,on_HoughLines);
//进行边缘检测和转化为灰度图
Canny(g_srcImage, g_midImage, 50, 200, 3);//进行一次canny边缘检测
cvtColor(g_midImage,g_dstImage, CV_GRAY2BGR);//转化边缘检测后的图为灰度图
//调用一次回调函数，调用一次HoughLinesP函数
on_HoughLines(g_nthreshold,0);
HoughLinesP(g_midImage, g_lines, 1, CV_PI/180, 80, 50, 10 );
//显示效果图
imshow("【效果图】", g_dstImage);
waitKey(0);
return 0;
}
//-----------------------------------【on_HoughLines( )函数】--------------------------------
// 描述：【顶帽运算/黑帽运算】窗口的回调函数
//----------------------------------------------------------------------------------------------
static void on_HoughLines(int, void*)
{
//定义局部变量储存全局变量
Mat dstImage=g_dstImage.clone();
Mat midImage=g_midImage.clone();
//调用HoughLinesP函数
vector<Vec4i> mylines;
HoughLinesP(midImage, mylines, 1, CV_PI/180, g_nthreshold+1, 50, 10 );
//循环遍历绘制每一条线段
for( size_t i = 0; i < mylines.size(); i++ )
{
Vec4i l = mylines[i];
line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(23,180,55), 1, CV_AA);
}
//显示图像
imshow("【效果图】",dstImage);
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf("\n\n\n\t请调整滚动条观察图像效果~\n\n");
);
}
运行效果
值为100时
值为200时
值为0时
三、重映射
重映射概念
OpenCV实现函数remap()
（一）重映射的概念
重映射，就是把一幅图像中某位置的像素放置到另一个图片指定位置的过程。为了完成映射过程, 我们需要获得一些插值为非整数像素的坐标,因为源图像与目标图像的像素坐标不是一一对应的。一般情况下，我们通过重映射来表达每个像素的位置 (x,y)，像这样 :
g(x,y) = f ( h(x,y) )
在这里， g( ) 是目标图像, f() 是源图像, 而h(x,y) 是作用于 (x,y) 的映射方法函数。
来看个例子。 若有一幅图像 I ,想满足下面的条件作重映射:
h(x,y) = (I.cols - x, y )
这样的话，图像会按照 x 轴方向发生翻转。那么，源图像和效果图分别如下:
（二）实现重映射：remap()函数
remap( )函数会根据我们指定的映射形式，将源图像进行重映射几何变换，基于的式子如下：
void remap(InputArray src, OutputArraydst, InputArray map1, InputArray map2, int interpolation, intborderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
（1）第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可，且需为单通道8位或者浮点型图像。
（2）第二个参数，OutputArray类型的dst，函数调用后的运算结果存在这里，即这个参数用于存放函数调用后的输出结果，需和源图片有一样的尺寸和类型。
（3）第三个参数，InputArray类型的map1，它有两种可能的表示对象。
- 表示点（x，y）的第一个映射。
- 表示CV_16SC2 , CV_32FC1 或CV_32FC2类型的X值。
（4）第四个参数，InputArray类型的map2，同样，它也有两种可能的表示对象，而且他是根据map1来确定表示那种对象。
- 若map1表示点（x，y）时。这个参数不代表任何值。
- 表示CV_16UC1 , CV_32FC1类型的Y值（第二个值）。
（5）第五个参数，int类型的interpolation,插值方式，之前的resize( )函数中有讲到，需要注意，resize( )函数中提到的INTER_AREA插值方式在这里是不支持的，所以可选的插值方式如下：
- INTER_NEAREST - 最近邻插值
- INTER_LINEAR – 双线性插值（默认值）
- INTER_CUBIC – 双三次样条插值（逾4×4像素邻域内的双三次插值）
- INTER_LANCZOS4 -Lanczos插值（逾8×8像素邻域的Lanczos插值）
（6）第六个参数，int类型的borderMode，边界模式，有默认值BORDER_CONSTANT，表示目标图像中“离群点（outliers）”的像素值不会被此函数修改。
（7）第七个参数，const Scalar&类型的borderValue，当有常数边界时使用的值，其有默认值Scalar( )，即默认值为0。
（三）基础示例程序：基本重映射
示例代码
//-----------------------------------【程序说明】----------------------------------------------
//《【OpenCV入门教程之十七】OpenCV重映射》
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始执行
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】变量定义
Mat srcImage, dstImage;
Mat map_x, map_y;
//【1】载入原始图
srcImage = imread( "D://lili/Desktop/jpg/opencv/8.jpg", 1 );
if(!srcImage.data ) { printf("读取图片错误！\n"); return false; }
imshow("原始图",srcImage);
//【2】创建和原始图一样的效果图，x重映射图，y重映射图
dstImage.create( srcImage.size(), srcImage.type() );
map_x.create( srcImage.size(), CV_32FC1 );
map_y.create( srcImage.size(), CV_32FC1 );
//【3】双层循环，遍历每一个像素点，改变map_x & map_y的值
for( int j = 0; j < srcImage.rows;j++)
{
for( int i = 0; i < srcImage.cols;i++)
{
//改变map_x & map_y的值.
map_x.at<float>(j,i) = static_cast<float>(i);
map_y.at<float>(j,i) = static_cast<float>(srcImage.rows - j);
}
}
//【4】进行重映射操作
remap( srcImage, dstImage, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );
//【5】显示效果图
imshow( "【程序窗口】", dstImage );
waitKey();
return 0;
}
运行效果
（四）综合示例程序：实现多种重映射
示例代码
/*
效果：
按键控制实现4种不同重映射模式
*/
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
#include<iostream>
using namespace cv;
using namespace std;
#define WINDOW_NAME "【程序窗口】"
//全局变量
Mat g_srcImage, g_dstImage;
Mat g_map_x, g_map_y;
//全局函数
int update_map(int key);
static void ShowHelpText();
int main()
{
//改变console字体颜色
system("color 2F");
//显示帮助文字
ShowHelpText();
//【1】载入原图
g_srcImage = imread("D://lili/Desktop/jpg/opencv/8.jpg");
if (!g_srcImage.data)
{
printf("载入原图失败\n");
return false;
}
//【2】创建和原图一样的效果图，x重映射图，y重映射图
g_dstImage.create(g_srcImage.size(), g_srcImage.type());
g_map_x.create(g_srcImage.size(), CV_32FC1);
g_map_y.create(g_srcImage.size(), CV_32FC1);
//【3】创建窗口并显示
namedWindow(WINDOW_NAME, CV_WINDOW_AUTOSIZE);
imshow(WINDOW_NAME, g_srcImage);
//【4】轮询按键，更新map_x和map_y的值，进行重映射操作并显示效果图
while (1)
{
//获取键盘按键
int key = waitKey(0);
//判断ESC是否按下，若按下便退出
if ((key & 255) == 27)
{
cout << "程序退出...........\n";
break;
}
//根据按下的键盘按键来更新 map_x & map_y的值. 然后调用remap( )进行重映射
update_map(key);
remap(g_srcImage, g_dstImage, g_map_x, g_map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0));
//显示效果图
imshow(WINDOW_NAME, g_dstImage);
}
return 0;
}
//update_map( )函数：根据按键来更新map_x与map_x的值
int update_map(int key)
{
//双层循环，遍历每一个像素点
for (int j = 0; j < g_srcImage.rows; j++)
{
for (int i = 0; i < g_srcImage.cols; i++)
{
switch (key)
{
case '1': // 键盘【1】键按下，进行第一种重映射操作
if (i > g_srcImage.cols*0.25 && i < g_srcImage.cols*0.75 && j > g_srcImage.rows*0.25 && j < g_srcImage.rows*0.75)
{
g_map_x.at<float>(j, i) = static_cast<float>(2 * (i - g_srcImage.cols*0.25) + 0.5);
g_map_y.at<float>(j, i) = static_cast<float>(2 * (j - g_srcImage.rows*0.25) + 0.5);
}
else
{
g_map_x.at<float>(j, i) = 0;
g_map_y.at<float>(j, i) = 0;
}
break;
case '2': // 键盘【2】键按下，进行第二种重映射操作
g_map_x.at<float>(j, i) = static_cast<float>(i);
g_map_y.at<float>(j, i) = static_cast<float>(g_srcImage.rows - j);
break;
case '3': // 键盘【3】键按下，进行第三种重映射操作
g_map_x.at<float>(j, i) = static_cast<float>(g_srcImage.cols - i);
g_map_y.at<float>(j, i) = static_cast<float>(j);
break;
case '4': // 键盘【4】键按下，进行第四种重映射操作
g_map_x.at<float>(j, i) = static_cast<float>(g_srcImage.cols - i);
g_map_y.at<float>(j, i) = static_cast<float>(g_srcImage.rows - j);
break;
}
}
}
return 0;
}
static void ShowHelpText()
{
printf("\n\n\n\t欢迎来到重映射示例程序~\n\n");
printf("\n\n\t按键操作说明: \n\n");
printf("\t\t键盘按键【ESC】- 退出程序\n");
printf("\t\t键盘按键【1】- 第一种映射方式\n");
printf("\t\t键盘按键【2】- 第二种映射方式\n");
printf("\t\t键盘按键【3】- 第三种映射方式\n");
printf("\t\t键盘按键【4】- 第四种映射方式\n");
}
运行效果
四、仿射变换
仿射变换的概念
OpenCV实现函数wrapAffine和getRotationMatrix2D
（一）认识仿射变换
仿射变换（Affine Transformation或 Affine Map），又称仿射映射，是指在几何中，一个向量空间进行一次线性变换并接上一个平移，变换为另一个向量空间的过程。它保持了二维图形的“平直性”（即：直线经过变换之后依然是直线）和“平行性”（即：二维图形之间的相对位置关系保持不变，平行线依然是平行线，且直线上点的位置顺序不变）。
一个任意的仿射变换都能表示为乘以一个矩阵(线性变换)接着再加上一个向量(平移)的形式。
那么, 我们能够用仿射变换来表示如下三种常见的变换形式：
- 旋转，rotation (线性变换)
- 平移，translation(向量加)
- 缩放，scale(线性变换)
如果进行更深层次的理解，仿射变换代表的是两幅图之间的一种映射关系。
而我们通常使用2 x 3的矩阵来表示仿射变换。
考虑到我们要使用矩阵 A 和 B 对二维向量
做变换, 所以也能表示为下列形式:
或者
即
（二）仿射变换的求法
我们知道，仿射变换表示的就是两幅图片之间的一种联系 . 关于这种联系的信息大致可从以下两种场景获得:
（1）已知 X和T，而且我们知道他们是有联系的. 接下来我们的工作就是求出矩阵 M
（2）已知 M和X，要想求得 T. 我们只要应用算式
即可。对于这种联系的信息可以用矩阵 M 清晰的表达 (即给出明确的2×3矩阵) 或者也可以用两幅图片点之间几何关系来表达。
我们形象地说明一下，因为矩阵 M 联系着两幅图片, 我们就以其表示两图中各三点直接的联系为例。
见下图:
其中，点1, 2 和 3 (在图一中形成一个三角形) 与图二中三个点是一一映射的关系, 且他们仍然形成三角形, 但形状已经和之前不一样了。我们能通过这样两组三点求出仿射变换 (可以选择自己喜欢的点), 接着就可以把仿射变换应用到图像中去。
OpenCV仿射变换相关的函数一般涉及到warpAffine和getRotationMatrix2D这两个：
使用OpenCV函数warpAffine 来实现一些简单的重映射.
使用OpenCV函数getRotationMatrix2D 来获得旋转矩阵。
（三）进行仿射变换：wrapAffine()函数
warpAffine函数的作用是依据如下式子，对图像做仿射变换。
void warpAffine(InputArray src,OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, intborderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar())
（1）第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。
（2）第二个参数，OutputArray类型的dst，函数调用后的运算结果存在这里，需和源图片有一样的尺寸和类型。
（3）第三个参数，InputArray类型的M，2×3的变换矩阵。
（4）第四个参数，Size类型的dsize，表示输出图像的尺寸。
（5）第五个参数，int类型的flags，插值方法的标识符。此参数有默认值INTER_LINEAR(线性插值)，可选的插值方式如下：
- INTER_NEAREST - 最近邻插值
- INTER_LINEAR - 线性插值（默认值）
- INTER_AREA - 区域插值
- INTER_CUBIC –三次样条插值
- INTER_LANCZOS4 -Lanczos插值
- CV_WARP_FILL_OUTLIERS - 填充所有输出图像的象素。如果部分象素落在输入图像的边界外，那么它们的值设定为 fillval.
- CV_WARP_INVERSE_MAP –表示M为输出图像到输入图像的反变换，即 。因此可以直接用来做象素插值。否则, warpAffine函数从M矩阵得到反变换。
（6）第六个参数，int类型的borderMode，边界像素模式，默认值为BORDER_CONSTANT。
（7）第七个参数，const Scalar&类型的borderValue，在恒定的边界情况下取的值，默认值为Scalar()，即0。
（四）计算二维旋转变换矩阵：getRotationMatrix2D()函数
计算二维旋转变换矩阵。变换会将旋转中心映射到它自身。
Mat getRotationMatrix2D(Point2fcenter, double angle, double scale)
（1）第一个参数，Point2f类型的center，表示源图像的旋转中心。
（2）第二个参数，double类型的angle，旋转角度。角度为正值表示向逆时针旋转（坐标原点是左上角）。
（3）第三个参数，double类型的scale，缩放系数。
此函数计算以下矩阵：
其中：
（五）示例程序：仿射变换
自我理解：就是把图片映射到指定大小的矩阵范围内，并且可以旋转。
示例代码
//-----------------------------------【程序说明】----------------------------------------------
// 《【OpenCV入门教程之十八】OpenCV仿射变换》
//----------------------------------------------------------------------------------------------
//-----------------------------------【头文件包含部分】---------------------------------------
// 描述：包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
//-----------------------------------【命名空间声明部分】--------------------------------------
// 描述：包含程序所使用的命名空间
//-----------------------------------------------------------------------------------------------
using namespace cv;
using namespace std;
//-----------------------------------【宏定义部分】--------------------------------------------
// 描述：定义一些辅助宏
//------------------------------------------------------------------------------------------------
#define WINDOW_NAME1 "【原始图窗口】" //为窗口标题定义的宏
#define WINDOW_NAME2 "【经过Warp后的图像】" //为窗口标题定义的宏
#define WINDOW_NAME3 "【经过Warp和Rotate后的图像】" //为窗口标题定义的宏
//-----------------------------------【全局函数声明部分】--------------------------------------
// 描述：全局函数的声明
//-----------------------------------------------------------------------------------------------
static void ShowHelpText( );
//-----------------------------------【main( )函数】--------------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始执行
//-----------------------------------------------------------------------------------------------
int main( )
{
//【0】改变console字体颜色
system("color 1A");
//【0】显示欢迎和帮助文字
ShowHelpText( );
//【1】参数准备
//定义两组点，代表两个三角形
Point2f srcTriangle[3];
Point2f dstTriangle[3];
//定义一些Mat变量
Mat rotMat( 2, 3, CV_32FC1 );
Mat warpMat( 2, 3, CV_32FC1 );
Mat srcImage, dstImage_warp, dstImage_warp_rotate;
//【2】加载源图像并作一些初始化
srcImage = imread( "D://lili/Desktop/jpg/opencv/8.jpg", 1 );
if(!srcImage.data ) { printf("读取图片错误\n"); return false; }
// 设置目标图像的大小和类型与源图像一致
dstImage_warp = Mat::zeros( srcImage.rows, srcImage.cols, srcImage.type() );
//【3】设置源图像和目标图像上的三组点以计算仿射变换
srcTriangle[0] = Point2f( 0,0 );
srcTriangle[1] = Point2f( static_cast<float>(srcImage.cols - 1), 0 );
srcTriangle[2] = Point2f( 0, static_cast<float>(srcImage.rows - 1 ));
dstTriangle[0] = Point2f( static_cast<float>(srcImage.cols*0.0), static_cast<float>(srcImage.rows*0.33));
dstTriangle[1] = Point2f( static_cast<float>(srcImage.cols*0.65), static_cast<float>(srcImage.rows*0.35));
dstTriangle[2] = Point2f( static_cast<float>(srcImage.cols*0.15), static_cast<float>(srcImage.rows*0.6));
//【4】求得仿射变换
warpMat = getAffineTransform( srcTriangle, dstTriangle );
//【5】对源图像应用刚刚求得的仿射变换
warpAffine( srcImage, dstImage_warp, warpMat, dstImage_warp.size() );
//【6】对图像进行缩放后再旋转
// 计算绕图像中点顺时针旋转50度缩放因子为0.6的旋转矩阵
Point center = Point( dstImage_warp.cols/2, dstImage_warp.rows/2 );
double angle = -30.0;
double scale = 0.8;
// 通过上面的旋转细节信息求得旋转矩阵
rotMat = getRotationMatrix2D( center, angle, scale );
// 旋转已缩放后的图像
warpAffine( dstImage_warp, dstImage_warp_rotate, rotMat, dstImage_warp.size() );
//【7】显示结果
imshow( WINDOW_NAME1, srcImage );
imshow( WINDOW_NAME2, dstImage_warp );
imshow( WINDOW_NAME3, dstImage_warp_rotate );
// 等待用户按任意按键退出程序
waitKey(0);
return 0;
}
//-----------------------------------【ShowHelpText( )函数】----------------------------------
// 描述：输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText()
{
//输出一些帮助信息
printf( "\n\n\n\t欢迎来到【仿射变换】示例程序~\n\n");
printf("\t当前使用的OpenCV版本为 OpenCV "CV_VERSION);
);
}
运行效果
五、直方图均衡化
个人理解：增加对比度？
很多时候，我们用相机拍摄的照片的效果往往会不尽人意。这时，可以对这些图像进行一些处理，来扩大图像的动态范围。这种情况下最常用到的技术就是直方图均衡化。未经均衡化的图片范例如图7.41、7.42所示。
在图7.41中，我们可以看到，左边的图像比较淡，因为其数值范围变化比较小，可以在这幅图的直方图(图7.42）中明显地看到。因为处理的是8位图像，其亮度值是从0 到255，但直方图值显示的实际亮度却集中在亮度范围的中间区域。
（一）直方图均衡 的概念和特点
直方图均衡化是灰度变换的一个重要应用，它高效且易于实现，广泛应用于图像增强处理中。图像的像素灰度变化是随机的，直方图的图形高低不齐，直方图均衡化就是用一定的算法使直方图大致平和的方法。均衡化效果示例如图7.43、7.44所示。
简而言之，直方图均衡化是通过拉伸像素强度分布范围来增强图像对比度的一种方法。
均衡化处理后的图像只能是近似均匀分布。均衡化图像的动态范围扩大了，但其本质是扩大了量化间隔，而量化级别反而减少了，因此，原来灰度不同的象素经处理后可能变的相同，形成了一片相同灰度的区域，各区域之间有明显的边界，从而出现了伪轮廓。
在原始图像对比度本来就很高的情况下，如果再均衡化则灰度调和，对比度会降低。在泛白缓和的图像中，均衡化会合并一些象素灰度，从而增大对比度。均衡化后的图片如果再对其均衡化，则图像不会有任何变化。如图7.45、7.46所示。
通过图7.46可以发现，经过均衡化的图像，其频谱更加舒展，有效地利用了0一255的空间，图像表现力更加出色。
（二）实现直方图均衡化：equalizeHist()函数
在OpenCV中，直方图均衡化的功能实现由 equalizeHist函数完成。我们一起看看它的函数描述。
（1）第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可，需为8位单通道的图像。
（2）第二个参数，OutputArray类型的 dst，函数调用后的运算结果存在这里，需和源图片有一样的尺寸和类型。
- 采用如下步骤对输入图像进行直方图均衡化。
- 计算输入图像的直方图H。
- 进行直方图归一化，直方图的组距的和为255。
- 计算直方图积分:
- 以H`作为查询表进行图像变换:
总而言之，由 equalizeHist()函数实现的灰度直方图均衡化算法，就是把直方图的每个灰度级进行归一化处理，求每种灰度的累积分布，得到一个映射的灰度映射表，然后根据相应的灰度值来修正原图中的每个像素。
（三）示例程序：直方图均衡化
示例代码
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
using namespace cv;
using namespace std;
int main()
{
Mat srcImage, dstImage;
//输入原始图像
srcImage = imread("D://lili/Desktop/jpg/opencv/8.jpg");
if (!srcImage.data)
{
printf("读取图片错误\n");
return false;
}
//转为灰度图并展示出来
cvtColor(srcImage, srcImage, COLOR_BGR2GRAY);
imshow("原始图", srcImage);
//进行直方图均衡化
equalizeHist(srcImage, dstImage);
//显示结果
imshow("经过直方图均衡化后的图", dstImage);
waitKey(0);
return 0;
}
运行效果
