5.4.3 cv::floodFill() 

        cv::floodFill()在判断一个像素时，要检查附近像素的状态，这是为了识别某种颜色的相关区域。用户只需指定一起始位置和允许的误差，就可以找出颜色接近的连续区域。

// 构造函数1
int floodFill(InputArray image, 
              Point seedPoint, 
              Scalar newVal, 
              Rect* rect=0,
              Scalar ioDiff=Scalar(), 
              Scalar upDiff=Scalar(), 
              int flags=4)
// 构造函数2
int floodFill(InputArray image, 
              InputArray mask, 
              Point seedPoint, 
              Scalar newVal, 
              Rect* rect=0,
              Scalar ioDiff=Scalar(), 
              Scalar upDiff=Scalar(), 
              int flags=4)

• image：输入图像，1个或3个通道的8位或浮点图像。
• mask：只有第二个版本才有该参数，表示作为掩膜。它应该是单通道，8位，长和宽都比输入图像大两个点的图像。因为漫水填充需要使用以及更细掩膜，所以对这个mask参数，我们一定要将其准本好并填在此处。需要注意的是，漫水填充不会填充mask的非零像素区域。例如，一个边缘检测算子的输出可以用来作为掩膜，以防止填充到边缘。同样的，也可以在多次的函数调用中使用同一个掩膜，以保证填充的区域不会重叠。需要注意的是，mask会比需填充的图像大，所以mask与输入图像(x, y)像素点对应的坐标为(x,+1 y+1)。
• seedPoint：漫水填充算法的起始点。
• newVal：像素被染色的值。
• rect：默认值是0，可选参数，用于设置floodFill函数将要重绘区域的最小边界矩形区域。
• loDiff：默认值是Scalar()，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间的亮度或颜色之负差的最大值。
• upDiff：默认值是Scalar()，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间的亮度或颜色之正差的最大值。
• flags：操作标志符。

（1） cv::absdiff()检测颜色

	// 使用cv::floodFill函数
    ColorDetector colordetector(230, 190, 130, 45, true);  // 第3个构造函数
	cv::floodFill(image,            // 输入/输出图像
		cv::Point(100, 50),         // 起始点
		cv::Scalar(255, 255, 255),  // 填充颜色
		(cv::Rect*)0,               // 填充颜色的边界距离
		cv::Scalar(35, 35, 35),     // 偏差的最小/最大阈值
		cv::Scalar(35, 35, 35),     // 正差阈值，两个阈值通常相等
		cv::FLOODFILL_FIXED_RANGE); // 与起始点像素比较
	cv::namedWindow("Image2");
	cv::Mat image2 = colordetector(image);
	cv::imshow("Image2", image2);
	cv::waitKey();

 5.5 完整代码

/*
    colordetector.h头文件
*/
#if !defined COLORDETECT
#define COLORDETECT

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>

class ColorDetector {

  private:
	  int maxDist;     // 允许的最小差距
	  cv::Vec3b target;    // 目标颜色
	  cv::Mat converted;   // 转换的图像
	  bool useLab;         // 是否使用Lab色彩空间
	  cv::Mat result;  // 存储二值映射结果的图像

  public:
	  // 不同的构造函数
	  // 在此初始化默认参数
	  ColorDetector() : maxDist(100), target(0,0,0), useLab(false) {}
	  ColorDetector(bool useLab) : maxDist(100), target(0,0,0), useLab(useLab) {}
	  ColorDetector(uchar blue, uchar green, uchar red, int mxDist=100, bool useLab=false): maxDist(mxDist), useLab(useLab) { 
		  // 设置需要检测的颜色
		  setTargetColor(blue, green, red);
	  }

	  // 计算与目标颜色的距离
	  int getDistanceToTargetColor(const cv::Vec3b& color) const {
		  return getColorDistance(color, target);
	  }

	  // 计算两个颜色之间的城区距离
	  int getColorDistance(const cv::Vec3b& color1, const cv::Vec3b& color2) const {

		  return abs(color1[0]-color2[0])+
					abs(color1[1]-color2[1])+
					abs(color1[2]-color2[2]);
	  }

	  cv::Mat process(const cv::Mat &image);
      
