waterShed-分水岭算法的原理及实现

所谓分水岭算法有好多种实现算法，拓扑学，形态学，浸水模拟和降水模拟等方式。要搞懂就不容易了。Watershed Algorithm(分水岭算法)，顾名思义，就是根据分水岭的构成来考虑图像的分割。现实中我们可以或者说可以想象有山有湖的景象，那么那一定是水绕 山，山围水的情形。当然在需要的时候，要人工构筑分水岭，以防集水盆之间的互相穿透。而区分高山（plateaus）与水的界线，以及湖与湖之间的间隔或 都是连通的关系，就是我们可爱的分水岭（watershed）。为了得到一个相对集中的集水盆，那么让水涨到都接近周围的最高的山顶就可以了，再涨就要漏 水到邻居了，而邻居，嘿嘿，水质不同诶，会混淆自我的。那么这样的话，我们就可以用来获取边界灰阶大，中间灰阶小的物体区域了，它就是集水盆。 

浸水法，就是先通过一个适当小的阈值得到起点，即集水盆的底；然后是向周围淹没也就是浸水的过程，直到得到分水岭。当然如果我们要一直淹没到山顶，即是一 直处理到图像灰阶最高片，那么，当中就会出现筑坝的情况，不同的集水盆在这里想相遇了，我们要洁身自爱，到这里为止，因为都碰到边界了；那么即使在相遇时 没有碰到最高灰阶的地方，也需要人工构筑分水岭，区分不同的区域。不再上山。构筑属于自己的分水岭 

在计算机图形学中，可利用灰度表征地貌高。图像中我们可以利用灰度高与地貌高的相似性来研究图像的灰度在空间上的变化。这是空域分析，比如还可以通过各种 形式的梯度计算以得到算法的输入，进行浸水处理。分水岭具有很强的边缘检测能力，对微弱的边缘也有较好的效果。这与分水岭扩张的阈值的设置有关系，阈值可 以决定集水盆扩张的范围。但自我构筑的能力却不受影响。 

为会么这么说呢？为什么有很强的边缘检测能力，而又能得到相对集中的连通的集水盆？现实中很好办，我们在往凹地加水的时候，直到它涨到这一块紧凑的山岭边 缘就不加了；但是如果有一条小山沟存在，那没办法，在初始阈值分割的时候，也就是山沟与集水盆有同样的极小值，而且它们之间是以这个高度一直连接的。那没 关系，我们将它连通。在图像上呢？如何实现？ 

看看算法，算法思想是这样的： 

首先准备好山和初始的水。这山就是我们的初始图像了，比如用自然获取的图像的梯度来表征山地的每一点的高度吧；而初始的水就是在阈值记为Thre底下，所 有的低于这个高度的整个山地都加水，直到这个阈值Thre高度。从而有三个初始量：unsigned char** Ori_image、char** Seed_image和int** Label_image。最后一个是为最终的结果做准备的。当然要做好初始化，比如，Ora_image赋值为原图像（256色灰度图）的梯度 值，Seed_image则是初始状态下有水的置位，无水的复位，而Label_image则全初始化为0，最终得到的是各点对应的区域号。 

接下来是考虑将已加的水进行记录，记录成连通的区域，也就是看看有多少个互不相关的集水盆，有五个，那么我们就涨出五个湖，而且尽可能的高，只要大家想到 不溢出。在算法上，有多少个连通的区域就记录成多少个数据结构，工夫就在于如何将这些连通的区域连接成一块，并由一个数据结构来表达了。很好，我们准备用 一个向量容器来实现初始保存，保存所有标记区域种子队列的数组，里面放的是种子队列的指针 vector*> vque; ，而且这个队列是由一系列属于同一个区域的图像点组成，我们来自一个集水盆：）；其保存方式是这样的：queue *pque=new queue[256]；vque.push_back(pque)，这样便将一个成员放进到这个区域来了，即容器－－集水盆的 保管都，容器中的每个指针，都指向一个集水盆，也就是我们要的连通区域；所以我们可以方便地由这个容器数据结构直接读值的方便性进行操作，一个脚标就可以 得到一个区域（队列指针）的指针；而每个队列还不简单，并不是一列整形数那么易搞，所以说啊，这个算法，真头痛，这个队列的一个成员是一个点；而注意到 vque里存放的一256个队列的的起始指针，真够残忍的。也就是说vque [m] [n]就表达了一个队列，这个队列里可以存储操作一系列的点；显然容量取256是因为所有的初始或者是最终的区域中可能有0-256之间的不同的灰阶的 点，那么我一个区域分用256个队列来记录这些成员点啦，很有可能，这里就只有一个集水盆，那么，256个灰阶的点都存在一个区域就有可能了 

