opencv漫水填充法。

红太狼 2022-08-07 10:48 153阅读 0赞

向浅墨学习。

> ## 本系列文章由[@浅墨\_毛星云][Link 1]出品，转载请注明出处。   文章链接：[http://blog.csdn.net/poem\_qianmo/article/details/28261997][http_blog.csdn.net_poem_qianmo_article_details_28261997]  **作者：毛星云（浅墨）** 微博：[http://weibo.com/u/1723155442][http_weibo.com_u_1723155442]  知乎：[http://www.zhihu.com/people/mao-xing-yun][http_www.zhihu.com_people_mao-xing-yun]  **邮箱：****[happylifemxy@163.com][happylifemxy_163.com]**     写作当前博文时配套使用的OpenCV版本：**2.4.9**    ##
> 
>   
> 
> 
>   
> 
> 
> 本篇文章中，我们一起探讨了OpenCV填充算法中漫水填充算法相关的知识点，以及了解了OpenCV中实现漫水填充算法的两个版本的floodFill函数的使用方法。此篇博文一共有两个个配套的示例程序，其详细注释过的代码都在文中贴出，且文章最后提供了综合示例程序的下载。
> 
> 先尝鲜一下最终示例程序的运行截图吧，这个示例程序实现了类似于PhotoShop中魔棒的图像处理效果，我们可以用鼠标对窗口中的图片一顿狂点，得到一片一片的彩色区域：
> 
> ![SouthEast][] ![SouthEast 1][]
> 
>  效果图原始图
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
>   
> 
> 
> 一、引言 · 漫水填充的定义
> 
>   
> 
> 
>   
> 
> 
> 漫水填充法是一种用特定的颜色填充联通区域，通过设置可连通像素的上下限以及连通方式来达到不同的填充效果的方法。漫水填充经常被用来标记或分离图像的一部分以便对其进行进一步处理或分析，也可以用来从输入图像获取掩码区域，掩码会加速处理过程，或只处理掩码指定的像素点，操作的结果总是某个连续的区域。
> 
> 另外，floodfill官方译作“漫水填充”，但是浅墨总是喜欢说成“水漫填充”，因为受从小到大深入骨髓的“水漫金山”这个成语的影响，囧。
> 
>   
> 
> 
> 二、漫水填充法的基本思想
> 
>   
> 
> 
>   
> 
> 
> 所谓漫水填充，简单来说，就是自动选中了和种子点相连的区域，接着将该区域替换成指定的颜色，这是个非常有用的功能,经常用来标记或者分离图像的一部分进行处理或分析.漫水填充也可以用来从输入图像获取掩码区域,掩码会加速处理过程,或者只处理掩码指定的像素点.
> 
> 以此填充算法为基础，类似photoshop的魔术棒选择工具就很容易实现了。漫水填充（FloodFill）是查找和种子点联通的颜色相同的点，魔术棒选择工具则是查找和种子点联通的颜色相近的点，将和初始种子像素颜色相近的点压进栈作为新种子
> 
> 在OpenCV中，漫水填充是填充算法中最通用的方法。且在OpenCV 2.X中，使用C++重写过的FloodFill函数有两个版本。一个不带掩膜mask的版本，和一个带mask的版本。这个掩膜mask，就是用于进一步控制哪些区域将被填充颜色（比如说当对同一图像进行多次填充时）。这两个版本的FloodFill，都必须在图像中选择一个种子点，然后把临近区域所有相似点填充上同样的颜色，不同的是，不一定将所有的邻近像素点都染上同一颜色，漫水填充操作的结果总是某个连续的区域。当邻近像素点位于给定的范围（从loDiff到upDiff）内或在原始seedPoint像素值范围内时，FloodFill函数就会为这个点涂上颜色。
> 
>   
> 
> 
> ## 三、floodFill函数详解 ##
> 
>   
> 
> 
>   
> 
> 
> 在OpenCV中，漫水填充算法由floodFill函数实现，其作用是用我们指定的颜色从种子点开始填充一个连接域。连通性由像素值的接近程度来衡量。OpenCV2.X有两个C++重写版本的floodFill。
> 
>   
> 
> 
> 第一个版本的floodFill：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  **int** floodFill(InputOutputArray image, Point seedPoint, Scalar newVal, Rect\* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), **int** flags=4 ) 
> 
>   
> 
> 
> 第二个版本的floodFill：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  **int** floodFill(InputOutputArray image, InputOutputArray mask, Point seedPoint,Scalar newVal, Rect\* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), **int** flags=4 ) 
> 
>   
> 
> 
> 下面是一起介绍的参数详解。除了第二个参数外，其他的参数都是共用的。
> 
>  *  第一个参数，InputOutputArray类型的image, 输入/输出1通道或3通道，8位或浮点图像，具体参数由之后的参数具体指明。
>  *  第二个参数， InputOutputArray类型的mask，这是第二个版本的floodFill独享的参数，表示操作掩模,。它应该为单通道、8位、长和宽上都比输入图像 image 大两个像素点的图像。第二个版本的floodFill需要使用以及更新掩膜，所以这个mask参数我们一定要将其准备好并填在此处。需要注意的是，漫水填充不会填充掩膜mask的非零像素区域。例如，一个边缘检测算子的输出可以用来作为掩膜，以防止填充到边缘。同样的，也可以在多次的函数调用中使用同一个掩膜，以保证填充的区域不会重叠。另外需要注意的是，掩膜mask会比需填充的图像大，所以 mask 中与输入图像(x,y)像素点相对应的点的坐标为(x+1,y+1)。
>  *  第三个参数，Point类型的seedPoint，漫水填充算法的起始点。
>  *  第四个参数，Scalar类型的newVal，像素点被染色的值，即在重绘区域像素的新值。
>  *  第五个参数，Rect\*类型的rect，有默认值0，一个可选的参数，用于设置floodFill函数将要重绘区域的最小边界矩形区域。
>  *  第六个参数，Scalar类型的loDiff，有默认值Scalar( )，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间的亮度或颜色之负差（lower brightness/color difference）的最大值。
>  *  第七个参数，Scalar类型的upDiff，有默认值Scalar( )，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间的亮度或颜色之正差（lower brightness/color difference）的最大值。
>  *  第八个参数，int类型的flags，操作标志符，此参数包含三个部分，比较复杂，我们一起详细看看。
> 
>   
> 
> 
>  *  **低八位**（第0~7位）用于控制算法的连通性，可取4 (4为缺省值) 或者 8。如果设为4，表示填充算法只考虑当前像素水平方向和垂直方向的相邻点；如果设为 8，除上述相邻点外，还会包含对角线方向的相邻点。
>  *  **高八位**部分（16~23位）可以为0 或者如下两种选项标识符的组合：

