我们将讨论以区域为基础的图像分割处理技术。传统的区域分割方法有区域生长和区域分裂与合并，其中最基础的是区域生长法。
 
区域生长法
 
区域生长是根据事先定义的准则将像素或者子区域聚合成更大区域的过程。其基本思想是从一组生长点开始（生长点可以是单个像素，也可以是某个小区域），将与该生长点性质相似的相邻像素或者区域与生长点合并，形成新的生长点，重复此过程直到不能生长为止。生长点和相似区域的相似性判断依据可以是灰度值、纹理、颜色等图像信息。所以区域生长算法关键有三个：
 
1、选择合适的生长点
 2、确定相似性准则即生长准则
 3、确定生长停止条件
 
下面给出一个区域生长的实例：图(a)为原始图像，数字表示像素的灰度。以灰度值为8的像素为初始的生长点，记为f(i,j)。在8邻域内，生长准则是待测点灰度值与生长点灰度值相差为1或0.那么图(b)是第一次区域生长后，f(i-1,j)、f(i,j-1)、f(i,j+1)和生长点灰度值相差都是1，因而被合并。图©是第二次生长后，f(i+1,j)被合并。图(d)为第三次生长后，f(i+1,j-1)、f(i+2,j)被合并，至此，已经不存在满足生长准则的像素点，生长停止。
 

 示例代码：
 
#include <opencv2/opencv.hpp> //头文件
#include <opencv2/highgui.hpp>
#include <iostream>
#include <map>

using namespace cv;
using namespace std;


/***************************************************************************************
Function:  区域生长算法
Input:     src 待处理原图像 pt 初始生长点 th 生长的阈值条件
Output:    肺实质的所在的区域 实质区是白色，其他区域是黑色
Description: 生长结果区域标记为白色(255),背景色为黑色(0)
Return:    NULL
Others:    NULL
***************************************************************************************/
void RegionGrow(cv::Mat& src, cv::Mat& matDst, cv::Point2i pt, int th = 40)
{
	cv::Point2i ptGrowing;						//待生长点位置
	int nGrowLable = 0;								//标记是否生长过
	int nSrcValue = 0;								//生长起点灰度值
	int nCurValue = 0;								//当前生长点灰度值
	matDst = cv::Mat::zeros(src.size(), CV_8UC1);	//创建一个空白区域，填充为黑色
	//生长方向顺序数据
	int DIR[8][2] = { { -1, -1 }, { 0, -1 }, { 1, -1 }, { 1, 0 }, { 1, 1 }, { 0, 1 }, { -1, 1 }, { -1, 0 } };
	std::vector<cv::Point2i> vcGrowPt;						//生长点栈
	vcGrowPt.push_back(pt);							//将生长点压入栈中
	matDst.at<uchar>(pt.y, pt.x) = 255;				//标记生长点
	nSrcValue = src.at<uchar>(pt.y, pt.x);			//记录生长点的灰度值

	while (!vcGrowPt.empty())						//生长栈不为空则生长
	{
		pt = vcGrowPt.back();						//取出一个生长点
		vcGrowPt.pop_back();

		//分别对八个方向上的点进行生长
		for (int i = 0; i < 8; ++i)
		{
			ptGrowing.x = pt.x + DIR[i][0];
			ptGrowing.y = pt.y + DIR[i][1];
			//检查是否是边缘点
			if (ptGrowing.x < 0 || ptGrowing.y < 0 || ptGrowing.x >(src.cols - 1) || (ptGrowing.y > src.rows - 1))
				continue;

			nGrowLable = matDst.at<uchar>(ptGrowing.y, ptGrowing.x);		//当前待生长点的灰度值

			if (nGrowLable == 0)					//如果标记点还没有被生长
			{
				nCurValue = src.at<uchar>(ptGrowing.y, ptGrowing.x);
				if (abs(nSrcValue - nCurValue) < th)					//在阈值范围内则生长
				{
					matDst.at<uchar>(ptGrowing.y, ptGrowing.x) = 255;		//标记为白色
					vcGrowPt.push_back(ptGrowing);					//将下一个生长点压入栈中
				}
			}
		}
	}

}


