bwlabel的实现方法我这里列举三种（递归、一步法、两步法），其中递归方法和一步法很类似，只不过一步法中用了一个队列实现递归。

主要思路： 
递归：从上至下，从左至右，当搜索到第一个白色点并且其对应的output值没有被标签，然后开始从这个点搜索，在其八邻域内搜索，如果它满足是白色点并且其对应的output值没有被标签这个条件，就将这个点的八邻域继续搜索，这个地方可以使用递归实现. 
但是递归方法没有一步法好，因为递归有着次数限制，当图像不大的时候没有问题，图像很大的时候会栈溢出，报错，此时可以运用一步法，用队列这种数据结构。

一步法：思路和递归一样，从上至下，从左至右，当搜索到第一个白色点并且其对应的output值没有被标签，然后开始从这个点搜索，在其八邻域内搜索，如果它满足是白色点并且其对应的output值没有被标签这个条件，就将这个点添加到待搜索的队列里面，队列移动，直到队列里面没有元素，表示搜索完毕

两步法：应该是这些方法里面最快的方法了，顾名思义Two-pass第一次for循环将图1中4个周围点label先打上，并使用一个数组记录他们的父节点，这个打label的规则如下： 
1. 4个点全是0 处理方法：label+1，并赋值 
2. （至多4个点）全是一样的label 将周围的label赋值给这个点即可 
3. （至多4个点）有两种label label赋值为label小的那个，并将这两个label放到同一个数组里面去 
4. （至多4个点）有三种label，并使最小的值为另外两个值的父节点

第二次for循环，将每个label更新，首先更新为父节点，但是父节点并不一定是连续的，所以需要将不连续的父节点label变成连续的label。 
图1

一步法及两步法相关资料网址： 
https://blog.csdn.net/u012526003/article/details/50970850 
http://www.cnblogs.com/tiandsp/archive/2012/12/06/2805276.html 
https://www.cnblogs.com/evilKing/p/6001654.html 
http://www.cnblogs.com/tiandsp/archive/2012/12/06/2804922.html

递归方法代码：

1. clc;
2. clear;
4. %彩色图像转化成灰度再转化成二值图像
5. global K;
6. global bw;
8. K = imread('rice.png');
9. K = im2bw(K);
11. imshow(K)
12. global r;
13. global c;
14. [r ,c ] = size(K);
15. bw = zeros(r,c);
16. %global count;
17. count = 1;
18. global s;
19. s = 1;%变量s用来控制count，使得一次递归只加一次
21. %连通
22. for i = 1:r
23. for j = 1:c
24. liantong(i,j,count);
25. if s == 0;
26. count = count +1;
27. s = 1;
28. end
29. end
30. end
31. count = count - 1;
33. figure
34. imshow(bw)

递归函数文件（liantong.m）

1. function liantong(i,j,count)
2. global K;
3. global bw;
4. global r;
5. global c;
6. global s;
7. if(K(i,j) == 1 && bw(i,j) == 0 )
8. s = 0;
9. bw(i,j) = count;
10. if(i>1 )
11. liantong(i-1,j,count);
12. if( j > 1)
13. liantong(i-1,j-1,count);
14. end
15. end
16. if(i>1 && j<c)
17. liantong(i-1,j+1,count);
18. end
19. if(j>1)
20. liantong(i,j-1,count);
21. end
22. if(j<c)
23. liantong(i,j+1,count);
24. end
25. if(i<r)
26. liantong(i+1,j,count);
27. if(j>1)
28. liantong(i+1,j-1,count);
29. end
30. end
31. if(i<r && j<c)
32. liantong(i+1,j+1,count);
33. end
34. end
35. end

一步法：