>  *  FLOODFILL\_FIXED\_RANGE\- 如果设置为这个标识符的话，就会考虑当前像素与种子像素之间的差，否则就考虑当前像素与其相邻像素的差。也就是说，这个范围是浮动的。
>  *  FLOODFILL\_MASK\_ONLY \- 如果设置为这个标识符的话，函数不会去填充改变原始图像 (也就是忽略第三个参数newVal), 而是去填充掩模图像（mask）。这个标识符只对第二个版本的floodFill有用，因第一个版本里面压根就没有mask参数。

> >   
> >

>  *  **中间八位**部分，上面关于高八位FLOODFILL\_MASK\_ONLY标识符中已经说的很明显，需要输入符合要求的掩码。Floodfill的flags参数的中间八位的值就是用于指定填充掩码图像的值的。但如果flags中间八位的值为0，则掩码会用1来填充。

> > 而所有flags可以用or操作符连接起来，即“|”。例如，如果想用8邻域填充，并填充固定像素值范围，填充掩码而不是填充源图像，以及设填充值为38，那么输入的参数是这样：
> > 
> > **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> > 
> > 1.  flags=8 | FLOODFILL\_MASK\_ONLY | FLOODFILL\_FIXED\_RANGE | （38<<8） 
> > 
> >   
> >

