我们将讨论以区域为基础的图像分割处理技术。传统的区域分割方法有区域生长和区域分裂与合并，其中最基础的是区域生长法。

区域生长法

区域生长是根据事先定义的准则将像素或者子区域聚合成更大区域的过程。其基本思想是从一组生长点开始（生长点可以是单个像素，也可以是某个小区域），将与该生长点性质相似的相邻像素或者区域与生长点合并，形成新的生长点，重复此过程直到不能生长为止。生长点和相似区域的相似性判断依据可以是灰度值、纹理、颜色等图像信息。所以区域生长算法关键有三个：

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);
}

结果：

区域生长法:

通俗的讲就是利用初始种子点，通过邻域判断，获取更多的种子点，以达到生长的目的。

有点像是核聚变的链式反应，一个点找到更多的种子点，然后新的种子点再找到更多的，最后生长结束，种子点库也就清空了。

目前主要使用的是四领域和八领域：

四邻域 (左) 和八邻域 (右) 的示意图：

区域生长的流程图：

  以下是部分代码(参考：结合python与遥感图像的区域生长算法实现 - 知乎)：

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def toString(self):
        return '[' + str(self.x) + ',' + str(self.y) + ']'

def selectConnects(p):
    if p != 0:
        connects = [Point(-1, -1), Point(0, -1), Point(1, -1), Point(1, 0), Point(1, 1),
                    Point(0, 1), Point(-1, 1), Point(-1, 0)]
    else:
        connects = [Point(0, -1), Point(1, 0), Point(0, 1), Point(-1, 0)]
    return connects 

def getGrayDiff(img, currentPoint, tmpPoint):
    return abs(int(img[currentPoint.x, currentPoint.y]) - int(img[tmpPoint.x, tmpPoint.y]))

def regionGrow(img, seeds, thresh, p=1):
    height, weight = img.shape
    seedMark = np.zeros(img.shape)
    seedList = []
    for seed in seeds:
        if seed is not None:
            seedList.append(seed)
    label1 = 255
    connects = selectConnects(p)
    while len(seedList) > 0:
        currentPoint = seedList.pop(0)
        seedMark[currentPoint.y, currentPoint.x] = label1
        for i in range(0, 8):
            tmpX = currentPoint.x + connects[i].x
            tmpY = currentPoint.y + connects[i].y

            if tmpX < 0 or tmpY < 0 or tmpX >= height or tmpY >= weight:
                continue
            grayDiff = getGrayDiff(img, Point(currentPoint.y, currentPoint.x), Point(tmpY, tmpX))
            if grayDiff < thresh and seedMark[tmpY, tmpX] == 0:
                seedMark[tmpY, tmpX] = label1
                seedList.append(Point(tmpX, tmpY))
    return seedMark

def on_EVENT_LBUTTONDOWN(event, x, y, flags, param):
    global num
    if event == cv2.EVENT_LBUTTONDOWN:
        if num < 5:
            num = num + 1
            seeds[num] = Point(x, y)
        else:
            print("已勾选五个点")

 结合以上代码和流程图进行分析：

这是一个灰度值图像的区域生长，通过鼠标左键选取五个种子点，在seeds这个数组中我们传入初始的种子点。假设我们从中拿出一个种子点，将其对应位置设置为白色，以这个种子点作为中心实行八邻域生长。判断周围点的灰度值与它的误差是否小于thresh，如果满足条件我们将这个点加入种子点列表，在种子点列表为空时结束循环。

总结：

写这篇文章的目的主要是记录学习内容，代码部分不知道是不是自己的操作问题，但就运行结果来讲原知乎上代码存在坐标颠倒的问题，坐标（x，y）的 x 与 y 应当对于数组 a[ i , j ] 的 j 和 i ，具体表现为选取左下的点，实际却是以右上对称点进行生长。在这里我进行了修改，所以部分代码显示为x，y部分却是y，x。

后续我会基于这个方法对一些医学图像进行一些切割，来获取深度学习的样本，这里做一些进度的记录和学习内容的笔记。如果有什么想法或是问题，欢迎一起讨论。