OpenCV入门指南

最新推荐文章于 2023-06-19 11:41:47 发布
最新推荐文章于 2023-06-19 11:41:47 发布
阅读量4.5k 收藏 8
点赞数
分类专栏： 图形、图像、动画、游戏、界面相关

【OpenCV第一篇】安装OpenCV

本篇主要介绍如何下载OpenCV安装程序，如何在VS2008下安装配置OpenCV，文章最后还介绍了一个使用OpenCV的简单小例子。

一．OpenCV的下载

可以到http://www.opencv.org.cn/index.php/Download，然后选一个较新版本下载。我下的是V2.3.1版本，下载地址是：

http://www.opencv.org.cn/download/OpenCV-2.3.1-win-superpack.exe

下载完成后，双击运行exe，选择输出目录，我选择的是D:\opencv。然后解压缩就完成了安装。安装过程如下图所示：

 

二．在我的电脑中配置OpenCV

在“我的电脑”右击弹出“系统属性”对话框，选择“高级”再点击“环境变量”，然后再编辑path，在“编辑用户变量”对话框的变量值输入以下三条，注意用“;”来分开。

D:\opencv\opencv\build\x86\vc9\bin;

D:\opencv\opencv\build\x86\mingw\bin;

D:\opencv\opencv\build\common\tbb\ia32\vc9;

 

三．在VS2008中加入OpenCV

在VS2008中点击“工具”，再点击“选项”，然后选择“项目和解决方案”，手动加入库文件，引用文件和包含文件即可完成OpenCV在VS2008的导入。 

 

四．第一个OpenCV程序

下面是最简单的OpenCV使用例子，功能也很简单——加载图像文件并显示出来。代码如下：

[cpp] view plain copy print ?
  1. //显示图像文件   
  2. #include <opencv2/opencv.hpp>   
  3. using namespace std;  
  4.   
  5. #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")   
  6.   
  7. int main()  
  8. {  
  9.     const char *pstrImageName = "冲浪大师赛001.jpg";  
  10.     const char *pstrWindowsTitle = "OpenCV第一个程序(http://blog.csdn.net/MoreWindows)";  
  11.   
  12.     //从文件中读取图像   
  13.     IplImage *pImage = cvLoadImage(pstrImageName, CV_LOAD_IMAGE_UNCHANGED);  
  14.   
  15.     //创建窗口   
  16.     cvNamedWindow(pstrWindowsTitle, CV_WINDOW_AUTOSIZE);  
  17.   
  18.     //在指定窗口中显示图像   
  19.     cvShowImage(pstrWindowsTitle, pImage);  
  20.   
  21.     //等待按键事件   
  22.     cvWaitKey();  
  23.   
  24.     cvDestroyWindow(pstrWindowsTitle);  
  25.     cvReleaseImage(&pImage);  
  26.     return 0;  
  27. }  
//显示图像文件
#include <opencv2/opencv.hpp>
using namespace std;

#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

int main()
{
	const char *pstrImageName = "冲浪大师赛001.jpg";
	const char *pstrWindowsTitle = "OpenCV第一个程序(http://blog.csdn.net/MoreWindows)";

	//从文件中读取图像
	IplImage *pImage = cvLoadImage(pstrImageName, CV_LOAD_IMAGE_UNCHANGED);

	//创建窗口
	cvNamedWindow(pstrWindowsTitle, CV_WINDOW_AUTOSIZE);

	//在指定窗口中显示图像
	cvShowImage(pstrWindowsTitle, pImage);

	//等待按键事件
	cvWaitKey();

	cvDestroyWindow(pstrWindowsTitle);
	cvReleaseImage(&pImage);
	return 0;
}

对代码中的主要函数进行下讲解：

 

1．创建窗口 cvNamedWindow

函数名称：cvNamedWindow
函数功能：创建窗口
函数原型：
int cvNamedWindow( const char* name, int flags=CV_WINDOW_AUTOSIZE );

参数说明：
第一个参数表示窗口的名字，它被用来区分不同的窗口，并被显示为窗口标题。被创建的窗口可以通过它们的名字被引用。
第二个参数表示窗口属性标志。目前唯一支持的标志是CV_WINDOW_AUTOSIZE。当这个标志被设置后，用户不能手动改变窗口大小，窗口大小会自动调整以适合被显示图像。
函数cvNamedWindow创建一个可以放置图像和trackbar的窗口。

注意：
如果已经存在这个名字的窗口，这个函数将不做任何事情。

 

2．在指定窗口中显示图像 cvShowImage

函数名称：cvShowImage
函数功能：在指定窗口中显示图像
函数原型：
void cvShowImage( const char* name, const CvArr* image );
参数说明：

第一个参数：窗口的名字。
第二个参数：被显示的图像。

3．等待按键事件 cvWaitKey

函数名称：cvWaitKey

函数功能：等待按键事件

函数原型：
int cvWaitKey( int delay=0 );
参数说明：

第一个参数：延迟的毫秒数，当delay<=0时表示无限等待。

函数返回值：

如果超过指定时间则返回-1，否则返回被按键的值。

 

编译，居然出错了！！错误信息如下：

1>正在链接...

1>opencv_test1.obj : error LNK2019: 无法解析的外部符号_cvReleaseImage，该符号在函数_main 中被引用

1>opencv_test1.obj : error LNK2019: 无法解析的外部符号_cvDestroyWindow，该符号在函数_main 中被引用

1>opencv_test1.obj : error LNK2019: 无法解析的外部符号_cvWaitKey，该符号在函数_main 中被引用

1>opencv_test1.obj : error LNK2019: 无法解析的外部符号_cvShowImage，该符号在函数_main 中被引用

1>opencv_test1.obj : error LNK2019: 无法解析的外部符号_cvNamedWindow，该符号在函数_main 中被引用

1>opencv_test1.obj : error LNK2019: 无法解析的外部符号_cvLoadImage，该符号在函数_main 中被引用

 

现在如何解决这个问题了？既然是在链接时出的错，说明肯定有静态库没有被编译器找到。因此我们在VS2008中点击“项目”，再点击“属性”，依次展开“配置属性”-->“链接器”-->“输入”在“附加依赖项中”添加如下静态文件。

opencv_calib3d231d.lib opencv_contrib231d.lib opencv_core231d.lib opencv_features2d231d.lib opencv_flann231d.lib opencv_gpu231d.lib opencv_highgui231d.lib opencv_imgproc231d.lib opencv_legacy231d.lib opencv_ml231d.lib opencv_objdetect231d.lib opencv_ts231d.lib opencv_video231d.lib

 

再编译，成功。程序运行结果如下图所示：

呵呵，很酷的冲浪~~

【OpenCV入门指南】第二篇 缩放图像

 一. 主要函数介绍

1.1 cvResize

函数功能：图像大小变换

函数原型：

voidcvResize(

  const CvArr* src,

  CvArr* dst,

  intinterpolation=CV_INTER_LINEAR

);

函数说明：

第一个参数表示输入图像。

第二个参数表示输出图像。

第三个参数表示插值方法，可以有以下四种：

CV_INTER_NN - 最近邻插值,

CV_INTER_LINEAR - 双线性插值 (缺省使用)

CV_INTER_AREA - 使用象素关系重采样。当图像缩小时候，该方法可以避免波纹出现。当图像放大时，类似于 CV_INTER_NN 方法..

CV_INTER_CUBIC - 立方插值.

这个函数在功能上与Win32 API中的StretchBlt()函数类似。

 

1.2 cvCreateImage

函数功能：创建图像

函数原型：

IplImage* cvCreateImage(CvSize size, intdepth, intchannels);

函数说明：