>   
> 
> 
> 接着，来看一个关于Floodfill的简单的调用范例：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【头文件包含部分】--------------------------------------- 
> 2.  // 描述：包含程序所依赖的头文件 
> 3.  //---------------------------------------------------------------------------------------------- 
> 4.  \#include <opencv2/opencv.hpp> 
> 5.  \#include <opencv2/imgproc/imgproc.hpp> 
> 6.  
> 7.  //-----------------------------------【命名空间声明部分】--------------------------------------- 
> 8.  // 描述：包含程序所使用的命名空间 
> 9.  //----------------------------------------------------------------------------------------------- 
> 10. **using****namespace** cv; 
> 11. //-----------------------------------【main( )函数】-------------------------------------------- 
> 12. // 描述：控制台应用程序的入口函数，我们的程序从这里开始 
> 13. //----------------------------------------------------------------------------------------------- 
> 14. 
> 15. **int** main( ) 
> 16. \{ 
> 17.  Mat src = imread("1.jpg"); 
> 18.  imshow("【原始图】",src); 
> 19.  Rect ccomp; 
> 20.  floodFill(src, Point(50,300), Scalar(155, 255,55), &ccomp, Scalar(20, 20, 20),Scalar(20, 20, 20)); 
> 21.  imshow("【效果图】",src); 
> 22.  waitKey(0); 
> 23. **return** 0; 
> 24. \} 
> 
>  运行截图，原始图：
> 
>   
> 
> 
> ![SouthEast 2][]  
> 
> 
> 效果图：
> 
> ![SouthEast 3][]  
> 
> 
> ### 五、floodFill函数在OpenCV中的实现源代码 ###
> 
>   
> 
> 
>   
> 
> 
> 这个部分贴出OpenCV中本文相关函数的源码实现细节，来给想了解实现细节的小伙伴们参考。浅墨暂时不在源码的细节上挖深作详细注释。
> 
>   
> 
> 
> ### 5.1OpenCV2.X中两个版本的floodFill函数源码 ###
> 
> ### 第一个，不带mask版本的floodFill： ###
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  **int** cv::floodFill( InputOutputArray \_image,Point seedPoint, 
> 2.   Scalar newVal, Rect\* rect, 
> 3.   Scalar loDiff, ScalarupDiff, **int** flags ) 
> 4.  \{ 
> 5.   CvConnectedComp ccomp; 
> 6.   CvMat c\_image = \_image.getMat(); 
> 7.   cvFloodFill(&c\_image, seedPoint, newVal, loDiff, upDiff, &ccomp,flags, 0); 
> 8.  **if**( rect ) 
> 9.   \*rect = ccomp.rect; 
> 10. **return** cvRound(ccomp.area); 
> 11. \} 
> 
>   
> 
> 
> ### 第二个，带mask版本的floodFill： ###
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  **int** cv::floodFill( InputOutputArray \_image,InputOutputArray \_mask, 
> 2.   Point seedPoint, ScalarnewVal, Rect\* rect, 
> 3.   Scalar loDiff, ScalarupDiff, **int** flags ) 
> 4.  \{ 
> 5.   CvConnectedComp ccomp; 
> 6.   CvMat c\_image = \_image.getMat(), c\_mask = \_mask.getMat(); 
> 7.   cvFloodFill(&c\_image, seedPoint, newVal,loDiff, upDiff, &ccomp, flags, c\_mask.data.ptr ? &c\_mask : 0); 
> 8.  **if**( rect ) 
> 9.   \*rect = ccomp.rect; 
> 10. **return** cvRound(ccomp.area); 
> 11. \} 
> 
>   
>   
> 
> 
> 我们依然可以发现，其内部实现是基于OpenCV 1.X旧版的cvFloodFill函数，我们再来看看其旧版函数的源码。
> 
>   
> 
> 
>   
> 
> 
> ### 5.2 OpenCV2.X中cvFloodFill()函数的实现源码 ###
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  CV\_IMPL **void**
> 2.  cvFloodFill( CvArr\* arr, CvPointseed\_point, 
> 3.   CvScalar newVal, CvScalar lo\_diff, CvScalar up\_diff, 
> 4.   CvConnectedComp\* comp, **int** flags, CvArr\* maskarr ) 
> 5.  \{ 
> 6.   cv::Ptr<CvMat> tempMask; 
> 7.   std::vector<CvFFillSegment> buffer; 
> 8.  
> 9.  **if**( comp ) 
> 10.  memset( comp, 0, **sizeof**(\*comp) ); 
> 11. 
> 12. **int** i, type, depth, cn, is\_simple; 
> 13. **int** buffer\_size, connectivity = flags & 255; 
> 14. **union** \{ 
> 15.  uchar b\[4\]; 
> 16. **int** i\[4\]; 
> 17. **float** f\[4\]; 
> 18. **double** \_\[4\]; 
> 19.  \}nv\_buf; 
> 20.  nv\_buf.\_\[0\] = nv\_buf.\_\[1\] = nv\_buf.\_\[2\] = nv\_buf.\_\[3\] = 0; 
> 21. 
> 22. **struct** \{ cv::Vec3b b; cv::Vec3i i; cv::Vec3f f; \} ld\_buf, ud\_buf; 
> 23.  CvMat stub, \*img = cvGetMat(arr, &stub); 
> 24.  CvMat maskstub, \*mask = (CvMat\*)maskarr; 
> 25.  CvSize size; 
> 26. 
> 27.  type = CV\_MAT\_TYPE( img->type ); 
> 28.  depth = CV\_MAT\_DEPTH(type); 
> 29.  cn = CV\_MAT\_CN(type); 
> 30. 
> 31. **if**( connectivity == 0 ) 
> 32.  connectivity = 4; 
> 33. **else****if**( connectivity != 4 && connectivity != 8 ) 
> 34.  CV\_Error( CV\_StsBadFlag, "Connectivity must be 4, 0(=4) or 8"); 
> 35. 
> 36.  is\_simple = mask == 0 && (flags & CV\_FLOODFILL\_MASK\_ONLY) ==0; 
> 37. 
> 38. **for**( i = 0; i < cn; i++ ) 
> 39.  \{ 
> 40. **if**( lo\_diff.val\[i\] < 0 || up\_diff.val\[i\] < 0 ) 
> 41.  CV\_Error( CV\_StsBadArg, "lo\_diff and up\_diff must benon-negative" ); 
> 42.  is\_simple &= fabs(lo\_diff.val\[i\]) < DBL\_EPSILON &&fabs(up\_diff.val\[i\]) < DBL\_EPSILON; 
> 43.  \} 
> 44. 
> 45.  size = cvGetMatSize( img ); 
> 46. 
> 47. **if**( (unsigned)seed\_point.x >= (unsigned)size.width || 
> 48.  (unsigned)seed\_point.y >=(unsigned)size.height ) 
> 49.  CV\_Error( CV\_StsOutOfRange, "Seed point is outside of image"); 
> 50. 
> 51.  cvScalarToRawData( &newVal, &nv\_buf, type, 0 ); 
> 52.  buffer\_size = MAX( size.width, size.height ) \* 2; 
> 53.  buffer.resize( buffer\_size ); 
> 54. 
> 55. **if**( is\_simple ) 
> 56.  \{ 
> 57. **int** elem\_size = CV\_ELEM\_SIZE(type); 
> 58. **const** uchar\* seed\_ptr = img->data.ptr + img->step\*seed\_point.y +elem\_size\*seed\_point.x; 
> 59. 
> 60. **for**(i = 0; i < elem\_size; i++) 
> 61. **if** (seed\_ptr\[i\] != nv\_buf.b\[i\]) 
> 62. **break**; 
> 63. 
> 64. **if** (i != elem\_size) 
> 65.  \{ 
> 66. **if**( type == CV\_8UC1 ) 
> 67.  icvFloodFill\_CnIR(img->data.ptr, img->step, size, seed\_point,nv\_buf.b\[0\], 
> 68.  comp, flags, &buffer); 
> 69. **else****if**( type == CV\_8UC3 ) 
> 70.  icvFloodFill\_CnIR(img->data.ptr, img->step, size, seed\_point,cv::Vec3b(nv\_buf.b), 
> 71.  comp, flags,&buffer); 
> 72. **else****if**( type == CV\_32SC1 ) 
> 73.  icvFloodFill\_CnIR(img->data.ptr, img->step, size, seed\_point,nv\_buf.i\[0\], 
> 74.  comp, flags,&buffer); 
> 75. **else****if**( type == CV\_32FC1 ) 
> 76.  icvFloodFill\_CnIR(img->data.ptr, img->step, size, seed\_point,nv\_buf.f\[0\], 
> 77.  comp, flags,&buffer); 
> 78. **else****if**( type == CV\_32SC3 ) 
> 79.  icvFloodFill\_CnIR(img->data.ptr, img->step, size, seed\_point,cv::Vec3i(nv\_buf.i), 
> 80.  comp, flags, &buffer); 
> 81. **else****if**( type == CV\_32FC3 ) 
> 82.  icvFloodFill\_CnIR(img->data.ptr, img->step, size, seed\_point,cv::Vec3f(nv\_buf.f), 
> 83.  comp, flags,&buffer); 
> 84. **else**
> 85.  CV\_Error(CV\_StsUnsupportedFormat, "" ); 
> 86. **return**; 
> 87.  \} 
> 88.  \} 
> 89. 
> 90. **if**( !mask ) 
> 91.  \{ 
> 92. /\* created mask will be 8-byte aligned \*/
> 93.  tempMask = cvCreateMat( size.height + 2, (size.width + 9) & -8,CV\_8UC1 ); 
> 94.  mask = tempMask; 
> 95.  \} 
> 96. **else**
> 97.  \{ 
> 98.  mask = cvGetMat( mask, &maskstub ); 
> 99. **if**( !CV\_IS\_MASK\_ARR( mask )) 
> 100.  CV\_Error( CV\_StsBadMask, "" ); 
> 101. 
> 102. **if**( mask->width != size.width + 2 || mask->height != size.height +2 ) 
> 103.  CV\_Error( CV\_StsUnmatchedSizes, "mask must be 2 pixel wider "
> 104. "and 2pixel taller than filled image" ); 
> 105.  \} 
> 106. 
> 107. **int** width = tempMask ? mask->step : size.width + 2; 
> 108.  uchar\* mask\_row = mask->data.ptr + mask->step; 
> 109.  memset(mask\_row - mask->step, 1, width ); 
> 110. 
> 111. **for**( i = 1; i <= size.height; i++, mask\_row += mask->step ) 
> 112.  \{ 
> 113. **if**( tempMask ) 
> 114.  memset( mask\_row, 0, width ); 
> 115.  mask\_row\[0\] = mask\_row\[size.width+1\] = (uchar)1; 
> 116.  \} 
> 117.  memset( mask\_row, 1, width ); 
> 118. 
> 119. **if**( depth == CV\_8U ) 
> 120. **for**( i = 0; i < cn; i++ ) 
> 121.  \{ 
> 122. **int** t = cvFloor(lo\_diff.val\[i\]); 
> 123.  ld\_buf.b\[i\] = CV\_CAST\_8U(t); 
> 124.  t = cvFloor(up\_diff.val\[i\]); 
> 125.  ud\_buf.b\[i\] = CV\_CAST\_8U(t); 
> 126.  \} 
> 127. **else****if**( depth == CV\_32S ) 
> 128. **for**( i = 0; i < cn; i++ ) 
> 129.  \{ 
> 130. **int** t = cvFloor(lo\_diff.val\[i\]); 
> 131.  ld\_buf.i\[i\] = t; 
> 132.  t = cvFloor(up\_diff.val\[i\]); 
> 133.  ud\_buf.i\[i\] = t; 
> 134.  \} 
> 135. **else****if**( depth == CV\_32F ) 
> 136. **for**( i = 0; i < cn; i++ ) 
> 137.  \{ 
> 138.  ld\_buf.f\[i\] = (**float**)lo\_diff.val\[i\]; 
> 139.  ud\_buf.f\[i\] = (**float**)up\_diff.val\[i\]; 
> 140.  \} 
> 141. **else**
> 142.  CV\_Error( CV\_StsUnsupportedFormat, "" ); 
> 143. 
> 144. **if**( type == CV\_8UC1 ) 
> 145.  icvFloodFillGrad\_CnIR<uchar, **int**, Diff8uC1>( 
> 146.  img->data.ptr,img->step, mask->data.ptr, mask->step, 
> 147.  size, seed\_point,nv\_buf.b\[0\], 
> 148.  Diff8uC1(ld\_buf.b\[0\],ud\_buf.b\[0\]), 
> 149.  comp, flags,&buffer); 
> 150. **else****if**( type == CV\_8UC3 ) 
> 151.  icvFloodFillGrad\_CnIR<cv::Vec3b, cv::Vec3i, Diff8uC3>( 
> 152.  img->data.ptr,img->step, mask->data.ptr, mask->step, 
> 153.  size, seed\_point,cv::Vec3b(nv\_buf.b), 
> 154.  Diff8uC3(ld\_buf.b, ud\_buf.b), 
> 155.  comp, flags,&buffer); 
> 156. **else****if**( type == CV\_32SC1 ) 
> 157.  icvFloodFillGrad\_CnIR<**int**, **int**, Diff32sC1>( 
> 158.  img->data.ptr,img->step, mask->data.ptr, mask->step, 
> 159.  size, seed\_point,nv\_buf.i\[0\], 
> 160.  Diff32sC1(ld\_buf.i\[0\], ud\_buf.i\[0\]), 
> 161.  comp, flags, &buffer); 
> 162. **else****if**( type == CV\_32SC3 ) 
> 163.  icvFloodFillGrad\_CnIR<cv::Vec3i, cv::Vec3i, Diff32sC3>( 
> 164.  img->data.ptr,img->step, mask->data.ptr, mask->step, 
> 165.  size, seed\_point,cv::Vec3i(nv\_buf.i), 
> 166.  Diff32sC3(ld\_buf.i, ud\_buf.i), 
> 167.  comp, flags,&buffer); 
> 168. **else****if**( type == CV\_32FC1 ) 
> 169.  icvFloodFillGrad\_CnIR<**float**, **float**, Diff32fC1>( 
> 170.  img->data.ptr,img->step, mask->data.ptr, mask->step, 
> 171.  size, seed\_point,nv\_buf.f\[0\], 
> 172.  Diff32fC1(ld\_buf.f\[0\], ud\_buf.f\[0\]), 
> 173.  comp, flags,&buffer); 
> 174. **else****if**( type == CV\_32FC3 ) 
> 175.  icvFloodFillGrad\_CnIR<cv::Vec3f, cv::Vec3f, Diff32fC3>( 
> 176.  img->data.ptr,img->step, mask->data.ptr, mask->step, 
> 177.  size, seed\_point,cv::Vec3f(nv\_buf.f), 
> 178.  Diff32fC3(ld\_buf.f,ud\_buf.f), 
> 179.  comp, flags,&buffer); 
> 180. **else**
> 181.  CV\_Error(CV\_StsUnsupportedFormat, ""); 
> 182. \} 
> 
>   
>   
> 
> 
>   
> 
> 
>   
> 
> 
> ## 四、关于SetMouseCallback函数 ##
> 
>   
> 
> 
> 因为下面示例程序中有用到SetMouseCallback函数，我们在这里讲一讲。SetMouseCallback函数为指定的窗口设置鼠标回调函数。
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  C++: **void** setMouseCallback(conststring& winname, MouseCallback onMouse, **void**\* userdata=0 ) 
> 
>   
> 
> 
>  *  第一个参数，const string&类型的winname，为窗口的名字。
>  *  第二个参数，MouseCallback类型的onMouse，指定窗口里每次鼠标时间发生的时候，被调用的函数指针。这个函数的原型应该为voidFoo(int event, int x, int y, int flags, void\* param);其中event是 CV\_EVENT\_\*变量之一， x和y是鼠标指针在图像坐标系的坐标（不是窗口坐标系）， flags是CV\_EVENT\_FLAG的组合， param是用户定义的传递到cvSetMouseCallback函数调用的参数。
>  *  第三个参数，void\*类型的userdata，用户定义的传递到回调函数的参数，有默认值0。
> 
> # 五、综合示例部分 #
> 
> 本次的综合示例为OpenCV文档中自带的一个程序。浅墨将其做了适当的修改并详细注释，放出来供大家消化理解。
> 
> 操作说明如下：
> 
> ![SouthEast 4][]  
> 
> 
>  可以看到，此程序着不少的按键功能。而我们拿着鼠标对窗口中的图形一顿狂点，就可以得到类似PhotoShop中魔棒的效果，当然，就这短短的两百来行代码写出来的东西，体验是比不上PS的魔棒工具的。
> 
> 废话不多说，程序详细注释的源码如下：
> 
> **\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
> 
> 1.  //-----------------------------------【程序说明】----------------------------------------------
> 2.  // 程序名称:：《【OpenCV入门教程之十五】水漫金山：OpenCV漫水填充算法（Floodfill）》 博文配套源码 
> 3.  // 开发所用IDE版本：Visual Studio 2010
> 4.  // 开发所用OpenCV版本： 2.4.9
> 5.  // 2014年6月3日 Created by 浅墨
> 6.  // 浅墨的微博：@浅墨\_毛星云 http://weibo.com/1723155442/profile?topnav=1&wvr=5&user=1
> 7.  // 浅墨的知乎：http://www.zhihu.com/people/mao-xing-yun
> 8.  // 浅墨的豆瓣：http://www.douban.com/people/53426472/
> 9.  //----------------------------------------------------------------------------------------------
> 10. 
> 11. //-----------------------------------【头文件包含部分】--------------------------------------- 
> 12. // 描述：包含程序所依赖的头文件 
> 13. //----------------------------------------------------------------------------------------------
> 14. \#include "opencv2/imgproc/imgproc.hpp"
> 15. \#include "opencv2/highgui/highgui.hpp"
> 16. \#include <iostream>
> 17. 
> 18. //-----------------------------------【命名空间声明部分】--------------------------------------- 
> 19. // 描述：包含程序所使用的命名空间 
> 20. //----------------------------------------------------------------------------------------------- 
> 21. **using****namespace** cv; 
> 22. **using****namespace** std; 
> 23. 
> 24. 
> 25. //-----------------------------------【全局变量声明部分】-------------------------------------- 
> 26. // 描述：全局变量声明 
> 27. //----------------------------------------------------------------------------------------------- 
> 28. Mat g\_srcImage, g\_dstImage, g\_grayImage, g\_maskImage;//定义原始图、目标图、灰度图、掩模图
> 29. **int** g\_nFillMode = 1;//漫水填充的模式
> 30. **int** g\_nLowDifference = 20, g\_nUpDifference = 20;//负差最大值、正差最大值
> 31. **int** g\_nConnectivity = 4;//表示floodFill函数标识符低八位的连通值
> 32. **int** g\_bIsColor = **true**;//是否为彩色图的标识符布尔值
> 33. **bool** g\_bUseMask = **false**;//是否显示掩膜窗口的布尔值
> 34. **int** g\_nNewMaskVal = 255;//新的重新绘制的像素值
> 35. 
> 36. 
> 37. //-----------------------------------【ShowHelpText( )函数】---------------------------------- 
> 38. // 描述：输出一些帮助信息 
> 39. //---------------------------------------------------------------------------------------------- 
> 40. **static****void** ShowHelpText() 
> 41. \{ 
> 42. //输出一些帮助信息 
> 43.  printf("\\n\\n\\n\\t欢迎来到漫水填充示例程序~\\n\\n"); 
> 44.  printf( "\\n\\n\\t按键操作说明: \\n\\n"
> 45. "\\t\\t鼠标点击图中区域- 进行漫水填充操作\\n"
> 46. "\\t\\t键盘按键【ESC】- 退出程序\\n"
> 47. "\\t\\t键盘按键【1】- 切换彩色图/灰度图模式\\n"
> 48. "\\t\\t键盘按键【2】- 显示/隐藏掩膜窗口\\n"
> 49. "\\t\\t键盘按键【3】- 恢复原始图像\\n"
> 50. "\\t\\t键盘按键【4】- 使用空范围的漫水填充\\n"
> 51. "\\t\\t键盘按键【5】- 使用渐变、固定范围的漫水填充\\n"
> 52. "\\t\\t键盘按键【6】- 使用渐变、浮动范围的漫水填充\\n"
> 53. "\\t\\t键盘按键【7】- 操作标志符的低八位使用4位的连接模式\\n"
> 54. "\\t\\t键盘按键【8】- 操作标志符的低八位使用8位的连接模式\\n"
> 55. "\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t by浅墨\\n\\n\\n"
> 56.  ); 
> 57. \} 
> 58. 
> 59. 
> 60. //-----------------------------------【onMouse( )函数】-------------------------------------- 
> 61. // 描述：鼠标消息onMouse回调函数
> 62. //---------------------------------------------------------------------------------------------
> 63. **static****void** onMouse( **int** event, **int** x, **int** y, **int**, **void**\* ) 
> 64. \{ 
> 65. // 若鼠标左键没有按下，便返回
> 66. **if**( event != CV\_EVENT\_LBUTTONDOWN ) 
> 67. **return**; 
> 68. 
> 69. //-------------------【<1>调用floodFill函数之前的参数准备部分】---------------
> 70.  Point seed = Point(x,y); 
> 71. **int** LowDifference = g\_nFillMode == 0 ? 0 : g\_nLowDifference;//空范围的漫水填充，此值设为0，否则设为全局的g\_nLowDifference
> 72. **int** UpDifference = g\_nFillMode == 0 ? 0 : g\_nUpDifference;//空范围的漫水填充，此值设为0，否则设为全局的g\_nUpDifference
> 73. **int** flags = g\_nConnectivity + (g\_nNewMaskVal << 8) + 
> 74.  (g\_nFillMode == 1 ? CV\_FLOODFILL\_FIXED\_RANGE : 0);//标识符的0~7位为g\_nConnectivity，8~15位为g\_nNewMaskVal左移8位的值，16~23位为CV\_FLOODFILL\_FIXED\_RANGE或者0。
> 75. 
> 76. //随机生成bgr值
> 77. **int** b = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
> 78. **int** g = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
> 79. **int** r = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
> 80.  Rect ccomp;//定义重绘区域的最小边界矩形区域
> 81. 
> 82.  Scalar newVal = g\_bIsColor ? Scalar(b, g, r) : Scalar(r\*0.299 + g\*0.587 + b\*0.114);//在重绘区域像素的新值，若是彩色图模式，取Scalar(b, g, r)；若是灰度图模式，取Scalar(r\*0.299 + g\*0.587 + b\*0.114)
> 83. 
> 84.  Mat dst = g\_bIsColor ? g\_dstImage : g\_grayImage;//目标图的赋值
> 85. **int** area; 
> 86. 
> 87. //--------------------【<2>正式调用floodFill函数】-----------------------------
> 88. **if**( g\_bUseMask ) 
> 89.  \{ 
> 90.  threshold(g\_maskImage, g\_maskImage, 1, 128, CV\_THRESH\_BINARY); 
> 91.  area = floodFill(dst, g\_maskImage, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference), 
> 92.  Scalar(UpDifference, UpDifference, UpDifference), flags); 
> 93.  imshow( "mask", g\_maskImage ); 
> 94.  \} 
> 95. **else**
> 96.  \{ 
> 97.  area = floodFill(dst, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference), 
> 98.  Scalar(UpDifference, UpDifference, UpDifference), flags); 
> 99.  \} 
> 100. 
> 101.  imshow("效果图", dst); 
> 102.  cout << area << " 个像素被重绘\\n"; 
> 103. \} 
> 104. 
> 105. 
> 106. //-----------------------------------【main( )函数】-------------------------------------------- 
> 107. // 描述：控制台应用程序的入口函数，我们的程序从这里开始 
> 108. //----------------------------------------------------------------------------------------------- 
> 109. **int** main( **int** argc, **char**\*\* argv ) 
> 110. \{ 
> 111. //改变console字体颜色 
> 112.  system("color 2F"); 
> 113. 
> 114. //载入原图
> 115.  g\_srcImage = imread("1.jpg", 1); 
> 116. 
> 117. **if**( !g\_srcImage.data ) \{ printf("Oh，no，读取图片image0错误~！ \\n"); **return****false**; \} 
> 118. 
> 119. //显示帮助文字
> 120.  ShowHelpText(); 
> 121. 
> 122.  g\_srcImage.copyTo(g\_dstImage);//拷贝源图到目标图
> 123.  cvtColor(g\_srcImage, g\_grayImage, COLOR\_BGR2GRAY);//转换三通道的image0到灰度图
> 124.  g\_maskImage.create(g\_srcImage.rows+2, g\_srcImage.cols+2, CV\_8UC1);//利用image0的尺寸来初始化掩膜mask
> 125. 
> 126.  namedWindow( "效果图",CV\_WINDOW\_AUTOSIZE ); 
> 127. 
> 128. //创建Trackbar
> 129.  createTrackbar( "负差最大值", "效果图", &g\_nLowDifference, 255, 0 ); 
> 130.  createTrackbar( "正差最大值" ,"效果图", &g\_nUpDifference, 255, 0 ); 
> 131. 
> 132. //鼠标回调函数
> 133.  setMouseCallback( "效果图", onMouse, 0 ); 
> 134. 
> 135. //循环轮询按键
> 136. **while**(1) 
> 137.  \{ 
> 138. //先显示效果图
> 139.  imshow("效果图", g\_bIsColor ? g\_dstImage : g\_grayImage); 
> 140. 
> 141. //获取键盘按键
> 142. **int** c = waitKey(0); 
> 143. //判断ESC是否按下，若按下便退出
> 144. **if**( (c & 255) == 27 ) 
> 145.  \{ 
> 146.  cout << "程序退出...........\\n"; 
> 147. **break**; 
> 148.  \} 
> 149. 
> 150. //根据按键的不同，进行各种操作
> 151. **switch**( (**char**)c ) 
> 152.  \{ 
> 153. //如果键盘“1”被按下，效果图在在灰度图，彩色图之间互换
> 154. **case**'1': 
> 155. **if**( g\_bIsColor )//若原来为彩色，转为灰度图，并且将掩膜mask所有元素设置为0
> 156.  \{ 
> 157.  cout << "键盘“1”被按下，切换彩色/灰度模式，当前操作为将【彩色模式】切换为【灰度模式】\\n"; 
> 158.  cvtColor(g\_srcImage, g\_grayImage, COLOR\_BGR2GRAY); 
> 159.  g\_maskImage = Scalar::all(0); //将mask所有元素设置为0
> 160.  g\_bIsColor = **false**; //将标识符置为false，表示当前图像不为彩色，而是灰度
> 161.  \} 
> 162. **else**//若原来为灰度图，便将原来的彩图image0再次拷贝给image，并且将掩膜mask所有元素设置为0
> 163.  \{ 
> 164.  cout << "键盘“1”被按下，切换彩色/灰度模式，当前操作为将【彩色模式】切换为【灰度模式】\\n"; 
> 165.  g\_srcImage.copyTo(g\_dstImage); 
> 166.  g\_maskImage = Scalar::all(0); 
> 167.  g\_bIsColor = **true**;//将标识符置为true，表示当前图像模式为彩色
> 168.  \} 
> 169. **break**; 
> 170. //如果键盘按键“2”被按下，显示/隐藏掩膜窗口
> 171. **case**'2': 
> 172. **if**( g\_bUseMask ) 
> 173.  \{ 
> 174.  destroyWindow( "mask" ); 
> 175.  g\_bUseMask = **false**; 
> 176.  \} 
> 177. **else**
> 178.  \{ 
> 179.  namedWindow( "mask", 0 ); 
> 180.  g\_maskImage = Scalar::all(0); 
> 181.  imshow("mask", g\_maskImage); 
> 182.  g\_bUseMask = **true**; 
> 183.  \} 
> 184. **break**; 
> 185. //如果键盘按键“3”被按下，恢复原始图像
> 186. **case**'3': 
> 187.  cout << "按键“3”被按下，恢复原始图像\\n"; 
> 188.  g\_srcImage.copyTo(g\_dstImage); 
> 189.  cvtColor(g\_dstImage, g\_grayImage, COLOR\_BGR2GRAY); 
> 190.  g\_maskImage = Scalar::all(0); 
> 191. **break**; 
> 192. //如果键盘按键“4”被按下，使用空范围的漫水填充
> 193. **case**'4': 
> 194.  cout << "按键“4”被按下，使用空范围的漫水填充\\n"; 
> 195.  g\_nFillMode = 0; 
> 196. **break**; 
> 197. //如果键盘按键“5”被按下，使用渐变、固定范围的漫水填充
> 198. **case**'5': 
> 199.  cout << "按键“5”被按下，使用渐变、固定范围的漫水填充\\n"; 
> 200.  g\_nFillMode = 1; 
> 201. **break**; 
> 202. //如果键盘按键“6”被按下，使用渐变、浮动范围的漫水填充
> 203. **case**'6': 
> 204.  cout << "按键“6”被按下，使用渐变、浮动范围的漫水填充\\n"; 
> 205.  g\_nFillMode = 2; 
> 206. **break**; 
> 207. //如果键盘按键“7”被按下，操作标志符的低八位使用4位的连接模式
> 208. **case**'7': 
> 209.  cout << "按键“7”被按下，操作标志符的低八位使用4位的连接模式\\n"; 
> 210.  g\_nConnectivity = 4; 
> 211. **break**; 
> 212. //如果键盘按键“8”被按下，操作标志符的低八位使用8位的连接模式
> 213. **case**'8': 
> 214.  cout << "按键“8”被按下，操作标志符的低八位使用8位的连接模式\\n"; 
> 215.  g\_nConnectivity = 8; 
> 216. **break**; 
> 217.  \} 
> 218.  \} 
> 219. 
> 220. **return** 0; 
> 221. \} 
> 
>   
>   
> 
> 
>   
>   
> 
> 
> 一些运行截图，首先是运行后的原始图：
> 
> ![SouthEast 5][]  
> 
> 
> 点鼠标啊点鼠标：
> 
> ![SouthEast 6][]  
> 
> 
> 滑滚动条啊滑滚动条：
> 
> ![SouthEast 7][]  
> 
> 
>   
> 
> 
> 地球已经阻止不了我们的鼠标了，点出来的图，已经有点恐怖。。。。。看妹子的手。。。。  
> 
> 
> ![SouthEast 8][]  
> 
> 
>  如果鼠标点到妹子脸上的话。。。。呃，更多惊悚的图，浅墨不放出了，免得。。。。。
> 
> 随着我们鼠标的点击，程序会记下我们的操作：
> 
> ![SouthEast 9][]  
> 
> 
>   
> 
> 
> 接着看一张灰度图模式的漫水填充效果和掩码图：
> 
> ![SouthEast 10][]  
> 
> 
> 再来一张彩色窗户：
> 
> ![SouthEast 11][]  
> 
> 
> 程序功能还是很多的，有鼠标操作，键盘8个按键的操作，还可以调滚动条：
> 
> ![SouthEast 12][]  
> 
> 
>   
> 
> 
> 好了，更多的功能我们就不在这里示范了，大家下载了程序自己回去玩吧。
> 
>   
> 
> 
> 本篇文章的配套源代码请点击这里下载：
> 
> [【浅墨OpenCV入门教程之十五】配套源代码下载][OpenCV]
> 
>   
> 
> 
>   
>

