java图像处理--连通区域计数bwlable_如何计算8连通域的个数

java图像处理之图的联通计数
图的联通分量计数，根据连通区域可分为八连通和四连通
（1）八连通：上左，上，上右，左，右，下左，下，下右
1 1 1
1 0 1
1 1 1 0和周围的1都视为连通关系
（2）四连通：上，下，左，右
2 1 2
1 0 1
2 1 2 0仅和周围的1连通，和二视为不连通

主要思路如下

图像的联通分量计算，
使用递归算法，首先创建一个二维的的数组，用于存放二进制的图像数据，
（1）起初白色为1，黑色为0， 用for循环去遍历图像，横向扫描，由于图像已经使用腐蚀算法去除了细小的杂质和，简单的分离了白色区域，对其连通区域进行标记为 n
（2）标记逻辑为：
使用递归算法，对其周围四个进行访问，（四连通）直至周围没有1，遇到联通的可以标记为同一个数字。
使用递归算法，对其周围八个进行访问，（八连通）直至周围没有1，遇到联通的可以标记为同一个数字。

源码如下：

八连通和四连通算法及UI测试代码实现如下

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class bwlable extends JPanel{

    int image[][];
    BufferedImage grayImage;
    BufferedImage colorImage;
    int counter=1;

    public bwlable(int[][] grayImageData) {
        // TODO Auto-generated constructor stub

        image = new int[grayImageData.length][grayImageData[1].length];
        for (int i = 1; i < grayImageData.length-1; i++) {
            for (int j = 1; j < grayImageData[0].length-1; j++) {
                image[i][j] = grayImageData[i][j];
            }
        }
        for (int i = 1; i < grayImageData.length-1; i++) {
            for (int j = 1; j < grayImageData[0].length-1; j++) {
                if (image[i][j] == 1) {
                    counter++;
                    dealBwlabe(i,j);
                }
            }
        }
        System.out.println(counter-1);

        color();
        dialog();

    }

    private void dealBwlabe(int i, int j) {
        // TODO Auto-generated method stub
        //上
        if (image[i-1][j] == 1) {
            image[i-1][j] = counter;
            dealBwlabe(i-1, j);
        }
        //左
        if (image[i][j-1] == 1) {
            image[i][j-1] = counter;
            dealBwlabe(i, j-1);
        }
        //下
        if (image[i+1][j] == 1) {
            image[i+1][j] = counter;
            dealBwlabe(i+1, j);
        }
        //右
        if (image[i][j+1] == 1) {
            image[i][j+1] = counter;
            dealBwlabe(i, j+1);
        }

八连通需要
//      //上左
//      if (image[i-1][j-1] == 1) {
//          image[i-1][j-1] = counter;
//          dealBwlabe(i-1, j-1);
//      }
//      //上右
//      if (image[i-1][j+1] == 1) {
//          image[i-1][j+1] = counter;
//          dealBwlabe(i-1, j+1);
//      }
//      //下左
//      if (image[i+1][j-1] == 1) {
//          image[i+1][j-1] = counter;
//          dealBwlabe(i+1, j-1);
//      }
//      //下右
//      if (image[i+1][j+1] == 1) {
//          image[i+1][j+1] = counter;
//          dealBwlabe(i+1, j+1);
//      }       

    }

    private void color(){

        int color[];
        color = new int[counter+1];

        for (int i = 0; i < color.length; i++)  
            color[i] = (int) (0xff000000+Math.random()*0xffffff);
        colorImage = new BufferedImage(image.length, image[0].length, 5);

        for (int i = 0; i < colorImage.getWidth(); i++) 
            for (int j = 0; j < colorImage.getHeight(); j++) 
            {   if (image[i][j] > 0) colorImage.setRGB(i, j, color[image[i][j]]);
                else colorImage.setRGB(i, j, 0xff000000);
            }

    }

    public void dialog(){
        JFrame mFrame = new JFrame();
        mFrame.setSize(800, 500);
        mFrame.setVisible(true);

        mFrame.add(this);
        //mFrame
    }
    @Override
    public void paint(Graphics g) {
        // TODO Auto-generated method stub
        super.paint(g);
        try {
            grayImage = ImageIO.read(new File("specialGray.jpg"));

            g.drawImage(grayImage, 0, 0, 400, 500, null);
            g.drawImage(colorImage, 402, 0, 400, 500, null);
            g.setColor(Color.red);
            Font mFont= g.getFont();
            g.setFont(new Font(mFont.getFontName(), Font.PLAIN, 20));
            g.drawString(counter-1+" ", 2, 20);
            g.drawString("原图", 100, 400);
            g.drawString("染色处理图", 500, 400);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

test代码如下：

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class test {

    public static void main(String[] args) throws IOException {

//      new bwlable(getCircle(10));
        BufferedImage mBufferedImage = ImageIO.read(new File("specialGray.jpg"));

        int image[][];
        image = new int[mBufferedImage.getWidth()][mBufferedImage.getHeight()];
        int numRGB = 0xff222222;
        for (int i = 0; i < image.length; i++) {
            for (int j = 0; j < image[0].length; j++) {
                if (mBufferedImage.getRGB(i, j) > numRGB)   image[i][j] = 1;
                else image[i][j] = 0;
            }
        }
        new bwlable(image);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

---

测试结果如下：

算法实现敬请参考，欢迎指点