统计初始连通区域的方法是，八连通邻域法（还有其他方法：四连通域，六连通域），即从逐一扫描输入的Seed_image的每个像素点，将所有的标记了的 初始集水盆一一纳入各自的区域，这是整修图像的扫描，形成外循环。先创建一个临时队列que，用来处理当前初始集水盆的连通连接，将逐一扫描到的属 于一个特定的初始集水盆区域的可生长点暂存，并形成一个内循环。对当前扫描点的处理是，首先判断该点是否为某个初始集水盆的点，如果不是跳过；接下来是， 如果是初始集水盆的点，那么它的八连通域中是否存在不可生长的点（这里的不可生长是指Seed_image中没有标记的点），扫描的八连通邻域中的点是可 生长的，即有标记的，则将之加入到临时队列中que；如果扫描到的连通邻域中有不可生长的至少一个点存在，那么加入到种子队列，记当前区域号为 Num，当前扫描点为(m，n)，从而当前的灰阶为Ori_image[m][n]，将当前点添加到种子队列：qu[Num－1] [Ori_image[m][n]].push(POINT(m，n))。这里有两个循环，一个是que，另一个是Seed_image。直到两个 循环完整结束，那么就得到了各个连通初始集水盆的记录，保存标记是区域号Num；而我们同时得到了初始的分水岭，那就放在了保存地点qu，这里面标识 了它们对应的区域号，和区域里面对应的点的灰阶，即是特定区域特定灰阶对应的点的集合；我们可以获取这些分水岭的点所在的区域号，可以得到该区域的所有的 灰阶的点信息。一句话，统计连通区域的功能有两个，一是标记初始区域，二是找分水岭 

初始的区域标记好了，分岭也找到了，那么可以开始“水漫梁山”了。这就是淹没过程。淹没过程由也是由一个内嵌循环的循环来实现的：外循环是做水位上升（这 里循环次数一定要256以内），waterlevel的上升，原来是已经做过了初始的水位分割，那么现在可以从Thre开始了，让水位慢慢上升，让它原本 的湖慢慢扩张，尽量利用其应有的空间，而又不至于淹没到其它的邻居湖泊。内循环是扫描每个初始区域（当前Num，从而有Num个循环）的分水岭的点（在 qu[][]中），按照给定的水位进行扩张。扩张过程是这样的：扫描到的分水岭的当前点，对其进行四连通邻域进行逐一检查，如果四连通域中有点没有标 记的（那这一定是高度较高的点，较低的前面一定扫描过），那么先对该点以本区域号做标记Num（注意是当前的Num）；再判断它在当前水位下是否可生长 （灰阶是否小于等于waterlevel），如果可生长那么加入到qu[Num][waterlevel]种子队列中，将会再次进入内循环，否则如果 在当前水位下不可生长，则加入到这个邻域点的分水岭集合中qu[Num][Ori_image[邻域点]]队列中。如此往复循环，直到对应区域完成， 一个水位，扫描所有的区域的分水岭，这样各自同时在一个水位下扩张，保证了不出现跳跃的情况出现（就是一个水位一个区域全局扩张）。 

最终，所有的区域在每个水位都扩张完毕，得到了分割图，我们的大湖泊形成了 

这是分水岭算法的一种实现方式。仔细考察不难发现这种实现方式不能产生新的集水盆，也就是说，由于初始集水盆的局限性，很可能会浪费大部分没有发掘出来的 起始点较高的集水盆地。这样，我们就要对算法进行修改了。实现方式是：在淹没的过程中，我们是由阈值Thre的水位开始淹没的，那么我们可以对初始区域之 外的没有标记的点（从Seed_image中考察），对之进行标记，条件是先把这一轮的内循环做好，然后在剩下的没标记区域中发掘新的集水盆，并加入到我 们的种子队列中，下一个水位开始，就又多了一个新成员了，让它们不断膨胀，成长，拥有自己的小天的成员就会逐一的被分割出来。不过话说回来，我们这里是采 用梯度图像，一般情况下，阈值初始分割能够满足我们的要求，把灰阶变化平滑的先截取出来，梯度信息已然足够强大；而如果采用了新盆地扩张，则比较适用于原 始图像。 

分水岭算法主要的分割目的在于找到图像的连通区域。利用梯度信息作为输入图像，会有一个矛盾点，如果对原始图像进行梯度计算时不作滤波平滑处理，很容易将 物体分割成多个物体，那是因为噪声的影响；而如果进行滤波处理，又容易造成将某些原本几个的物体合成一个物体。当然这里的物体主要还是指图像变化不大或者 说是灰度值相近的目标区域。

