计算机视觉
图像处理

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

文章目录

本篇文章中,我们一起探讨了Opencv填充算法漫水填充算法相关的知识点,以及了解了OpenCV中实现漫水填充算法的两个版本的floodfill()函数的使用方法。此篇博文一共有两个个配套的示例程序,其详细注释过的代码都在文中贴出,且文章最后提供了综合示例程序的下载。

先尝鲜一下最终示例程序的运行截图吧,这个示例程序实现了类似于PhotoShop中魔棒的图像处理效果,我们可以用鼠标对窗口中的图片一顿狂点,得到一片一片的彩色区域:

  

效果图                                                                                              原始图

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

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

另外,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=8 | FLOODFILL_MASK_ONLY | FLOODFILL_FIXED_RANGE | (38<<8)

 

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

运行截图,原始图:

效果图:

五、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.    if( comp )
  9.        memset( comp, 0, sizeof(*comp) );
  10.    int i, type, depth, cn, is_simple;
  11.    int buffer_size, connectivity = flags & 255;
  12.    union {
  13.        uchar b[4];
  14.        int i[4];
  15.        float f[4];
  16.        double _[4];
  17.     }nv_buf;
  18.    nv_buf._[0] = nv_buf._[1] = nv_buf._[2] = nv_buf._[3] = 0;
  19.    struct { cv::Vec3b b; cv::Vec3i i; cv::Vec3f f; } ld_buf, ud_buf;
  20.    CvMat stub, *img = cvGetMat(arr, &stub);
  21.    CvMat maskstub, *mask = (CvMat*)maskarr;
  22.    CvSize size;
  23.    type = CV_MAT_TYPE( img->type );
  24.    depth = CV_MAT_DEPTH(type);
  25.    cn = CV_MAT_CN(type);
  26.    if( connectivity == 0 )
  27.        connectivity = 4;
  28.    else if( connectivity != 4 && connectivity != 8 )
  29.        CV_Error( CV_StsBadFlag, “Connectivity must be 4, 0(=4) or 8”);
  30.    is_simple = mask == 0 && (flags & CV_FLOODFILL_MASK_ONLY) ==0;
  31.    for( i = 0; i < cn; i++ )
  32.     {
  33.        if( lo_diff.val[i] < 0 || up_diff.val[i] < 0 )
  34.            CV_Error( CV_StsBadArg, “lo_diff and up_diff must benon-negative” );
  35.        is_simple &= fabs(lo_diff.val[i]) < DBL_EPSILON &&fabs(up_diff.val[i]) < DBL_EPSILON;
  36.     }
  37.    size = cvGetMatSize( img );
  38.    if( (unsigned)seed_point.x >= (unsigned)size.width ||
  39.         (unsigned)seed_point.y >=(unsigned)size.height )
  40.        CV_Error( CV_StsOutOfRange, “Seed point is outside of image”);
  41.    cvScalarToRawData( &newVal, &nv_buf, type, 0 );
  42.    buffer_size = MAX( size.width, size.height ) * 2;
  43.    buffer.resize( buffer_size );
  44.    if( is_simple )
  45.     {
  46.        int elem_size = CV_ELEM_SIZE(type);
  47.        const uchar* seed_ptr = img->data.ptr + img->step*seed_point.y +elem_size*seed_point.x;
  48.        for(i = 0; i < elem_size; i++)
  49.            if (seed_ptr[i] != nv_buf.b[i])
  50.                 break;
  51.        if (i != elem_size)
  52.        {
  53.            if( type == CV_8UC1 )
  54.                icvFloodFill_CnIR(img->data.ptr, img->step, size, seed_point,nv_buf.b[0],
  55.                                   comp, flags, &buffer);
  56.            else if( type == CV_8UC3 )
  57.                icvFloodFill_CnIR(img->data.ptr, img->step, size, seed_point,cv::Vec3b(nv_buf.b),
  58.                                   comp, flags,&buffer);
  59.            else if( type == CV_32SC1 )
  60.                icvFloodFill_CnIR(img->data.ptr, img->step, size, seed_point,nv_buf.i[0],
  61.                                   comp, flags,&buffer);
  62.            else if( type == CV_32FC1 )
  63.                icvFloodFill_CnIR(img->data.ptr, img->step, size, seed_point,nv_buf.f[0],
  64.                                   comp, flags,&buffer);
  65.            else if( type == CV_32SC3 )
  66.                icvFloodFill_CnIR(img->data.ptr, img->step, size, seed_point,cv::Vec3i(nv_buf.i),
  67.                                   comp, flags, &buffer);
  68.            else if( type == CV_32FC3 )
  69.                icvFloodFill_CnIR(img->data.ptr, img->step, size, seed_point,cv::Vec3f(nv_buf.f),
  70.                                   comp, flags,&buffer);
  71.            else
  72.                 CV_Error(CV_StsUnsupportedFormat, “” );
  73.            return;
  74.        }
  75.     }
  76.    if( !mask )
  77.     {
  78.        /* created mask will be 8-byte aligned */
  79.        tempMask = cvCreateMat( size.height + 2, (size.width + 9) & -8,CV_8UC1 );
  80.        mask = tempMask;
  81.     }
  82.    else
  83.     {
  84.        mask = cvGetMat( mask, &maskstub );
  85.        if( !CV_IS_MASK_ARR( mask ))
  86.            CV_Error( CV_StsBadMask, “” );
  87.        if( mask->width != size.width + 2 || mask->height != size.height +2 )
  88.            CV_Error( CV_StsUnmatchedSizes, “mask must be 2 pixel wider “
  89.                                    “and 2pixel taller than filled image” );
  90.     }
  91.    int width = tempMask ? mask->step : size.width + 2;
  92.    uchar* mask_row = mask->data.ptr + mask->step;
  93.     memset(mask_row – mask->step, 1, width );
  94.    for( i = 1; i <= size.height; i++, mask_row += mask->step )
  95.     {
  96.        if( tempMask )
  97.            memset( mask_row, 0, width );
  98.        mask_row[0] = mask_row[size.width+1] = (uchar)1;
  99.     }
  100.    memset( mask_row, 1, width );
  101.    if( depth == CV_8U )
  102.        for( i = 0; i < cn; i++ )
  103.        {
  104.            int t = cvFloor(lo_diff.val[i]);
  105.            ld_buf.b[i] = CV_CAST_8U(t);
  106.            t = cvFloor(up_diff.val[i]);
  107.            ud_buf.b[i] = CV_CAST_8U(t);
  108.        }
  109.    else if( depth == CV_32S )
  110.        for( i = 0; i < cn; i++ )
  111.        {
  112.            int t = cvFloor(lo_diff.val[i]);
  113.            ld_buf.i[i] = t;
  114.            t = cvFloor(up_diff.val[i]);
  115.            ud_buf.i[i] = t;
  116.        }
  117.     else if( depth == CV_32F )
  118.        for( i = 0; i < cn; i++ )
  119.        {
  120.            ld_buf.f[i] = (float)lo_diff.val[i];
  121.            ud_buf.f[i] = (float)up_diff.val[i];
  122.        }
  123.    else
  124.        CV_Error( CV_StsUnsupportedFormat, “” );
  125.    if( type == CV_8UC1 )
  126.        icvFloodFillGrad_CnIR<uchar, int, Diff8uC1>(
  127.                               img->data.ptr,img->step, mask->data.ptr, mask->step,
  128.                               size, seed_point,nv_buf.b[0],
  129.                               Diff8uC1(ld_buf.b[0],ud_buf.b[0]),
  130.                               comp, flags,&buffer);
  131.    else if( type == CV_8UC3 )
  132.        icvFloodFillGrad_CnIR<cv::Vec3b, cv::Vec3i, Diff8uC3>(
  133.                               img->data.ptr,img->step, mask->data.ptr, mask->step,
  134.                               size, seed_point,cv::Vec3b(nv_buf.b),
  135.                              Diff8uC3(ld_buf.b, ud_buf.b),
  136.                               comp, flags,&buffer);
  137.    else if( type == CV_32SC1 )
  138.        icvFloodFillGrad_CnIR<intint, Diff32sC1>(
  139.                               img->data.ptr,img->step, mask->data.ptr, mask->step,
  140.                               size, seed_point,nv_buf.i[0],
  141.                              Diff32sC1(ld_buf.i[0], ud_buf.i[0]),
  142.                               comp, flags, &buffer);
  143.    else if( type == CV_32SC3 )
  144.        icvFloodFillGrad_CnIR<cv::Vec3i, cv::Vec3i, Diff32sC3>(
  145.                               img->data.ptr,img->step, mask->data.ptr, mask->step,
  146.                               size, seed_point,cv::Vec3i(nv_buf.i),
  147.                              Diff32sC3(ld_buf.i, ud_buf.i),
  148.                               comp, flags,&buffer);
  149.    else if( type == CV_32FC1 )
  150.        icvFloodFillGrad_CnIR<floatfloat, Diff32fC1>(
  151.                               img->data.ptr,img->step, mask->data.ptr, mask->step,
  152.                               size, seed_point,nv_buf.f[0],
  153.                              Diff32fC1(ld_buf.f[0], ud_buf.f[0]),
  154.                               comp, flags,&buffer);
  155.    else if( type == CV_32FC3 )
  156.        icvFloodFillGrad_CnIR<cv::Vec3f, cv::Vec3f, Diff32fC3>(
  157.                               img->data.ptr,img->step, mask->data.ptr, mask->step,
  158.                               size, seed_point,cv::Vec3f(nv_buf.f),
  159.                              Diff32fC3(ld_buf.f,ud_buf.f),
  160.                               comp, flags,&buffer);
  161.    else
  162.        CV_Error(CV_StsUnsupportedFormat, “”);
  163. }

 