第一个参数表示图像的大小。

第二个参数表示图像的深度，可以为IPL_DEPTH_8U，IPL_DEPTH_16U等等。

第三个参数表示图像的通道数。

 

二. 示例程序代码

有了这二个函数后，不难写出代码：

[cpp] view plain copy print ?
  1. //缩放图像文件   
  2. //By MoreWindows (http://blog.csdn.net/MoreWindows)   
  3. #include <opencv2/opencv.hpp>   
  4. using namespace std;  
  5. //隐藏控制台窗口   
  6. #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")   
  7. int main()  
  8. {  
  9.     const char *pstrImageName = "冲浪大师赛001.jpg";  
  10.     const char *pstrSaveImageName = "冲浪大师赛001缩放图.jpg";  
  11.     const char *pstrWindowsSrcTitle = "原图 (http://blog.csdn.net/MoreWindows)";  
  12.     const char *pstrWindowsDstTitle = "缩放图 (http://blog.csdn.net/MoreWindows)";  
  13.       
  14.     double fScale = 0.314;      //缩放倍数   
  15.     CvSize czSize;              //目标图像尺寸   
  16.       
  17.     //从文件中读取图像     
  18.     IplImage *pSrcImage = cvLoadImage(pstrImageName, CV_LOAD_IMAGE_UNCHANGED);  
  19.     IplImage *pDstImage = NULL;   
  20.       
  21.     //计算目标图像大小   
  22.     czSize.width = pSrcImage->width * fScale;  
  23.     czSize.height = pSrcImage->height * fScale;  
  24.       
  25.     //创建图像并缩放   
  26.     pDstImage = cvCreateImage(czSize, pSrcImage->depth, pSrcImage->nChannels);  
  27.     cvResize(pSrcImage, pDstImage, CV_INTER_AREA);  
  28.       
  29.     //创建窗口   
  30.     cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);  
  31.     cvNamedWindow(pstrWindowsDstTitle, CV_WINDOW_AUTOSIZE);  
  32.       
  33.     //在指定窗口中显示图像   
  34.     cvShowImage(pstrWindowsSrcTitle, pSrcImage);  
  35.     cvShowImage(pstrWindowsDstTitle, pDstImage);  
  36.       
  37.     //等待按键事件   
  38.     cvWaitKey();  
  39.       
  40.     //保存图片   
  41.     cvSaveImage(pstrSaveImageName, pDstImage);  
  42.       
  43.     cvDestroyWindow(pstrWindowsSrcTitle);  
  44.     cvDestroyWindow(pstrWindowsDstTitle);  
  45.     cvReleaseImage(&pSrcImage);  
  46.     cvReleaseImage(&pDstImage);  
  47.     return 0;  
  48. }  
//缩放图像文件
//By MoreWindows (http://blog.csdn.net/MoreWindows)
#include <opencv2/opencv.hpp>
using namespace std;
//隐藏控制台窗口
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
int main()
{
	const char *pstrImageName = "冲浪大师赛001.jpg";
	const char *pstrSaveImageName = "冲浪大师赛001缩放图.jpg";
	const char *pstrWindowsSrcTitle = "原图 (http://blog.csdn.net/MoreWindows)";
	const char *pstrWindowsDstTitle = "缩放图 (http://blog.csdn.net/MoreWindows)";
	
	double fScale = 0.314;		//缩放倍数
	CvSize czSize;			    //目标图像尺寸
	
	//从文件中读取图像  
	IplImage *pSrcImage = cvLoadImage(pstrImageName, CV_LOAD_IMAGE_UNCHANGED);
	IplImage *pDstImage = NULL;	
	
	//计算目标图像大小
	czSize.width = pSrcImage->width * fScale;
	czSize.height = pSrcImage->height * fScale;
	
	//创建图像并缩放
	pDstImage = cvCreateImage(czSize, pSrcImage->depth, pSrcImage->nChannels);
	cvResize(pSrcImage, pDstImage, CV_INTER_AREA);
	
	//创建窗口
	cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);
	cvNamedWindow(pstrWindowsDstTitle, CV_WINDOW_AUTOSIZE);
	
	//在指定窗口中显示图像
	cvShowImage(pstrWindowsSrcTitle, pSrcImage);
	cvShowImage(pstrWindowsDstTitle, pDstImage);
	
	//等待按键事件
	cvWaitKey();
	
	//保存图片
	cvSaveImage(pstrSaveImageName, pDstImage);
	
	cvDestroyWindow(pstrWindowsSrcTitle);
	cvDestroyWindow(pstrWindowsDstTitle);
	cvReleaseImage(&pSrcImage);
	cvReleaseImage(&pDstImage);
	return 0;
}

程序运行结果如下：

【OpenCV入门指南】第三篇Canny边缘检测

    图像的边缘检测的原理是检测出图像中所有灰度值变化较大的点，而且这些点连接起来就构成了若干线条，这些线条就可以称为图像的边缘。

    Canny边缘检测算子是John F. Canny于 1986 年开发出来的一个多级边缘检测算法。Canny 边缘检测的数学原理和算法实现这里就不再了，有兴趣的读者可以查阅专业书籍，本文主要介绍如何在OpenCV中对图像进行Canny 边缘检测，下面就来看看这个函数的原型。

一. 主要函数

1.1 cvCanny

函数功能：采用Canny方法对图像进行边缘检测

函数原型：

void cvCanny(

  const CvArr* image,

  CvArr* edges,

  double threshold1,double threshold2,

  int aperture_size=3

);

函数说明：

第一个参数表示输入图像，必须为单通道灰度图。

第二个参数表示输出的边缘图像，为单通道黑白图。

第三个参数和第四个参数表示阈值，这二个阈值中当中的小阈值用来控制边缘连接，大的阈值用来控制强边缘的初始分割即如果一个像素的梯度大与上限值，则被认为是边缘像素，如果小于下限阈值，则被抛弃。如果该点的梯度在两者之间则当这个点与高于上限值的像素点连接时我们才保留，否则删除。

第五个参数表示Sobel 算子大小，默认为3即表示一个3*3的矩阵。Sobel 算子与高斯拉普拉斯算子都是常用的边缘算子，详细的数学原理可以查阅专业书籍。

 

为了更好的使用cvCanny()函数，下面再介绍二个实用的函数，这二个函数对后面的程序实现非常有帮助。

 

1.2 cvCreateTrackbar

函数功能：创建trackbar并添加到指定窗口

函数原型：

intcvCreateTrackbar(

  const char* trackbar_name,

  const char* window_name,

  int* value,

  intcount,

  CvTrackbarCallback on_change

);

函数说明：

第一个参数表示该trackbar的名称。

第二个参数表示窗口名称，该trackbar将显示在这个窗口内。

第三个参数表示创建时滑块的位置。

第四个参数表示滑块位置的最大值，最小值固定为0。

第五个参数表示回调函数。当滑块位置有变化时，系统会调用该回调函数。

注：被创建的trackbar默认显示在指定窗口的顶端，可以通过函数cvGetTrackbarPos()来获取trackbar显示的位置信息，以及通过函数cvSetTrackbarPos()来重新设置trackbar的显示位置。

 

1.3  CvTrackbarCallback

函数功能：cvCreateTrackbar()函数所使用的回调函数

函数定义：

typedef void (CV_CDECL *CvTrackbarCallback)(int pos)

函数说明：

当trackbar位置被改变的时，系统会调用这个回调函数，并将参数pos设置为表示trackbar位置的数值。

 

二. 示例程序代码

下面就给出在OpenCV中使用Canny 边缘检测的程序代码：