/********  标记-分水岭算法对输入图像进行分割
输入参数：
OriginalImage - 输入图像（灰度图，0~255）
SeedImage     - 标记图像（二值图像，0非标记，1标记）
LabelImage    - 输出图像（1第一个分割区域；2第二个分割区域；3...）
row,col       - 图像行列数目
返回值：
分割区域数目
*/
int Watershed(uchar **OriginalImage, uchar** SeedImage, uchar **LabelImage, int row, int col)
{
	using namespace std;

	int Num = 0;                     //标志区域号，从1开始  
	int i, j;

	vector SeedCounts;       //保存每个队列种子个数容器  
	queue que;              //临时种子队列  
	vector* > qu;     //保存所有标记区域种子队列的数组  

	int* array;
	queue *uu;              //指向种子队列的指针  
	POINT temp;

	for (i = 0; i < row; i++)
	for (j = 0; j < col; j++)
		LabelImage[i][j] = 0;


	int m, n, k = 0;
	int up, down, right, left, upleft, upright, downleft, downright;
    // 预处理，提取区分每个标记区域，并初始化每个标记的种子队列  
	// 种子是指标记区域边缘的点，它们在水位上升时向外生长。   
	for (i = 0; i < row; i++)

	for (j = 0; j < col; j++)
	{
		if (SeedImage[i][j] == 1 || SeedImage[i][j] == 255)  //找到一个标记区域  
		{
			Num++;                                      //标志号加1  
			array = new int[256];
			ZeroMemory(array, 256 * sizeof(int));
			//  
			SeedCounts.push_back(array);
			uu = new queue[256];
			qu.push_back(uu);
			temp.x = i;
			temp.y = j;
			que.push(temp);
			LabelImage[i][j] = Num;
			SeedImage[i][j] = 127;

			while (!que.empty())
			{
				up = down = right = left = 0;
				upleft = upright = downleft = downright = 0;
				temp = que.front();
				m = temp.x;
				n = temp.y;
				que.pop();

				if (m > 0)
				{
					if (SeedImage[m - 1][n] == 1)
					{
						temp.x = m - 1;
						temp.y = n;
						que.push(temp);
						LabelImage[m - 1][n] = Num;
						SeedImage[m - 1][n] = 127;
					}
					else
					{
						up = 1;
					}
				}
				if (m > 0 && n > 0)
				{
					if (SeedImage[m - 1][n - 1] == 1)
					{
						temp.x = m - 1;
						temp.y = n - 1;
						que.push(temp);
						LabelImage[m - 1][n - 1] = Num;
						SeedImage[m - 1][n - 1] = 127;
					}
					else
					{
						upleft = 1;
					}
				}

				if (m < row - 1)
				{
					if (SeedImage[m + 1][n] == 1)
					{
						temp.x = m + 1;
						temp.y = n;
						que.push(temp);
						LabelImage[m + 1][n] = Num;
						SeedImage[m + 1][n] = 127;
					}
					else
					{
						down = 1;
					}
				}
				if (m < (row - 1) && n < (col - 1))
				{
					if (SeedImage[m + 1][n + 1] == 1)
					{
						temp.x = m + 1;
						temp.y = n + 1;
						que.push(temp);
						LabelImage[m + 1][n + 1] = Num;
						SeedImage[m + 1][n + 1] = 127;
					}
					else
					{
						downright = 1;
					}
				}

				if (n < col - 1)
				{
					if (SeedImage[m][n + 1] == 1)
					{
						temp.x = m;
						temp.y = n + 1;
						que.push(temp);
						LabelImage[m][n + 1] = Num;
						SeedImage[m][n + 1] = 127;
					}
					else
					{
						right = 1;
					}
				}
				if (m > 0 && n < (col - 1))
				{
					if (SeedImage[m - 1][n + 1] == 1)
					{
						temp.x = m - 1;
						temp.y = n + 1;
						que.push(temp);
						LabelImage[m - 1][n + 1] = Num;
						SeedImage[m - 1][n + 1] = 127;
					}
					else
					{
						upright = 1;
					}
				}

				if (n > 0)
				{
					if (SeedImage[m][n - 1] == 1)
					{
						temp.x = m;
						temp.y = n - 1;
						que.push(temp);
						LabelImage[m][n - 1] = Num;
						SeedImage[m][n - 1] = 127;
					}
					else
					{
						left = 1;
					}
				}
				if (m<(row - 1) && n>0)
				{
					if (SeedImage[m + 1][n - 1] == 1)
					{
						temp.x = m + 1;
						temp.y = n - 1;
						que.push(temp);
						LabelImage[m + 1][n - 1] = Num;
						SeedImage[m + 1][n - 1] = 127;
					}
					else
					{
						downleft = 1;
					}
				}

				//上下左右只要有一点不可生长，则本点为初始种子队列的一员  
					if (up || down || right || left || upleft || downleft || upright || downright)
					{
						temp.x = m;
						temp.y = n;
						qu[Num - 1][OriginalImage[m][n]].push(temp);
						SeedCounts[Num - 1][OriginalImage[m][n]]++;
					}
			}
		}
	}
}