void on_MouseHandle(int event, int x, int y, int flags, void* param)
{
	cv::Mat& src = *(cv::Mat*) param;
	cv::Mat src_gray, dst;
	if (src.channels() > 1)
		cv::cvtColor(src, src_gray, CV_RGB2GRAY);
	else
		src_gray = src.clone();
	cv::Point2i  pt;
	switch (event)
	{
		//左键按下
	case cv::EVENT_LBUTTONDOWN:
	{
		//x:列 y:行						   
		pt = cv::Point2i(x, y);
		std::cout << "(x,y)=" << "(" << x << "," << y << ")" << std::endl;
	}
	break;
	//左键放开
	char str[16];
	case cv::EVENT_LBUTTONUP:
	{
		//cv::circle(src, cv::Point2i(x, y), 1, cv::Scalar(0, 0, 255), -1, CV_AA);
		//sprintf_s(str, "(%d,%d)", x, y);
		//cv::putText(src, str, cv::Point2i(x, y), 3, 1, cv::Scalar(150, 200,0), 2, 8);
		
		pt = cv::Point2i(x, y);
		RegionGrow(src_gray, dst, pt);  //区域生长
		cv::bitwise_and(src_gray, dst, dst); //与运算
		//imshow("src", src);
		imshow("dst", dst);
	}
	break;
	}


}


int main() 
{
	cv::Mat src = cv::imread("toux.jpg", 0);
	if (src.empty())
	{
		return -1;
	}
	/*
int d: 表示在过滤过程中每个像素邻域的直径范围。如果这个值是非正数，则函数会从第五个参数sigmaSpace计算该值。
double sigmaColor: 颜色空间过滤器的sigma值，这个参数的值月大，表明该像素邻域内有越宽广的颜色会被混合到一起，产生较大的半相等颜色区域。
				  （这个参数可以理解为值域核w_r的\sigma_r）
double sigmaSpace: 坐标空间中滤波器的sigma值，如果该值较大，则意味着越远的像素将相互影响，从而使更大的区域中足够相似的颜色获取相同的颜色。
				   当d>0时，d指定了邻域大小且与sigmaSpace无关，否则d正比于sigmaSpace. （这个参数可以理解为空间域核w_d的\sigma_d）
int borderType=BORDER_DEFAULT: 用于推断图像外部像素的某种边界模式，有默认值BORDER_DEFAULT.
	*/
	int d = 7;
	double sigmaColor = 140;
	double sigmaSpace = 140;

	//cv::imshow("原图", src);

	cv::Mat gauss_src;
	cv::bilateralFilter(src, gauss_src, d, sigmaColor, sigmaSpace, cv::BORDER_DEFAULT);
	cv::namedWindow("双边模糊", CV_WND_PROP_AUTOSIZE);//定义一个img窗口
	cv::namedWindow("dst", CV_WND_PROP_AUTOSIZE);//定义一个dst窗口 
	imshow("双边模糊", gauss_src);
	cv::setMouseCallback("双边模糊", on_MouseHandle, (void*)&gauss_src);//调用回调函数 
	cv::waitKey(0);
}

 
结果：
 
 

 我们将讨论以区域为基础的图像分割处理技术。传统的区域分割方法有区域生长和区域分裂与合并，
 其中最基础的是区域生长法。
 
区域生长法
 
区域生长是根据事先定义的准则将像素或者子区域聚合成更大区域的过程。其基本思想是从一组生长点开始（生长点可以是单个像素，也可以是某个小区域），将与该生长点性质相似的相邻像素或者区域与生长点合并，形成新的生长点，重复此过程直到不能生长为止。生长点和相似区域的相似性判断依据可以是灰度值、纹理、颜色等图像信息。所以区域生长算法关键有三个：
 1、选择合适的生长点
 2、确定相似性准则即生长准则
 3、确定生长停止条件
 　　下面给出一个区域生长的实例：图(a)为原始图像，数字表示像素的灰度。以灰度值为8的像素为初始的生长点，记为f(i,j)。在8邻域内，生长准则是待测点灰度值与生长点灰度值相差为1或0.那么图(b)是第一次区域生长后，f(i-1,j)、f(i,j-1)、f(i,j+1)和生长点灰度值相差都是1，因而被合并。图©是第二次生长后，f(i+1,j)被合并。图(d)为第三次生长后，f(i+1,j-1)、f(i+2,j)被合并，至此，已经不存在满足生长准则的像素点，生长停止。
 
 