[cpp] view plain copy print ?
  1. //图像的Canny边缘检测   
  2. //By MoreWindows (http://blog.csdn.net/MoreWindows)   
  3. #include <opencv2/opencv.hpp>   
  4. using namespace std;  
  5. #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")   
  6. IplImage *g_pSrcImage, *g_pCannyImg;  
  7. const char *pstrWindowsCannyTitle = "边缘检测图(http://blog.csdn.net/MoreWindows)";  
  8. //cvCreateTrackbar的回调函数   
  9. void on_trackbar(int threshold)  
  10. {  
  11.     //canny边缘检测   
  12.     cvCanny(g_pSrcImage, g_pCannyImg, threshold, threshold * 3, 3);  
  13.     cvShowImage(pstrWindowsCannyTitle, g_pCannyImg);  
  14. }  
  15. int main()  
  16. {  
  17.     const char *pstrImageName = "001.jpg";  
  18.     const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";  
  19.     const char *pstrWindowsToolBar = "Threshold";  
  20.   
  21.     //从文件中载入图像的灰度图CV_LOAD_IMAGE_GRAYSCALE - 灰度图   
  22.     g_pSrcImage = cvLoadImage(pstrImageName, CV_LOAD_IMAGE_GRAYSCALE);  
  23.     g_pCannyImg = cvCreateImage(cvGetSize(g_pSrcImage), IPL_DEPTH_8U, 1);  
  24.   
  25.     //创建窗口   
  26.     cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);  
  27.     cvNamedWindow(pstrWindowsCannyTitle, CV_WINDOW_AUTOSIZE);  
  28.   
  29. //创建滑动条   
  30.     int nThresholdEdge = 1;  
  31.     cvCreateTrackbar(pstrWindowsToolBar, pstrWindowsCannyTitle, &nThresholdEdge, 100, on_trackbar);  
  32.   
  33.     //在指定窗口中显示图像   
  34.     cvShowImage(pstrWindowsSrcTitle, g_pSrcImage);  
  35.     on_trackbar(1);  
  36.   
  37.     //等待按键事件   
  38.     cvWaitKey();  
  39.   
  40.     cvDestroyWindow(pstrWindowsSrcTitle);  
  41.     cvDestroyWindow(pstrWindowsCannyTitle);  
  42.     cvReleaseImage(&g_pSrcImage);  
  43.     cvReleaseImage(&g_pCannyImg);  
  44.     return 0;  
  45. }  
//图像的Canny边缘检测
//By MoreWindows (http://blog.csdn.net/MoreWindows)
#include <opencv2/opencv.hpp>
using namespace std;
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
IplImage *g_pSrcImage, *g_pCannyImg;
const char *pstrWindowsCannyTitle = "边缘检测图(http://blog.csdn.net/MoreWindows)";
//cvCreateTrackbar的回调函数
void on_trackbar(int threshold)
{
	//canny边缘检测
	cvCanny(g_pSrcImage, g_pCannyImg, threshold, threshold * 3, 3);
	cvShowImage(pstrWindowsCannyTitle, g_pCannyImg);
}
int main()
{
	const char *pstrImageName = "001.jpg";
	const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";
	const char *pstrWindowsToolBar = "Threshold";

	//从文件中载入图像的灰度图CV_LOAD_IMAGE_GRAYSCALE - 灰度图
	g_pSrcImage = cvLoadImage(pstrImageName, CV_LOAD_IMAGE_GRAYSCALE);
	g_pCannyImg = cvCreateImage(cvGetSize(g_pSrcImage), IPL_DEPTH_8U, 1);

	//创建窗口
	cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);
	cvNamedWindow(pstrWindowsCannyTitle, CV_WINDOW_AUTOSIZE);

//创建滑动条
	int nThresholdEdge = 1;
	cvCreateTrackbar(pstrWindowsToolBar, pstrWindowsCannyTitle, &nThresholdEdge, 100, on_trackbar);

	//在指定窗口中显示图像
	cvShowImage(pstrWindowsSrcTitle, g_pSrcImage);
	on_trackbar(1);

	//等待按键事件
	cvWaitKey();

	cvDestroyWindow(pstrWindowsSrcTitle);
	cvDestroyWindow(pstrWindowsCannyTitle);
	cvReleaseImage(&g_pSrcImage);
	cvReleaseImage(&g_pCannyImg);
	return 0;
}

运行效果如图所示：

 

本篇介绍了Canny边缘检测，这种方法能有效的找出图像中的所有边缘。

【OpenCV入门指南】第四篇 图像的二值化

   在上一篇《【OpenCV入门指南】第三篇Canny边缘检测》中介绍了使用Canny算子对图像进行边缘检测。与边缘检测相比，轮廓检测有时能更好的反映图像的内容。而要对图像进行轮廓检测，则必须要先对图像进行二值化，图像的二值化就是将图像上的像素点的灰度值设置为0或255，这样将使整个图像呈现出明显的黑白效果。在数字图像处理中，二值图像占有非常重要的地位，图像的二值化使图像中数据量大为减少，从而能凸显出目标的轮廓。

一. 关键函数介绍

下面就介绍OpenCV中对图像进行二值化的关键函数——cvThreshold()。

函数功能：采用Canny方法对图像进行边缘检测

函数原型：

void cvThreshold(

  const CvArr* src,

  CvArr* dst,

  double threshold,

  double max_value,

  int threshold_type

);

函数说明：

第一个参数表示输入图像，必须为单通道灰度图。

第二个参数表示输出的边缘图像，为单通道黑白图。

第三个参数表示阈值

第四个参数表示最大值。

第五个参数表示运算方法。

在OpenCV的imgproc\types_c.h中可以找到运算方法的定义。

/* Threshold types */

enum

{

    CV_THRESH_BINARY      =0,  /* value = value > threshold ? max_value : 0       */

    CV_THRESH_BINARY_INV  =1,  /* value = value > threshold ? 0 : max_value       */

    CV_THRESH_TRUNC       =2,  /* value = value > threshold ? threshold : value   */

    CV_THRESH_TOZERO      =3,  /* value = value > threshold ? value : 0           */

    CV_THRESH_TOZERO_INV  =4,  /* value = value > threshold ? 0 : value           */

    CV_THRESH_MASK        =7,

    CV_THRESH_OTSU        =8  /* use Otsu algorithm to choose the optimal threshold value; combine the flag with one of the above CV_THRESH_* values */

};

注释已经写的很清楚了，因此不再用中文来表达了。

 

二. 示例程序代码

下面给出对图像进行二值化的完整的源代码：