四、关于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. —————————————————————————————
  6. //———————————–【头文件包含部分】—————————————  
  7. //      描述:包含程序所依赖的头文件  
  8. //———————————————————————————————-
  9. #include “opencv2/imgproc/imgproc.hpp”
  10. #include “opencv2/highgui/highgui.hpp”
  11. #include <iostream>
  12. //———————————–【命名空间声明部分】—————————————  
  13. //      描述:包含程序所使用的命名空间  
  14. //———————————————————————————————–   
  15. using namespace cv;
  16. using namespace std;
  17. //———————————–【全局变量声明部分】————————————–  
  18. //      描述:全局变量声明  
  19. //———————————————————————————————–  
  20. Mat g_srcImage, g_dstImage, g_grayImage, g_maskImage;//定义原始图、目标图、灰度图、掩模图
  21. int g_nFillMode = 1;//漫水填充的模式
  22. int g_nLowDifference = 20, g_nUpDifference = 20;//负差最大值、正差最大值
  23. int g_nConnectivity = 4;//表示floodFill函数标识符低八位的连通值
  24. int g_bIsColor = true;//是否为彩色图的标识符布尔值
  25. bool g_bUseMask = false;//是否显示掩膜窗口的布尔值
  26. int g_nNewMaskVal = 255;//新的重新绘制的像素值
  27. //———————————–【ShowHelpText( )函数】———————————-  
  28. //      描述:输出一些帮助信息  
  29. //———————————————————————————————-  
  30. static void ShowHelpText()
  31. {
  32.     //输出一些帮助信息  
  33.     printf(“nnnt欢迎来到漫水填充示例程序~nn”);
  34.     printf( “nnt按键操作说明: nn”
  35.         “tt鼠标点击图中区域- 进行漫水填充操作n”
  36.         “tt键盘按键【ESC】- 退出程序n”
  37.         “tt键盘按键【1】-  切换彩色图/灰度图模式n”
  38.         “tt键盘按键【2】- 显示/隐藏掩膜窗口n”
  39.         “tt键盘按键【3】- 恢复原始图像n”
  40.         “tt键盘按键【4】- 使用空范围的漫水填充n”
  41.         “tt键盘按键【5】- 使用渐变、固定范围的漫水填充n”
  42.         “tt键盘按键【6】- 使用渐变、浮动范围的漫水填充n”
  43.         “tt键盘按键【7】- 操作标志符的低八位使用4位的连接模式n”
  44.         “tt键盘按键【8】- 操作标志符的低八位使用8位的连接模式n”
  45.         “nntttttttt bynnn”
  46.         );
  47. }
  48. //———————————–【onMouse( )函数】————————————–  
  49. //      描述:鼠标消息onMouse回调函数
  50. //———————————————————————————————
  51. static void onMouse( int event, int x, int y, intvoid* )
  52. {
  53.     // 若鼠标左键没有按下,便返回
  54.     if( event != CV_EVENT_LBUTTONDOWN )
  55.         return;
  56.     //——————-【<1>调用floodFill函数之前的参数准备部分】—————
  57.     Point seed = Point(x,y);
  58.     int LowDifference = g_nFillMode == 0 ? 0 : g_nLowDifference;//空范围的漫水填充,此值设为0,否则设为全局的g_nLowDifference
  59.     int UpDifference = g_nFillMode == 0 ? 0 : g_nUpDifference;//空范围的漫水填充,此值设为0,否则设为全局的g_nUpDifference
  60.     int flags = g_nConnectivity + (g_nNewMaskVal << 8) +
  61.         (g_nFillMode == 1 ? CV_FLOODFILL_FIXED_RANGE : 0);//标识符的0~7位为g_nConnectivity,8~15位为g_nNewMaskVal左移8位的值,16~23位为CV_FLOODFILL_FIXED_RANGE或者0。
  62.     //随机生成bgr值
  63.     int b = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
  64.     int g = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
  65.     int r = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
  66.     Rect ccomp;//定义重绘区域的最小边界矩形区域
  67.     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)
  68.     Mat dst = g_bIsColor ? g_dstImage : g_grayImage;//目标图的赋值
  69.     int area;
  70.     //——————–【<2>正式调用floodFill函数】—————————–
  71.     if( g_bUseMask )
  72.     {
  73.         threshold(g_maskImage, g_maskImage, 1, 128, CV_THRESH_BINARY);
  74.         area = floodFill(dst, g_maskImage, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference),
  75.             Scalar(UpDifference, UpDifference, UpDifference), flags);
  76.         imshow( “mask”, g_maskImage );
  77.     }
  78.     else
  79.     {
  80.         area = floodFill(dst, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference),
  81.             Scalar(UpDifference, UpDifference, UpDifference), flags);
  82.     }
  83.     imshow(“效果图”, dst);
  84.     cout << area << ” 个像素被重绘n”;
  85. }
  86. //———————————–【main( )函数】——————————————–  
  87. //      描述:控制台应用程序的入口函数,我们的程序从这里开始  
  88. //———————————————————————————————–  
  89. int main( int argc, char** argv )
  90. {
  91.     //改变console字体颜色  
  92.     system(“color 2F”);
  93.     //载入原图
  94.     g_srcImage = imread(“1.jpg”, 1);
  95.     if( !g_srcImage.data ) { printf(“Oh,no,读取图片image0错误~! n”); return false; }
  96.     //显示帮助文字
  97.     ShowHelpText();
  98.     g_srcImage.copyTo(g_dstImage);//拷贝源图到目标图
  99.     cvtColor(g_srcImage, g_grayImage, COLOR_BGR2GRAY);//转换三通道的image0到灰度图
  100.     g_maskImage.create(g_srcImage.rows+2, g_srcImage.cols+2, CV_8UC1);//利用image0的尺寸来初始化掩膜mask
  101.     namedWindow( “效果图”,CV_WINDOW_AUTOSIZE );
  102.     //创建Trackbar
  103.     createTrackbar( “负差最大值”“效果图”, &g_nLowDifference, 255, 0 );
  104.     createTrackbar( “正差最大值” ,“效果图”, &g_nUpDifference, 255, 0 );
  105.     //鼠标回调函数
  106.     setMouseCallback( “效果图”, onMouse, 0 );
  107.     //循环轮询按键
  108.     while(1)
  109.     {
  110.         //先显示效果图
  111.         imshow(“效果图”, g_bIsColor ? g_dstImage : g_grayImage);
  112.         //获取键盘按键
  113.         int c = waitKey(0);
  114.         //判断ESC是否按下,若按下便退出
  115.         if( (c & 255) == 27 )
  116.         {
  117.             cout << “程序退出………..n”;
  118.             break;
  119.         }
  120.         //根据按键的不同,进行各种操作
  121.         switch( (char)c )
  122.         {
  123.         //如果键盘“1”被按下,效果图在在灰度图,彩色图之间互换
  124.         case ‘1’:
  125.             if( g_bIsColor )//若原来为彩色,转为灰度图,并且将掩膜mask所有元素设置为0
  126.             {
  127.                 cout << “键盘“1”被按下,切换彩色/灰度模式,当前操作为将【彩色模式】切换为【灰度模式】n”;
  128.                 cvtColor(g_srcImage, g_grayImage, COLOR_BGR2GRAY);
  129.                 g_maskImage = Scalar::all(0);   //将mask所有元素设置为0
  130.                 g_bIsColor = false//将标识符置为false,表示当前图像不为彩色,而是灰度
  131.             }
  132.             else//若原来为灰度图,便将原来的彩图image0再次拷贝给image,并且将掩膜mask所有元素设置为0
  133.             {
  134.                 cout << “键盘“1”被按下,切换彩色/灰度模式,当前操作为将【彩色模式】切换为【灰度模式】n”;
  135.                 g_srcImage.copyTo(g_dstImage);
  136.                 g_maskImage = Scalar::all(0);
  137.                 g_bIsColor = true;//将标识符置为true,表示当前图像模式为彩色
  138.             }
  139.             break;
  140.         //如果键盘按键“2”被按下,显示/隐藏掩膜窗口
  141.         case ‘2’:
  142.             if( g_bUseMask )
  143.             {
  144.                 destroyWindow( “mask” );
  145.                 g_bUseMask = false;
  146.             }
  147.             else
  148.             {
  149.                 namedWindow( “mask”, 0 );
  150.                 g_maskImage = Scalar::all(0);
  151.                 imshow(“mask”, g_maskImage);
  152.                 g_bUseMask = true;
  153.             }
  154.             break;
  155.         //如果键盘按键“3”被按下,恢复原始图像
  156.         case ‘3’:
  157.             cout << “按键“3”被按下,恢复原始图像n”;
  158.             g_srcImage.copyTo(g_dstImage);
  159.             cvtColor(g_dstImage, g_grayImage, COLOR_BGR2GRAY);
  160.             g_maskImage = Scalar::all(0);
  161.             break;
  162.         //如果键盘按键“4”被按下,使用空范围的漫水填充
  163.         case ‘4’:
  164.             cout << “按键“4”被按下,使用空范围的漫水填充n”;
  165.             g_nFillMode = 0;
  166.             break;
  167.         //如果键盘按键“5”被按下,使用渐变、固定范围的漫水填充
  168.         case ‘5’:
  169.             cout << “按键“5”被按下,使用渐变、固定范围的漫水填充n”;
  170.             g_nFillMode = 1;
  171.             break;
  172.         //如果键盘按键“6”被按下,使用渐变、浮动范围的漫水填充
  173.         case ‘6’:
  174.             cout << “按键“6”被按下,使用渐变、浮动范围的漫水填充n”;
  175.             g_nFillMode = 2;
  176.             break;
  177.         //如果键盘按键“7”被按下,操作标志符的低八位使用4位的连接模式
  178.         case ‘7’:
  179.             cout << “按键“7”被按下,操作标志符的低八位使用4位的连接模式n”;
  180.             g_nConnectivity = 4;
  181.             break;
  182.         //如果键盘按键“8”被按下,操作标志符的低八位使用8位的连接模式
  183.         case ‘8’:
  184.             cout << “按键“8”被按下,操作标志符的低八位使用8位的连接模式n”;
  185.             g_nConnectivity = 8;
  186.             break;
  187.         }
  188.     }
  189.     return 0;
  190. }

 

 

一些运行截图,首先是运行后的原始图:

点鼠标啊点鼠标:

滑滚动条啊滑滚动条:

地球已经阻止不了我们的鼠标了,点出来的图,已经有点恐怖。。。。。看妹子的手。。。。

如果鼠标点到妹子脸上的话。。。。呃,更多惊悚的图,不放出了,免得。。。。。

随着我们鼠标的点击,程序会记下我们的操作:

接着看一张灰度图模式的漫水填充效果和掩码图:

再来一张彩色窗户:

程序功能还是很多的,有鼠标操作,键盘8个按键的操作,还可以调滚动条:

好了,更多的功能我们就不在这里示范了,大家下载了程序自己回去玩吧。

本篇文章的配套源代码请点击这里下载:【OpenCV入门教程之十五】配套源代码下载

OK,今天的内容大概就是这些,我们下篇文章见:)

转载注明来源:CV视觉网 » 【OpenCV入门教程之十五】水漫金山:OpenCV漫水填充算法(Floodfill)

分享到:更多 ()
扫描二维码,给作者 打赏
pay_weixinpay_weixin

请选择你看完该文章的感受:

0不错 0超赞 0无聊 0扯淡 0不解 0路过

评论 5

评论前必须登录!