	  cv::Mat operator()(const cv::Mat &image) {
		  cv::Mat input;
		 
		  if (useLab) { 
			  cv::cvtColor(image, input, CV_BGR2Lab);    // 转换成Lab色彩空间
		  }
		  else {
			  input = image;
		  }

		  cv::Mat output;
		  cv::absdiff(input,cv::Scalar(target),output);   // 计算目标图像的绝对距离
	      std::vector<cv::Mat> images;
	      cv::split(output,images);    // 分割图像的通道
	      output= images[0]+images[1]+images[2];   // 合并3个通道
	      
		  // 设定阈值
          cv::threshold(output,  // 输入图像
                        output,  // 输出图像
                        maxDist, // 阈值
                        255,     // 最大值
                        cv::THRESH_BINARY_INV); // 阈值类型
	
	      return output;
	  }


	  //设置颜色距离的阈值
	  void setColorDistanceThreshold(int distance) {
		  if (distance<0)
			  distance=0;
		  maxDist= distance;
	  }

	  // 获取颜色距离的阈值
	  int getColorDistanceThreshold() const {
		  return maxDist;
	  }
	  
	  // 设置需要检测的颜色
	  void setTargetColor(uchar blue, uchar green, uchar red) {
		  // BGR的次序
		  target = cv::Vec3b(blue, green, red);

		  if (useLab) {
			  // 创建临时的单像素图像
			  cv::Mat tmp(1, 1, CV_8UC3);
			  tmp.at<cv::Vec3b>(0, 0) = cv::Vec3b(blue, green, red);

			  // 转换成Lab色彩空间
			  cv::cvtColor(tmp, tmp, CV_BGR2Lab);
			  target = tmp.at<cv::Vec3b>(0, 0);
		  }
	  }

	  // 设置需要检测的颜色
	  void setTargetColor(cv::Vec3b color) {
		  target= color;
	  }

	  // 获取需要检测的颜色
	  cv::Vec3b getTargetColor() const {
		  return target;
	  }
};


#endif

/*
    颜色检测处理函数
*/
#include "colordetector.h"
#include <vector>
	
cv::Mat ColorDetector::process(const cv::Mat &image) {

	  result.create(image.size(),CV_8U);

	  // 转换成Lab色彩空间
	  if (useLab)
		  cv::cvtColor(image, converted, CV_BGR2Lab);

	  // 获取迭代器
	  cv::Mat_<cv::Vec3b>::const_iterator it= image.begin<cv::Vec3b>();
	  cv::Mat_<cv::Vec3b>::const_iterator itend= image.end<cv::Vec3b>();
	  cv::Mat_<uchar>::iterator itout= result.begin<uchar>();

	  // 获取转换图像的迭代器
	  if (useLab) {
		  it = converted.begin<cv::Vec3b>();
		  itend = converted.end<cv::Vec3b>();
	  }

	  // 遍历每个像素
	  for ( ; it!= itend; ++it, ++itout) {
          // 通过像素与阈值比较 
		  if (getDistanceToTargetColor(*it)<maxDist) {
			  *itout= 255;
		  } 
		  else {
			  *itout= 0;
		  }
	  }

	  return result;
}

/*
    主函数
*/
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "colordetector.h"

int main()
{
    // step1
    // 创建检测图像的对象
	ColorDetector cdetect;

    // step2
    // 读取原图像
	cv::Mat image= cv::imread("Ferrar_F8.png");
	if (image.empty())
		return 0; 
	cv::namedWindow("Image");
	cv::imshow("Image", image);

    // step3
    // 设置输入参数与输出图像处理效果
	cdetect.setTargetColor(230,190,130);
	cv::namedWindow("Image1");
	cv::Mat image1 = cdetect.process(image);
	cv::imshow("Image1",image1);
    

	// 使用cv::floodFill函数
    ColorDetector colordetector(230, 190, 130, 45, true);  // 第3个构造函数
	cv::floodFill(image,            // 输入/输出图像
		cv::Point(100, 50),         // 起始点
		cv::Scalar(255, 255, 255),  // 填充颜色
		(cv::Rect*)0,               // 填充颜色的边界距离
		cv::Scalar(35, 35, 35),     // 偏差的最小/最大阈值
		cv::Scalar(35, 35, 35),     // 正差阈值，两个阈值通常相等
		cv::FLOODFILL_FIXED_RANGE); // 与起始点像素比较
	cv::namedWindow("Image2");
	cv::Mat image2 = colordetector(image);
	cv::imshow("Image2", image2);
	cv::waitKey();

	return 0;
}