[cpp] view plain copy print ?
  1. //图像的二值化   
  2. //By MoreWindows (http://blog.csdn.net/MoreWindows)   
  3. #include <opencv2/opencv.hpp>   
  4. using namespace std;  
  5.   
  6. #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")   
  7.   
  8. IplImage *g_pGrayImage = NULL;  
  9. IplImage *g_pBinaryImage = NULL;  
  10. const char *pstrWindowsBinaryTitle = "二值图(http://blog.csdn.net/MoreWindows)";  
  11.   
  12. void on_trackbar(int pos)  
  13. {  
  14.     // 转为二值图   
  15.     cvThreshold(g_pGrayImage, g_pBinaryImage, pos, 255, CV_THRESH_BINARY);  
  16.     // 显示二值图   
  17.     cvShowImage(pstrWindowsBinaryTitle, g_pBinaryImage);  
  18. }  
  19.   
  20. int main( int argc, char** argv )  
  21. {     
  22.     const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";  
  23.     const char *pstrWindowsToolBarName = "二值图阈值";  
  24.   
  25.     // 从文件中加载原图   
  26.     IplImage *pSrcImage = cvLoadImage("002.jpg", CV_LOAD_IMAGE_UNCHANGED);  
  27.   
  28.     // 转为灰度图   
  29.     g_pGrayImage =  cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 1);  
  30.     cvCvtColor(pSrcImage, g_pGrayImage, CV_BGR2GRAY);  
  31.   
  32.     // 创建二值图   
  33.     g_pBinaryImage = cvCreateImage(cvGetSize(g_pGrayImage), IPL_DEPTH_8U, 1);  
  34.   
  35.     // 显示原图   
  36.     cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);  
  37.     cvShowImage(pstrWindowsSrcTitle, pSrcImage);  
  38.     // 创建二值图窗口   
  39.     cvNamedWindow(pstrWindowsBinaryTitle, CV_WINDOW_AUTOSIZE);  
  40.   
  41.     // 滑动条     
  42.     int nThreshold = 0;  
  43.     cvCreateTrackbar(pstrWindowsToolBarName, pstrWindowsBinaryTitle, &nThreshold, 254, on_trackbar);  
  44.   
  45.     on_trackbar(1);  
  46.   
  47.     cvWaitKey(0);  
  48.   
  49.     cvDestroyWindow(pstrWindowsSrcTitle);  
  50.     cvDestroyWindow(pstrWindowsBinaryTitle);  
  51.     cvReleaseImage(&pSrcImage);  
  52.     cvReleaseImage(&g_pGrayImage);  
  53.     cvReleaseImage(&g_pBinaryImage);  
  54.     return 0;  
  55. }  
//图像的二值化
//By MoreWindows (http://blog.csdn.net/MoreWindows)
#include <opencv2/opencv.hpp>
using namespace std;

#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

IplImage *g_pGrayImage = NULL;
IplImage *g_pBinaryImage = NULL;
const char *pstrWindowsBinaryTitle = "二值图(http://blog.csdn.net/MoreWindows)";

void on_trackbar(int pos)
{
	// 转为二值图
	cvThreshold(g_pGrayImage, g_pBinaryImage, pos, 255, CV_THRESH_BINARY);
	// 显示二值图
	cvShowImage(pstrWindowsBinaryTitle, g_pBinaryImage);
}

int main( int argc, char** argv )
{	
	const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";
	const char *pstrWindowsToolBarName = "二值图阈值";

	// 从文件中加载原图
	IplImage *pSrcImage = cvLoadImage("002.jpg", CV_LOAD_IMAGE_UNCHANGED);

	// 转为灰度图
	g_pGrayImage =  cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 1);
	cvCvtColor(pSrcImage, g_pGrayImage, CV_BGR2GRAY);

	// 创建二值图
	g_pBinaryImage = cvCreateImage(cvGetSize(g_pGrayImage), IPL_DEPTH_8U, 1);

	// 显示原图
	cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);
	cvShowImage(pstrWindowsSrcTitle, pSrcImage);
	// 创建二值图窗口
	cvNamedWindow(pstrWindowsBinaryTitle, CV_WINDOW_AUTOSIZE);

	// 滑动条	
	int nThreshold = 0;
	cvCreateTrackbar(pstrWindowsToolBarName, pstrWindowsBinaryTitle, &nThreshold, 254, on_trackbar);

	on_trackbar(1);

	cvWaitKey(0);

	cvDestroyWindow(pstrWindowsSrcTitle);
	cvDestroyWindow(pstrWindowsBinaryTitle);
	cvReleaseImage(&pSrcImage);
	cvReleaseImage(&g_pGrayImage);
	cvReleaseImage(&g_pBinaryImage);
	return 0;
}

运行结果如下所示，读者可以到下载源文件和程序（Release版本，不用安装OpenCV也能使用），自己动手调试下阈值大小，看看生成的二值图有什么变化。

 

OpenCV还有个cvAdaptiveThreshold()函数，这个函数会使用Otsu算法(大律法或最大类间方差法)（注1）来计算出一个全局阈值，然后根据这个阈值进行二值化。当然直接使用上一篇《【OpenCV入门指南】第三篇Canny边缘检测》中的cvCanny()函数也可以对图像进行二值化（想到怎么传参数了吗？）。

注1．调用cvThreshold()时传入参数CV_THRESH_OTSU也是使用Otsu算法来自动生成一个阈值。

【OpenCV入门指南】第五篇 轮廓检测 上

《【OpenCV入门指南】第三篇Canny边缘检测》中介绍了边缘检测，本篇介绍轮廓检测，轮廓检测的原理通俗的说就是掏空内部点，比如原图中有3*3的矩形点。那么就可以将中间的那一点去掉。

       在OpenCV中使用轮廓检测是非常方便。直接使用cvFindContours函数就能完成对图像轮廓的检测。下面就来看看这个函数的用法。 

一．关键函数

1.1  cvFindContours

函数功能：对图像进行轮廓检测，这个函数将生成一条链表以保存检测出的各个轮廓信息，并传出指向这条链表表头的指针。

函数原型：

int cvFindContours(

  CvArr* image,

  CvMemStorage* storage,

  CvSeq** first_contour, 　　

  int header_size=sizeof(CvContour),

  int mode=CV_RETR_LIST, 　　

  int method=CV_CHAIN_APPROX_SIMPLE,

  CvPoint offset=cvPoint(0,0)

);

函数说明：

第一个参数表示输入图像，必须为一个8位的二值图像。图像的二值化请参见《【OpenCV入门指南】第四篇图像的二值化》。

 

第二参数表示存储轮廓的容器。为CvMemStorage类型，定义在OpenCV的\core\types_c.h中。

 

第三个参数为输出参数，这个参数将指向用来存储轮廓信息的链表表头。

 

第四个参数表示存储轮廓链表的表头大小，当第六个参数传入CV_CHAIN_CODE时，要设置成sizeof(CvChain)，其它情况统一设置成sizeof(CvContour)。

 

第五个参数为轮廓检测的模式，有如下取值：

CV_RETR_EXTERNAL：只检索最外面的轮廓；

　　CV_RETR_LIST：检索所有的轮廓，并将其保存到一条链表当中；

　　CV_RETR_CCOMP：检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界；

CV_RETR_TREE：检索所有的轮廓，并重构嵌套轮廓的整个层次，可以参见下图。

第六个参数用来表示轮廓边缘的近似方法的，常用值如下所示：

CV_CHAIN_CODE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。

　　CV_CHAIN_APPROX_SIMPLE：压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。

 

第七个参数表示偏移量，比如你要从图像的（100, 0）开始进行轮廓检测，那么就传入（100, 0）。

 

使用cvFindContours函数能检测出图像的轮廓，将轮廓绘制出来则需要另一函数——cvDrawContours来配合了。下面介绍cvDrawContours函数。

 

1.2  cvDrawContours

函数功能：在图像上绘制外部和内部轮廓

函数原型：

void cvDrawContours(

  CvArr *img,

  CvSeq* contour,

  CvScalar external_color,

  CvScalar hole_color,

  int max_level,

  int thickness=1,

  int line_type=8,

  CvPoint offset=cvPoint(0,0)

);

第一个参数表示输入图像，函数将在这张图像上绘制轮廓。

第二个参数表示指向轮廓链表的指针。

第三个参数和第四个参数表示颜色，绘制时会根据轮廓的层次来交替使用这二种颜色。

第五个参数表示绘制轮廓的最大层数，如果是0，只绘制contour；如果是1，追加绘制和contour同层的所有轮廓；如果是2，追加绘制比contour低一层的轮廓，以此类推；如果值是负值，则函数并不绘制contour后的轮廓，但是将画出其子轮廓，一直到abs(max_level) - 1层。