bool actives;                                 //某一水位，所有标记种子生长完的标志  
int WaterLevel;                         
//淹没过程开始，水位从零上升，水位对应灰度级，采用四联通法  
for (WaterLevel = 1; WaterLevel < 255; WaterLevel++)
{
	actives = true;
	while (actives)
	{
		
			actives = false;
		for (i = 0; i0)
				{
					SeedCounts[i][WaterLevel]--;
					temp = qu[i][WaterLevel].front();
					qu[i][WaterLevel].pop();
					m = temp.x;
					n = temp.y;
					if (m > 0)
					{
						if (!LabelImage[m - 1][n])
						{
							temp.x = m - 1;
							temp.y = n;
							lImage[m - 1][n] = i + 1;

								//上方点标记为已淹没区域。这个标记与扫描点区域号相同，一定在标号所在区域。  
							if (OriginalImage[m - 1][n] <= WaterLevel)
							{
								qu[i][WaterLevel].push(temp);
							}
							else
							{
								qu[i][OriginalImage[m - 1][n]].push(temp);
								SeedCounts[i][OriginalImage[m - 1][n]]++;
							}
						}
					}

					if (m < row - 1)
					{
						if (!LabelImage[m + 1][n])
						{
							temp.x = m + 1;
							temp.y = n;
							LabelImage[m + 1][n] = i + 1;

							if (OriginalImage[m + 1][n] <= WaterLevel)
							{
								qu[i][WaterLevel].push(temp);
							}
							else
							{
								qu[i][OriginalImage[m + 1][n]].push(temp);
								SeedCounts[i][OriginalImage[m + 1][n]]++;
							}
						}
					}

					if (n < col - 1)
					{
						if (!LabelImage[m][n + 1])
						{
							temp.x = m;
							temp.y = n + 1;
							LabelImage[m][n + 1] = i + 1;

							if (OriginalImage[m][n + 1] <= WaterLevel)
							{
								qu[i][WaterLevel].push(temp);
							}
							else
							{
								qu[i][OriginalImage[m][n + 1]].push(temp);
								SeedCounts[i][OriginalImage[m][n + 1]]++;
							}
						}
					}

					if (n > 0)
					{
						if (!LabelImage[m][n - 1])
						{
							temp.x = m;
							temp.y = n - 1;
							LabelImage[m][n - 1] = i + 1;

							if (OriginalImage[m][n - 1] <= WaterLevel)
							{
								qu[i][WaterLevel].push(temp);
							}
							else
							{
								qu[i][OriginalImage[m][n - 1]].push(temp);
								SeedCounts[i][OriginalImage[m][n - 1]]++;
							}
						}
					}
				}
				SeedCounts[i][WaterLevel] = (int)qu[i][WaterLevel].size();
			}
		}
	}
}

while (!qu.empty())
{
	uu = qu.back();
	delete[] uu;
	qu.pop_back();
}
while (!SeedCounts.empty())
{
	array = SeedCounts.back();
	delete[] array;
	SeedCounts.pop_back();
}
return Num;
}

调用方法如下：

int ROW = Img->height;
int COL = Img->width;
uchar **arrDist;
uchar **arrSeed;
uchar **arrLabel;
arrDist = (uchar **)malloc(ROW * sizeof(uchar*));
arrSeed = (uchar **)malloc(ROW * sizeof(uchar*));
arrLabel = (uchar **)malloc(ROW * sizeof(uchar*));
for (int i = 0; i < ROW; i++)
{
	arrDist[i] = (uchar*)malloc(COL * sizeof(uchar));

	for (int i = 0; i < ROW; i++)
	{
		memcpy(arrDist[i], imgMat.ptr(i), COL* sizeof(uchar));
		for (int j = 0; j < COL; j++)
			arrDist[i][j] = 255 - arrDist[i][j];
	}
}
	
	for (int i = 0; i< ROW; i++)
		memcpy(arrSeed[i], imgMat2.ptr(i), COL* sizeof(uchar));
	
int num = Watershed(arrDist, arrSeed, arrLabel, ROW, COL);

参考：

http://www.360doc.com/content/10/0512/21/1217721_27287483.shtml#

http://blog.csdn.net/augusdi/article/details/9022509

http://blog.csdn.net/nagao_kagetora/article/details/5995925