OK，今天的内容大概就是这些，我们下篇文章见：）

> ![SouthEast 13][]

[Link 1]: http://weibo.com/1723155442
[http_blog.csdn.net_poem_qianmo_article_details_28261997]: http://blog.csdn.net/poem_qianmo/article/details/28261997
[http_weibo.com_u_1723155442]: http://weibo.com/u/1723155442
[http_www.zhihu.com_people_mao-xing-yun]: http://www.zhihu.com/people/mao-xing-yun
[happylifemxy_163.com]: mailto:happylifemxy@163.com
[SouthEast]: https://img-blog.csdn.net/20140603145208187?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhteHk1NTU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 1]: /images/20220805/362daf5bed5a4aefa1bec879cf82e9f3.png
[view plain]: http://blog.csdn.net/poem_qianmo/article/details/28261997#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/374429
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/374429/fork
[SouthEast 2]: /images/20220805/cf558cce9c8842ce93dfb24ff98eb987.png
[SouthEast 3]: /images/20220805/4909d90d332e4e96aea039ee7159f5b0.png
[SouthEast 4]: /images/20220805/c03725f5e30b4ca3854f182c873844c6.png
[SouthEast 5]: /images/20220805/c3acaa7b4b2346eb9b9eb24b82527c5d.png
[SouthEast 6]: /images/20220805/2084d6cae6474f44a3f918620157eef7.png
[SouthEast 7]: /images/20220805/193f591f34014f0eb1461ef708bbd536.png
[SouthEast 8]: /images/20220805/1770a8494cf24bbe81c1304c0f2162c7.png
[SouthEast 9]: /images/20220805/147bee0f9c524d7aa5d447eefafc20a8.png
[SouthEast 10]: /images/20220805/dec42063b8c24aeaa5d084ec5ad286db.png
[SouthEast 11]: /images/20220805/424d98dc912b4549b0656f53060f6e4c.png
[SouthEast 12]: /images/20220805/9251c511a5f14699bd532da8c0a25ba2.png
[OpenCV]: http://download.csdn.net/detail/zhmxy555/7440813
[SouthEast 13]: /images/20220805/087cd79b97814cb4921b9a4aa20d78ab.png