第六个参数表示轮廓线的宽度，如果为CV_FILLED则会填充轮廓内部。

第七个参数表示轮廓线的类型。

第八个参数表示偏移量，如果传入（10，20），那绘制将从图像的（10，20）处开始。

 

二．示例程序代码

下面用一个非常简单的例子展示如何使用轮廓检测。

[cpp] view plain copy print ?
  1. //图像的轮廓检测上   
  2. //By MoreWindows (http://blog.csdn.net/MoreWindows)   
  3. #include <opencv2/opencv.hpp>   
  4. using namespace std;  
  5. #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")   
  6. int main( int argc, char** argv )  
  7. {     
  8.     const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";  
  9.     const char *pstrWindowsOutLineTitle = "轮廓图(http://blog.csdn.net/MoreWindows)";  
  10.       
  11.     const int IMAGE_WIDTH = 400;  
  12.     const int IMAGE_HEIGHT = 200;  
  13.   
  14.     // 创建图像   
  15.     IplImage *pSrcImage = cvCreateImage(cvSize(IMAGE_WIDTH, IMAGE_HEIGHT), IPL_DEPTH_8U, 3);  
  16.     // 填充成白色   
  17.     cvRectangle(pSrcImage, cvPoint(0, 0), cvPoint(pSrcImage->width, pSrcImage->height), CV_RGB(255, 255, 255), CV_FILLED);  
  18.     // 画圆   
  19.     CvPoint ptCircleCenter = cvPoint(IMAGE_WIDTH / 4, IMAGE_HEIGHT / 2);  
  20.     int nRadius = 80;  
  21.     cvCircle(pSrcImage, ptCircleCenter, nRadius, CV_RGB(255, 255, 0), CV_FILLED);  
  22.     ptCircleCenter = cvPoint(IMAGE_WIDTH / 4, IMAGE_HEIGHT / 2);  
  23.     nRadius = 30;  
  24.     cvCircle(pSrcImage, ptCircleCenter, nRadius, CV_RGB(255, 255, 255), CV_FILLED);  
  25.     // 画矩形   
  26.     CvPoint ptLeftTop = cvPoint(IMAGE_WIDTH / 2 + 20, 20);  
  27.     CvPoint ptRightBottom = cvPoint(IMAGE_WIDTH - 20, IMAGE_HEIGHT - 20);  
  28.     cvRectangle(pSrcImage, ptLeftTop, ptRightBottom, CV_RGB(0, 255, 255), CV_FILLED);  
  29.     ptLeftTop = cvPoint(IMAGE_WIDTH / 2 + 60, 40);  
  30.     ptRightBottom = cvPoint(IMAGE_WIDTH - 60, IMAGE_HEIGHT - 40);  
  31.     cvRectangle(pSrcImage, ptLeftTop, ptRightBottom, CV_RGB(255, 255, 255), CV_FILLED);  
  32.     // 显示原图   
  33.     cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);  
  34.     cvShowImage(pstrWindowsSrcTitle, pSrcImage);  
  35.   
  36.   
  37.     // 转为灰度图   
  38.     IplImage *pGrayImage =  cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 1);  
  39.     cvCvtColor(pSrcImage, pGrayImage, CV_BGR2GRAY);  
  40.     // 转为二值图   
  41.     IplImage *pBinaryImage = cvCreateImage(cvGetSize(pGrayImage), IPL_DEPTH_8U, 1);  
  42.     cvThreshold(pGrayImage, pBinaryImage, 250, 255, CV_THRESH_BINARY);  
  43.   
  44.   
  45.     // 检索轮廓并返回检测到的轮廓的个数   
  46.     CvMemStorage *pcvMStorage = cvCreateMemStorage();  
  47.     CvSeq *pcvSeq = NULL;  
  48.     cvFindContours(pBinaryImage, pcvMStorage, &pcvSeq, sizeof(CvContour), CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0));  
  49.       
  50.     // 画轮廓图   
  51.     IplImage *pOutlineImage = cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 3);  
  52.     int nLevels = 5;  
  53.     // 填充成白色   
  54.     cvRectangle(pOutlineImage, cvPoint(0, 0), cvPoint(pOutlineImage->width, pOutlineImage->height), CV_RGB(255, 255, 255), CV_FILLED);  
  55.     cvDrawContours(pOutlineImage, pcvSeq, CV_RGB(255,0,0), CV_RGB(0,255,0), nLevels, 2);  
  56.     // 显示轮廓图   
  57.     cvNamedWindow(pstrWindowsOutLineTitle, CV_WINDOW_AUTOSIZE);  
  58.     cvShowImage(pstrWindowsOutLineTitle, pOutlineImage);  
  59.   
  60.   
  61.     cvWaitKey(0);  
  62.   
  63.     cvReleaseMemStorage(&pcvMStorage);  
  64.   
  65.     cvDestroyWindow(pstrWindowsSrcTitle);  
  66.     cvDestroyWindow(pstrWindowsOutLineTitle);  
  67.     cvReleaseImage(&pSrcImage);  
  68.     cvReleaseImage(&pGrayImage);  
  69.     cvReleaseImage(&pBinaryImage);  
  70.     cvReleaseImage(&pOutlineImage);  
  71.     return 0;  
  72. }  
//图像的轮廓检测上
//By MoreWindows (http://blog.csdn.net/MoreWindows)
#include <opencv2/opencv.hpp>
using namespace std;
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
int main( int argc, char** argv )
{	
	const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";
	const char *pstrWindowsOutLineTitle = "轮廓图(http://blog.csdn.net/MoreWindows)";
	
	const int IMAGE_WIDTH = 400;
	const int IMAGE_HEIGHT = 200;

	// 创建图像
	IplImage *pSrcImage = cvCreateImage(cvSize(IMAGE_WIDTH, IMAGE_HEIGHT), IPL_DEPTH_8U, 3);
	// 填充成白色
	cvRectangle(pSrcImage, cvPoint(0, 0), cvPoint(pSrcImage->width, pSrcImage->height), CV_RGB(255, 255, 255), CV_FILLED);
	// 画圆
	CvPoint ptCircleCenter = cvPoint(IMAGE_WIDTH / 4, IMAGE_HEIGHT / 2);
	int nRadius = 80;
	cvCircle(pSrcImage, ptCircleCenter, nRadius, CV_RGB(255, 255, 0), CV_FILLED);
	ptCircleCenter = cvPoint(IMAGE_WIDTH / 4, IMAGE_HEIGHT / 2);
	nRadius = 30;
	cvCircle(pSrcImage, ptCircleCenter, nRadius, CV_RGB(255, 255, 255), CV_FILLED);
	// 画矩形
	CvPoint ptLeftTop = cvPoint(IMAGE_WIDTH / 2 + 20, 20);
	CvPoint ptRightBottom = cvPoint(IMAGE_WIDTH - 20, IMAGE_HEIGHT - 20);
	cvRectangle(pSrcImage, ptLeftTop, ptRightBottom, CV_RGB(0, 255, 255), CV_FILLED);
	ptLeftTop = cvPoint(IMAGE_WIDTH / 2 + 60, 40);
	ptRightBottom = cvPoint(IMAGE_WIDTH - 60, IMAGE_HEIGHT - 40);
	cvRectangle(pSrcImage, ptLeftTop, ptRightBottom, CV_RGB(255, 255, 255), CV_FILLED);
	// 显示原图
	cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);
	cvShowImage(pstrWindowsSrcTitle, pSrcImage);


	// 转为灰度图
	IplImage *pGrayImage =  cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 1);
	cvCvtColor(pSrcImage, pGrayImage, CV_BGR2GRAY);
	// 转为二值图
	IplImage *pBinaryImage = cvCreateImage(cvGetSize(pGrayImage), IPL_DEPTH_8U, 1);
	cvThreshold(pGrayImage, pBinaryImage, 250, 255, CV_THRESH_BINARY);


	// 检索轮廓并返回检测到的轮廓的个数
	CvMemStorage *pcvMStorage = cvCreateMemStorage();
	CvSeq *pcvSeq = NULL;
	cvFindContours(pBinaryImage, pcvMStorage, &pcvSeq, sizeof(CvContour), CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0));
	
	// 画轮廓图
	IplImage *pOutlineImage = cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 3);
	int nLevels = 5;
	// 填充成白色
	cvRectangle(pOutlineImage, cvPoint(0, 0), cvPoint(pOutlineImage->width, pOutlineImage->height), CV_RGB(255, 255, 255), CV_FILLED);
	cvDrawContours(pOutlineImage, pcvSeq, CV_RGB(255,0,0), CV_RGB(0,255,0), nLevels, 2);
	// 显示轮廓图
	cvNamedWindow(pstrWindowsOutLineTitle, CV_WINDOW_AUTOSIZE);
	cvShowImage(pstrWindowsOutLineTitle, pOutlineImage);


	cvWaitKey(0);

	cvReleaseMemStorage(&pcvMStorage);

	cvDestroyWindow(pstrWindowsSrcTitle);
	cvDestroyWindow(pstrWindowsOutLineTitle);
	cvReleaseImage(&pSrcImage);
	cvReleaseImage(&pGrayImage);
	cvReleaseImage(&pBinaryImage);
	cvReleaseImage(&pOutlineImage);
	return 0;
}

