java图像处理--连通区域计数bwlable

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

}
}

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

}

测试结果如下：



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