示例演示
 
我们实现一个功能，鼠标选择一个初始生长点，生长准则是待测点灰度值与初始生长点灰度值差的绝对值不大于8。示例代码中regionGrow函数参考了《数字图像处理与机器视觉》第九章第五节，regionGrowFast函数是优化过的实现，代码如下：
 
cv::Mat MainWindow::regionGrowFast(const cv::Mat &src, const cv::Point2i seed, int throld)
{
    //convert src to gray for getting gray value of every pixel
    cv::Mat gray;
    cv::cvtColor(src,gray, cv::COLOR_RGB2GRAY);

    // set every pixel to black
    cv::Mat result = cv::Mat::zeros(src.size(), CV_8UC1);
    if((seed.x < 0) || (seed.y < 0))
        return result;
    result.at<uchar>(seed.y, seed.x) = 255;

    //gray value of seed
    int seed_gray = gray.at<uchar>(seed.y, seed.x);
    //grow direction sequenc
    int grow_direction[8][2] = {{-1,-1}, {0,-1}, {1,-1}, {1,0}, {1,1}, {0,1}, {-1,1}, {-1,0}};
    //seeds collection
    std::vector<cv::Point2i> seeds;
    seeds.push_back(seed);

    //start growing
    while(! seeds.empty()){
        //get a seed
        cv::Point2i current_seed = seeds.back();
        seeds.pop_back();

        for(int i = 0; i < 8; ++i){
            cv::Point2i neighbor_seed(current_seed.x + grow_direction[i][0], current_seed.y + grow_direction[i][1]);
            //check wether in image
            if(neighbor_seed.x < 0 || neighbor_seed.y < 0 || neighbor_seed.x > (gray.cols-1) || (neighbor_seed.y > gray.rows -1))
                continue;
            int value = gray.at<uchar>(neighbor_seed.y, neighbor_seed.x);
            if((result.at<uchar>(neighbor_seed.y, neighbor_seed.x) == 0) && (abs(value - seed_gray) <= throld)){
                result.at<uchar>(neighbor_seed.y, neighbor_seed.x) = 255;
                seeds.push_back(neighbor_seed);
            }
        }
    }
    return result;
}
 
运行结果：
 
 
[代码下载]

区域生长法的C++实现（opencv）
 
区域生长法是一种图像分割的常用算法，能够将目标区域精确得分割出来。我的程序是将图像最中央的白色圆形区域提取出来，因此第一个种子点选择在了图像中央。
 待处理图片：
 
 提取结果如下：
 

 代码如下：
 