运行结果如下图所示：

由图可以看出，轮廓线已经按层次交替的绘制成功了，读者可以修改程序中的cvDrawContours中的nLevels参数，看看图形会有什么变化。

OpenCV入门指南】第六篇 轮廓检测 下

上一篇《【OpenCV入门指南】第五篇轮廓检测上》介绍了cvFindContours函数和cvDrawContours函数，并作了一个简单的使用示范。本篇将展示一个实例，让大家对轮廓检测有个更加深入的认识。

 

代码如下：

[cpp] view plain copy print ?
  1. //图像的轮廓检测下   
  2. //By MoreWindows (http://blog.csdn.net/MoreWindows)   
  3. #include <opencv2/opencv.hpp>   
  4. using namespace std;  
  5. #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")   
  6. IplImage *g_pGrayImage = NULL;  
  7. const char *pstrWindowsBinaryTitle = "二值图(http://blog.csdn.net/MoreWindows)";  
  8. const char *pstrWindowsOutLineTitle = "轮廓图(http://blog.csdn.net/MoreWindows)";  
  9. CvSeq *g_pcvSeq = NULL;  
  10.   
  11. void on_trackbar(int pos)  
  12. {  
  13.     // 转为二值图   
  14.     IplImage *pBinaryImage = cvCreateImage(cvGetSize(g_pGrayImage), IPL_DEPTH_8U, 1);  
  15.     cvThreshold(g_pGrayImage, pBinaryImage, pos, 255, CV_THRESH_BINARY);  
  16.     // 显示二值图   
  17.     cvShowImage(pstrWindowsBinaryTitle, pBinaryImage);  
  18.   
  19.     CvMemStorage* cvMStorage = cvCreateMemStorage();  
  20.     // 检索轮廓并返回检测到的轮廓的个数   
  21.     cvFindContours(pBinaryImage,cvMStorage, &g_pcvSeq);  
  22.   
  23.     IplImage *pOutlineImage = cvCreateImage(cvGetSize(g_pGrayImage), IPL_DEPTH_8U, 3);  
  24.     int _levels = 5;  
  25.     cvZero(pOutlineImage);  
  26.     cvDrawContours(pOutlineImage, g_pcvSeq, CV_RGB(255,0,0), CV_RGB(0,255,0), _levels);  
  27.     cvShowImage(pstrWindowsOutLineTitle, pOutlineImage);  
  28.   
  29.     cvReleaseMemStorage(&cvMStorage);  
  30.     cvReleaseImage(&pBinaryImage);  
  31.     cvReleaseImage(&pOutlineImage);  
  32. }  
  33.   
  34. int main( int argc, char** argv )  
  35. {     
  36.     const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";  
  37.     const char *pstrWindowsToolBarName = "二值化";  
  38.   
  39.     // 从文件中加载原图   
  40.     IplImage *pSrcImage = cvLoadImage("003.jpg", CV_LOAD_IMAGE_UNCHANGED);  
  41.     // 显示原图   
  42.     cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);  
  43.     cvShowImage(pstrWindowsSrcTitle, pSrcImage);  
  44.   
  45.     // 转为灰度图   
  46.     g_pGrayImage =  cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 1);  
  47.     cvCvtColor(pSrcImage, g_pGrayImage, CV_BGR2GRAY);  
  48.   
  49.     // 创建二值图和轮廓图窗口   
  50.     cvNamedWindow(pstrWindowsBinaryTitle, CV_WINDOW_AUTOSIZE);  
  51.     cvNamedWindow(pstrWindowsOutLineTitle, CV_WINDOW_AUTOSIZE);  
  52.   
  53.   
  54.     // 滑动条     
  55.     int nThreshold = 0;  
  56.     cvCreateTrackbar(pstrWindowsToolBarName, pstrWindowsBinaryTitle, &nThreshold, 254, on_trackbar);  
  57.   
  58.     on_trackbar(1);  
  59.   
  60.     cvWaitKey(0);  
  61.   
  62.     cvDestroyWindow(pstrWindowsSrcTitle);  
  63.     cvDestroyWindow(pstrWindowsBinaryTitle);  
  64.     cvDestroyWindow(pstrWindowsOutLineTitle);  
  65.     cvReleaseImage(&pSrcImage);  
  66.     cvReleaseImage(&g_pGrayImage);  
  67.     return 0;  
  68. }  
//图像的轮廓检测下
//By MoreWindows (http://blog.csdn.net/MoreWindows)
#include <opencv2/opencv.hpp>
using namespace std;
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
IplImage *g_pGrayImage = NULL;
const char *pstrWindowsBinaryTitle = "二值图(http://blog.csdn.net/MoreWindows)";
const char *pstrWindowsOutLineTitle = "轮廓图(http://blog.csdn.net/MoreWindows)";
CvSeq *g_pcvSeq = NULL;

void on_trackbar(int pos)
{
	// 转为二值图
	IplImage *pBinaryImage = cvCreateImage(cvGetSize(g_pGrayImage), IPL_DEPTH_8U, 1);
	cvThreshold(g_pGrayImage, pBinaryImage, pos, 255, CV_THRESH_BINARY);
	// 显示二值图
	cvShowImage(pstrWindowsBinaryTitle, pBinaryImage);

	CvMemStorage* cvMStorage = cvCreateMemStorage();
	// 检索轮廓并返回检测到的轮廓的个数
	cvFindContours(pBinaryImage,cvMStorage, &g_pcvSeq);

	IplImage *pOutlineImage = cvCreateImage(cvGetSize(g_pGrayImage), IPL_DEPTH_8U, 3);
	int _levels = 5;
	cvZero(pOutlineImage);
	cvDrawContours(pOutlineImage, g_pcvSeq, CV_RGB(255,0,0), CV_RGB(0,255,0), _levels);
	cvShowImage(pstrWindowsOutLineTitle, pOutlineImage);

	cvReleaseMemStorage(&cvMStorage);
	cvReleaseImage(&pBinaryImage);
	cvReleaseImage(&pOutlineImage);
}