1. K = imread('rice.png');
2. tic
3. K = im2bw(K);
5. %在最外圈加上一圈
6. [r,c] = size(K);
7. K1 = zeros(r+2,c+2);
8. for i = 2:r+1
9. for j = 2:c+1
10. K1(i,j) = K(i-1,j-1);
11. end
12. end
14. output = zeros(r,c);
15. label = 1;
16. neighbour = [-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1];%8个 邻域
18. head = 1;
19. tail = 1;
21. %output相对于K1来说 向左上平移了一个单元
22. for i = 2:r+1
23. for j = 2:c+1
24. if (K1(i,j) == 1 && output(i-1,j-1) == 0)%种子点
25. s{tail} = [i,j];
26. tail = tail + 1;
27. while (head ~= tail)
28. for l = 1:8
29. q = s{head} + neighbour(l,:);%头指针为K(i,j)这个点，在for循环里面不能改变，而尾指针需要增加
30. if q(1) > 1 && q(1) < r+2 && q(2) > 1 && q(2) < c+2
31. if K1(q(1),q(2)) == 1 && output(q(1)-1,q(2)-1) == 0 %满足点条件
32. output(q(1)-1,q(2)-1) = label;
33. s{tail} = q ;%加入队列
34. tail = tail + 1;
35. end
36. end
37. end
38. head = head + 1;
39. end
40. %
41. clear s;
42. label = label + 1;%最后一次label+1，但是并没有使用
43. head = 1;
44. tail =1;%恢复原状，以便下次循环使用
45. end
48. end
49. end
50. label = label - 1;%最后一次label+1没有使用，所以需要减一次
51. toc
52. figure
53. imshow(output)

两步法：

1. clear all;
2. clc;
3. s=imread('rice.png');
4. s = im2bw(s);
6. [r c]=size(s);
7. output=zeros(r,c);
8. label=0; %第一遍遍历时标记的标签数量
10. s1 = zeros(r+2,c+2);
11. for i = 2:r+1
12. for j = 2:c+1
13. s1(i,j) = s(i-1,j-1);
14. end
15. end
17. imtool(s);
18. output1 = zeros(r+2,c+2);
20. pre = zeros(1000);
21. new_label = zeros(1000);
22. new_label_count = 1;
23. %第一次for循环得到下面情况
24. %对于每个点的4周的情况只有三种：
25. %1. 4个点全是0 处理方法：label+1，并赋值
26. %2. （至多4个点）全是一样的label 将周围的label赋值给这个点即可
27. %3. （至多4个点）有两种label
28. label赋值为label小的那个，并将这两个label放到同一个数组里面去
29. %4. （至多4个点）有三种label，这种情况我一开始一直以为是不存在的，直到程序跑出来因为漏掉了这种情况有很多黑点
30. %对于pre数组来说，pre[label] = label的时候是根节点
33. for i = 2:r+1 % y
34. for j = 2:c+1 % x
35. if s1(i,j) == 1
36. %查找周围4个点的情况
37. m = [];%将4个点对应的label值存起来
38. m = [output1(i-1,j),output1(i-1,j-1),output1(i,j-1),output1(i-1,j+1)];
39. m = unique(m);
40. %先去重复，看有没有全是0的情况，没有的话再去0
41. if length(m) == 1 && m(1) == 0
42. label = label + 1;
43. output1(i,j) = label;
44. pre(label) = label;
45. else
46. m(find(m == 0)) = [];
47. m = sort(m);
48. %去除数组中的0元素,并讨论是一种label，还是两种label,并将数组排序，方便将两个label放到同一个数组里面
49. if length(m) == 1
50. output1(i,j) = m(1);
51. elseif length(m) == 2
52. output1(i,j) = m(1);
53. pre(m(2)) = m(1);%m(2)是子节点 m(1)是父节点
54. elseif length(m) == 3
55. output1(i,j) = m(1);
56. pre(m(2)) = m(1);
57. pre(m(3)) = m(1);
58. end
59. end
60. end
61. end
62. end
64. for i = 2:r+1
65. for j = 2:c+1
66. output(i-1,j-1) = output1(i,j);
67. end
68. end
70. %处理pre数组,new_label给根节点重新编号
72. for i = 1:1000
73. if pre(i) ~= 0
74. %当pre数组的内容不为0的时候
75. %1.pre[label] = label label为根节点
76. %2.pre[label] = a label是a的父节点，需要寻找a的根节点
77. if pre(i) ~= i
78. tmp = i;
79. while(pre(tmp) ~= tmp)
80. tmp = pre(tmp);
81. end
82. pre(i) = tmp;
83. else
84. new_label(i) = new_label_count;
85. new_label_count = new_label_count + 1;
86. end
87. end
88. end
90. %需要重新将label编号
91. for i = 1:r
92. for j = 1:c
93. if output(i,j) ~= 0
94. output(i,j) = new_label(pre(output(i,j)));
95. end
96. end
97. end
99. imtool (output);
100. new_label_count = new_label_count - 1;
101. new_label_count