void AreaGrow(Mat &mat, Mat &growArea)     
//mat为输入图像，growArea为区域生长后的输出图像
{
	//定义第一个种子点位置为图片最中心处	
	int firstSeed_x = mat.cols / 2;
	int firstSeed_y = mat.rows / 2;
	Point firstSeed = Point(firstSeed_x, firstSeed_y);

	growArea = Mat::zeros(mat.size(), CV_8UC1);    //创建一个全黑区域用于存放生长点
	growArea.at<uchar>(firstSeed.x, firstSeed.y) = mat.at<uchar>(firstSeed.x, firstSeed.y);   //为第一个生长点赋值
	Point waitSeed;    //待生长种子点
	int waitSeed_value = 0;    //待生长种子点像素值
	int opp_waitSeed_value = 0;   //mat_thresh中对应待生长种子点处的像素值
	vector<Point> seedVector;     //种子栈
	seedVector.push_back(firstSeed);    //将种子放入栈中最后一个位置
	int direct[8][2] = { {-1,-1}, {0,-1}, {1,-1}, {1,0}, {1,1}, {0,1}, {-1,1}, {-1,0} };  //定义8邻域

	while (!seedVector.empty())     //种子栈不为空则生长，即遍历栈中所有元素后停止生长
	{
		Point seed = seedVector.back();     //取出最后一个元素
		seedVector.pop_back();         //删除栈中最后一个元素,防止重复扫描
		for (int i = 0; i < 8; i++)    //遍历种子点的8邻域
		{
			waitSeed.x = seed.x + direct[i][0];    //第i个坐标0行，即x坐标值
			waitSeed.y = seed.y + direct[i][1];    //第i个坐标1行，即y坐标值

			//检查是否是边缘点
			if (waitSeed.x < 0 || waitSeed.y < 0 ||
				waitSeed.x >(mat.cols - 1) || (waitSeed.y > mat.rows - 1))
				continue;

			waitSeed_value = growArea.at<uchar>(waitSeed.x, waitSeed.y);   //为待生长种子点赋对应位置的像素值
			opp_waitSeed_value = mat.at<uchar>(waitSeed.x, waitSeed.y);
			if (waitSeed_value == 0)     //判断waitSeed是否已经被生长，避免重复生长造成死循环
			{
				if (opp_waitSeed_value != 0)     //区域生长条件
				{
					growArea.at<uchar>(waitSeed.x, waitSeed.y) = mat.at<uchar>(waitSeed.x, waitSeed.y);
					seedVector.push_back(waitSeed);    //将满足生长条件的待生长种子点放入种子栈中
				}
			}
		}
	}
}

 
区域分割
 
区域生长法

 
区域生长法
 
区域生长法的基本思想就是将具有相似性的像素集合起来形成一个区域。
 具体做法就是，首先选择一个种子点，通过比较种子点邻域的相似性，将邻域中满足相似性准则的像素归入种子点所在的区域，然后将这新的像素点定为种子点，重复上述过程，直到没有满足相似性准则的新的邻域像素点产生为止。通过区域生长，一个区域就形成了。
 有三个关键性的问题：
 1.种子点的选择问题，如何选择代表所需区域的种子点？
 借助具体问题的特点来进行选择。
 2.生长过程中停止生长的条件是什么？
 一般是再没有满足生长准则的像素产生为止。
 3.如何判断相邻两个像素是否是相似的呢？
 ①基于区域灰度差的方法。
 1）对所有的像素进行扫描，找出尚没有归属的像素点。
 2）对这像素点的所有邻域像素进行灰度差，找出灰度差满足某一阈值的邻域像素，将他们合并。
 3）以新合并的像素为新的中心，进行步骤2）。检查新像素的邻域，直到区域不能继续扩张为止。
 4）返回步骤1），继续扫描，直到所有像素都有归属为止。
 改进–>该方法对于生长起点的选择具有很大的依赖性。将灰度差阈值设为0，这样所有灰度值相同的像素点就形成了一个区域。然后比较相邻区域之间的平均灰度差，将平均灰度差小于阈值的区域进行合并。问题：对于变化缓慢的相邻区域，会产生错分割。
 改进–>在进行区域生长时，不使用新像素点的灰度值与其邻域进行比较，而是使用新像素点所在的区域的平均灰度值与其邻域的像素点的灰度值进行比较，选择满足阈值的点进行合并。
 ②以灰度分布的相似性为准则。
 1）将像素分成互不重叠的小区域。
 2）比较相邻区域的累计灰度直方图，即比较灰度分布的相似性。参考https://blog.csdn.net/combfish/article/details/45056239
 其实累积直方图就是对直方图分布进行归一化处理。将小于阈值的两个相邻区域进行合并。
 3）设定终止准则，通过反复步骤2），依次将各个区域进行合并。
 
区域生长法的优点是：计算简单，比较适合分割均匀的小结构，往往与其他分割方法联合使用。
 缺点是：对初始种子点的依赖性，而且对噪声比较敏感，出现分割空洞或者过分割。