int main( int argc, char** argv )
{	
	const char *pstrWindowsSrcTitle = "原图(http://blog.csdn.net/MoreWindows)";
	const char *pstrWindowsToolBarName = "二值化";

	// 从文件中加载原图
	IplImage *pSrcImage = cvLoadImage("003.jpg", CV_LOAD_IMAGE_UNCHANGED);
	// 显示原图
	cvNamedWindow(pstrWindowsSrcTitle, CV_WINDOW_AUTOSIZE);
	cvShowImage(pstrWindowsSrcTitle, pSrcImage);

	// 转为灰度图
	g_pGrayImage =  cvCreateImage(cvGetSize(pSrcImage), IPL_DEPTH_8U, 1);
	cvCvtColor(pSrcImage, g_pGrayImage, CV_BGR2GRAY);

    // 创建二值图和轮廓图窗口
	cvNamedWindow(pstrWindowsBinaryTitle, CV_WINDOW_AUTOSIZE);
	cvNamedWindow(pstrWindowsOutLineTitle, CV_WINDOW_AUTOSIZE);


	// 滑动条	
	int nThreshold = 0;
	cvCreateTrackbar(pstrWindowsToolBarName, pstrWindowsBinaryTitle, &nThreshold, 254, on_trackbar);

	on_trackbar(1);

	cvWaitKey(0);

	cvDestroyWindow(pstrWindowsSrcTitle);
	cvDestroyWindow(pstrWindowsBinaryTitle);
	cvDestroyWindow(pstrWindowsOutLineTitle);
	cvReleaseImage(&pSrcImage);
	cvReleaseImage(&g_pGrayImage);
	return 0;
}

程序运行结果如下所示：

可以明显看出，由于图像的二值化处理只是根据图像中单个像素的值来决定，因此这种最简单轮廓检测所产生的结果和人眼观测的实际感觉肯定是有比较大的区别的。

 

轮廓检测另外还有一个重要的函数cvApproxPoly，它的函数原型如下所示

CVAPI(CvSeq*)  cvApproxPoly(

  const void* src_seq,

  int header_size,

  CvMemStorage* storage,

  int method,

  double parameter,

  int parameter2 CV_DEFAULT(0)

);

cvApproxPoly的学习

这是一个轮廓的多边形轮廓逼近函数，这个函数用指定精度逼近一个或多个 曲线，并返回逼近结果。一开始觉得这个函数没什么必要，因为如果只是要简单的提取和显示图像轮廓的话只要cvFindContours函数就够了，那么为什么还要这个函数呢？后来百度了下，在opencv论坛上找到了答案。

首先，轮廓的多边形逼近指的是：使用多边形来近似表示一个轮廓。其次，多边形逼近的目的是为了减少轮廓的顶点数目。但多边形逼近的结果依然是一个轮廓，只是这个轮廓相对要粗旷一些。

下面看下测试代码：

#include<cv.h>   
  1. #include<highgui.h>   
  2.   
  3. int main()  
  4. {  
  5.     IplImage* src = NULL;  
  6.     IplImage* img = NULL;  
  7.     IplImage* dst = NULL;  
  8.   
  9.     CvMemStorage* storage = cvCreateMemStorage (0);  
  10.     CvMemStorage* storage1 = cvCreateMemStorage (0);  
  11.     CvSeq* contour = 0;  
  12.     CvSeq* cont;  
  13.     CvSeq* mcont;  
  14.   
  15.     src = cvLoadImage ("8.jpg", 1);  
  16.     img = cvCreateImage (cvGetSize(src), IPL_DEPTH_8U, 1);  
  17.     dst = cvCreateImage (cvGetSize(src), src->depth, src->nChannels);  
  18.   
  19.     cvCvtColor (src, img, CV_BGR2GRAY);  
  20.     cvThreshold (img, img, 100, 200, CV_THRESH_BINARY);  
  21.       
  22.     cvFindContours (img, storage, &contour, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);  
  23.       
  24.     if (contour)  
  25.     {  
  26.         CvTreeNodeIterator iterator;  
  27.         cvInitTreeNodeIterator (&iterator, contour,  1);  
  28.         while (0 != (cont = (CvSeq*)cvNextTreeNode (&iterator)))  
  29.         {  
  30.             mcont = cvApproxPoly (cont, sizeof(CvContour), storage1, CV_POLY_APPROX_DP, cvContourPerimeter(cont)*0.02,0);  
  31.             cvDrawContours (dst, mcont, CV_RGB(255,0,0),CV_RGB(0,0,100),1,2,8,cvPoint(0,0));  
  32.         }  
  33.     }  
  34.   
  35.     cvNamedWindow ("Contour", 1);  
  36.     cvShowImage ("Contour", dst);  
  37.   
  38.     cvWaitKey (0);  
  39.   
  40.     cvReleaseMemStorage (&storage);  
  41.     cvReleaseImage (&src);  
  42.     cvReleaseImage (&img);  
  43.     cvReleaseImage (&dst);  
  44.   
  45.     return 0;  
  46. }  
#include<cv.h>
#include<highgui.h>

