opencv 漫水填充运用

转载 2015年11月19日 22:07:13

一、引言 · 漫水填充的定义



漫水填充法是一种用特定的颜色填充联通区域,通过设置可连通像素的上下限以及连通方式来达到不同的填充效果的方法。漫水填充经常被用来标记或分离图像的一部分以便对其进行进一步处理或分析,也可以用来从输入图像获取掩码区域,掩码会加速处理过程,或只处理掩码指定的像素点,操作的结果总是某个连续的区域。

另外,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

  1. int floodFill(InputOutputArray image, Point seedPoint, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )  


第二个版本的floodFill:

  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,那么输入的参数是这样:

  1. flags
  1. #include <opencv2/opencv.hpp>    
  2. #include <opencv2/imgproc/imgproc.hpp>    
  3.   
  4. //-----------------------------------【命名空间声明部分】---------------------------------------    
  5. //      描述:包含程序所使用的命名空间    
  6. //-----------------------------------------------------------------------------------------------     
  7. using namespace cv;    
  8. //-----------------------------------【main( )函数】--------------------------------------------    
  9. //      描述:控制台应用程序的入口函数,我们的程序从这里开始    
  10. //-----------------------------------------------------------------------------------------------   
  11.   
  12. int main( )  
  13. {      
  14.     Mat src = imread("1.jpg");   
  15.     imshow("【原始图】",src);  
  16.     Rect ccomp;  
  17.     floodFill(src, Point(50,300), Scalar(155, 255,55), &ccomp, Scalar(20, 20, 20),Scalar(20, 20, 20));  
  18.     imshow("【效果图】",src);  
  19.     waitKey(0);  
  20.     return 0;      
  21. }    

五、floodFill函数在OpenCV中的实现源代码



这个部分贴出OpenCV中本文相关函数的源码实现细节,来给想了解实现细节的小伙伴们参考。浅墨暂时不在源码的细节上挖深作详细注释。

 


5.1 OpenCV2.X中两个版本的floodFill函数源码

第一个,不带mask版本的floodFill:

  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:

  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()函数的实现源码

 

  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<intint, 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<floatfloat, 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函数为指定的窗口设置鼠标回调函数。

 

  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文档中自带的一个程序。浅墨将其做了适当的修改并详细注释,放出来供大家消化理解。

操作说明如下:


 可以看到,此程序着不少的按键功能。而我们拿着鼠标对窗口中的图形一顿狂点,就可以得到类似PhotoShop中魔棒的效果,当然,就这短短的两百来行代码写出来的东西,体验是比不上PS的魔棒工具的。

废话不多说,程序详细注释的源码如下:

  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, intvoid* )  
  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. }  

相关文章推荐

OpenCV与EmguCV中的漫水填充

漫水填充算法,是根据选定的种子点,用一种自定义的颜色填充种子点的联通区域,通过设置可连通像素的上下限以及连通方式来达到不同的填充效果。漫水填充经常被用来标记或分离图像的一部分以便对其进行进一步处理或分...

【OpenCV入门教程之十五】水漫金山:OpenCV漫水填充算法(Floodfill)

本篇文章中,我们一起探讨了OpenCV填充算法中漫水填充算法相关的知识点,以及了解了OpenCV中实现漫水填充算法的两个版本的floodFill函数的使用方法,此博文一共有两个个配套的示例程序,其详细...
  • zhmxy555
  • zhmxy555
  • 2014年06月03日 15:39
  • 60594

opencv漫水填充法。

向浅墨学习。 本系列文章由@浅墨_毛星云 出品,转载请注明出处。   文章链接: http://blog.csdn.net/po...

Python3 迭代器与生成器

Python3 迭代器与生成器 迭代器 迭代是Python最强大的功能之一,是访问集合元素的一种方式。。 迭代器是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问,直到所有...
  • fly_yr
  • fly_yr
  • 2016年05月25日 20:53
  • 1554

CUDA(16)之内存对齐

摘要 本文主要讲述CUDA内存对齐。 1. 背景 CUDA内存对齐的背景就不说了。 2. 采用SoA设计/构造并行的数据结构 array of structures(AoS)和structur...

opencv FloodFill(漫水填充)和物体选取

简介   本篇主要是介绍opencv的FloodFill(漫水填充)和基于它实现的物体选取。 FloodFill使用 FloodFill函数   C++: int floodFill(Inp...

opencv源码学习漫水填充

漫水填充就是一种用特定颜色填充连通区域,通过设置可连通像素的上下限以及连通方式达到不同的填充效果的方法。简单来说就是自动选中了和种子点相连的区域,接着将该区域替换成指定的颜色,漫谁填充也可以用来从输入...

OpenCV漫水填充

漫水填充就是用一定颜色填充联通区域,通过设置可连通像素的上下限以及连通方式来达到不同的填充效果;漫水填充经常被用来标记或分离图像的一部分以便对其进行进一步处理或分析,也可以用来从输入图像获取掩码区域,...
  • utimes
  • utimes
  • 2013年08月29日 21:39
  • 4540
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:opencv 漫水填充运用
举报原因:
原因补充:

(最多只允许输入30个字)