int main()
{
	IplImage* src = NULL;
	IplImage* img = NULL;
	IplImage* dst = NULL;

	CvMemStorage* storage = cvCreateMemStorage (0);
	CvMemStorage* storage1 = cvCreateMemStorage (0);
	CvSeq* contour = 0;
	CvSeq* cont;
	CvSeq* mcont;

	src = cvLoadImage ("8.jpg", 1);
	img = cvCreateImage (cvGetSize(src), IPL_DEPTH_8U, 1);
	dst = cvCreateImage (cvGetSize(src), src->depth, src->nChannels);

	cvCvtColor (src, img, CV_BGR2GRAY);
	cvThreshold (img, img, 100, 200, CV_THRESH_BINARY);
	
	cvFindContours (img, storage, &contour, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
	
	if (contour)
	{
		CvTreeNodeIterator iterator;
    	cvInitTreeNodeIterator (&iterator, contour,  1);
		while (0 != (cont = (CvSeq*)cvNextTreeNode (&iterator)))
		{
			mcont = cvApproxPoly (cont, sizeof(CvContour), storage1, CV_POLY_APPROX_DP, cvContourPerimeter(cont)*0.02,0);
			cvDrawContours (dst, mcont, CV_RGB(255,0,0),CV_RGB(0,0,100),1,2,8,cvPoint(0,0));
		}
	}

	cvNamedWindow ("Contour", 1);
	cvShowImage ("Contour", dst);

	cvWaitKey (0);

	cvReleaseMemStorage (&storage);
	cvReleaseImage (&src);
	cvReleaseImage (&img);
	cvReleaseImage (&dst);

	return 0;
}


源图：

           


多边形逼近的结果图：                                               直接用cvFindContours得到的轮廓图


                     


对比两个图（轮廓颜色不用管），可以发现多边形逼近的结果确实相对粗旷点。

 

wwl33695
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv 入门指南
10-18
opencv 开发指南，计算机视觉基础
【OpenCV】第九章: 图像梯度
因为热爱所以坚持
12-06 1655
第九章: 图像梯度 图像梯度是用来做边缘检测的一种方法。为什么要检测边缘？ 比如自动驾驶里面，我们至少要做的一个工作就是道路的边缘检测，只有正确的检测到道路的边缘我们的车才会行驶在道路上而不是开到马路牙子外。 或者从另一个角度解释，我们做边缘检测不是让人眼去欣赏一张道路图片里面的道路边缘的，我们正确检测出一张图像的边缘是为了让模型更好的去认识这张图片中的道路。所以精确的边缘检测可以帮助电脑模型很好的识别这是道路还是道路外面，从而做出正确的反馈——指导汽车正确行使。 图像梯度的原理： 梯度是微积分中的概
【Python入门教程】OpenCV库简介
Remote Sensing迷途小书童
06-19 1万+
Opencv（Open Source Computer Vision Library）是一个基于开源发行的跨平台计算机视觉库，它实现了图像处理和计算机视觉方面的很多通用算法，已成为计算机视觉领域最有力的研究工具。在这里我们要区分两个概念：图像处理和计算机视觉的区别：图像处理侧重于“处理”图像–如增强，还原，去噪，分割等等；而计算机视觉重点在于使用计算机来模拟人的视觉，因此模拟才是计算机视觉领域的最终目标。   OpenCV用C++语言编写，它具有C ++，Python，Java和MATLAB接口，并支持Wi
什么是OpenCV，它有什么作用？
gp16674213804的博客
03-07 2万+
OpenCV可以用于处理数字图像和视频数据，其功能包括图像和视频的读取、写入、显示、变换、滤波、特征提取、目标检测、人脸识别、物体跟踪、相机标定、三维重建、机器学习等。
OpenCV教程：超详细的OpenCV入门教程，值得收藏
pythonandaiot的博客
05-10 11万+
OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它提供了很多函数，这些函数非常高效地实现了计算机视觉算法（最基本的滤波到高级的物体检测皆有涵盖）。 OpenCV 使用 C/C++ 开发，同时也提供了 Python、Java、MATLAB 等其他语言的接口。 OpenCV 是跨平台的，可以在Windows、Linux、Mac OS、Android、iOS 等操作系统上运行。 OpenCV 的应用领域非常广泛，包括图像拼接、图像降噪、产品质检、..
聊聊python-opencv那些入门必会基础的操作
qq1096425930的博客
02-10 2879
1 . 环境 （1）. opencv 3.2.0 （可以输入pkg-config --modversion opencv来查看安装的opencv版本） （2）. Ubuntu18.04.6 LTS（可以输入lsb_release -a或者uname -a来查看系统版本） 2 . opencv是啥？ 一句话带过，开源的计算机视觉应用库，几乎所有的视觉处理都用到了opencv，很多图像处理软件比如美图秀秀之类的，都是基于opencv对图像进行处理。 3 . opencv基础方法（函数）的应用（pyth
opencv python指南
03-29
讲述使用python语言调用Opencv库进行图像处理，是比较基础和全面的入门教程。
计算机视觉+OpenCV+Python教程+入门指南
最新发布
01-04
计算机视觉+OpenCV+Python教程+入门指南 算机视觉+OpenCV+项目资源+实战案例 计算机视觉+OpenCV+面试题+知识点总结 计算机视觉+OpenCV+面试题+知识点总结 计算机视觉+OpenCV+面试题+知识点总结 计算机视觉+OpenCV+...
OpenCV 即时入门（初译）
06-21
贡献指南 本项目需要校对，欢迎大家提交 Pull Request。 请您勇敢地去翻译和改进翻译。虽然我们追求卓越，但我们并不要求您做到十全十美，因此请不要担心因为翻译上犯错——在大部分情况下，我们的服务器已经记录...
OpenCV学习指南(四)图像滤波算法
12-21
  本文将是一篇为图像处理的初学者准备的滤波算法的入门文章。理论在前，代码在后。 算法 高斯滤波算法   一维高斯函数 G(x)=12πe−x22σ2 G(x) = \frac{1}{\sqrt{2\pi }}e^{-\frac{x^{2}}{2\sigma ^{2}}} G(x)...
图像处理 OpenCV简介
mengxianglong123的博客
07-18 1万+
OpenCV是一款由Intel公司俄罗斯团队发起并参与和维护的一个计算机视觉处理开源软件库，支持与计算机视觉和机器学习相关的众多算法，并且正在日益扩展。OpenCV的优势编程语言OpenCV基于C++实现，同时提供python,Ruby,Matlab等语言的接口。OpenCV-Python是OpenCV的PythonAPI，结合了OpenCVC++API和Python语言的最佳特性。跨平台可以在不同的系统平台上使用，包括Windows，Linux，OSX，Android和iOS。...
opencv入门 - 显示图像学习总结
bcbobo21cn的专栏
03-14 3852
OpenCV的第一个小程序-读取图像并显示 首先新建一个VC++控制台项目如下图所示。本文项目名称helloOpenCV。 在主文件中添加如下代码： #include "stdafx.h"   #include   using namespace std; using namespace cv;   int main(int argc, char* argv[])
C语言中const char* 和char* const等常量的正确理解
我逍遥的博客
07-13 1万+
不经常使用const的话，看过多少次都会忘记。让人很是郁闷！今天总结一下，找出规律便于以后记忆。 const char *p; //*p是const,p可变：const 后面紧跟的是char，所以*p是一个char字符，不可变 const (char *) p;//p是const,*p可变：const 后面紧跟的是（char *）这个整体，所以p是char*类型，不可变。 char* con
OpenCV3入门教程（一）基础知识
韦访的专栏
10-12 4万+
------韦访 20181011 1、概述 想学习图像处理，不管是机器学习也好，深度学习也好，不会点OpenCV好像有点说不过去吧？所以，现在开始OpenCV的学习。 2、读写图片 先从图片的读写开始，opencv读取图片的函数是imread，默认情况下，imread函数返回BGR格式的图像，可以用imwrite函数将数据写到本地。下面的代码会将JPG图片转成PNG。 import ...
OpenCV简介
半濠春水的博客
10-04 1万+
1. OpenCV简介   OpenCV的全称是Open Source Computer Vision Library，是一个跨平台的计算机视觉处理开源软件库，是由Intel公司俄罗斯团队发起并参与和维护，支持与计算机视觉和机器学习相关的众多算法，以BSD许可证授权发行，可以在商业和研究领域中免费使用。OpenCV可用于开发实时的图像处理、计算机视觉以及模式识别程序，该程序库也可以使用英特尔公司的IPP进行加速处理。 1.1 OpenCV的优势： 编程语言 OpenCV基于C++实现，同时提供pyth.
[OpenCV3函数] —— destroyWindow
Anoyer的博客
06-02 3283
destroyWindow 头文件：opencv2/highgui/highgui.hpp 作用： 关闭指定窗口 函数原型： void destroyWindow(const string& winname); 参数1 winname ,需要关闭的窗口的名称 示例： #include<iostream> #include<opencv2/highgui/highgui.hpp> using namespace std; int main(int argc,char **
C++中const char * const name;char * const name;cons
weixin_34384681的博客
11-05 1257
2019独角兽企业重金招聘Python工程师标准>>> ...
VS2017配置opencv教程（超详细！！！）
热门推荐
Chosen One
06-03 35万+
前言：刚开始是不打算写这篇博客的，但是我最近为了完成对老师布置的区域生长算法，强行要配置一波opencv，因为换了电脑，所以选择了有黑黑主题酷酷的VS2017，但无奈网上的博客关于vs2017配置Opencv不够全（vs2010配置opencv的倒是贼多！），我当时是看了将近10篇文章才配置成功，所以在此我来从一个新入坑的角度来说一下怎么完整的配置一个OPencv！下面就分步来进行说明吧！ ...
opencv 4快速入门 pan
06-06
好的，我可以为您提供OpenCV 4的快速入门指南。以下是一些基本步骤： 1. 安装OpenCV 4 安装OpenCV 4可以通过使用包管理器，如apt-get或yum，或者从OpenCV官方网站下载源代码并手动编译。确保安装了OpenCV的所有依赖...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值