图像处理之基于图的广度优先搜索组件标记算法

简介: 图像处理之基于图的广度优先搜索组件标记算法

图像处理之基于图的广度优先搜索组件标记算法

一:图的遍历与广度优先搜索算法

图的遍历算法最常用是广度优先搜索算法(BFS)与深度优先搜索算法(DFS),从一个的

节点开始,访问相邻的所有子节点,接着从这些子节点出发访问下个相邻子节点,如

此重复直到所有节点都被访问。

二:二值图像组件标记实现流程

如果把图像的每个像素点看成为图的一个节点,则二值图像中的每个连通区域都可以

看成一个无向图,只要遍历图像中的每个像素点就可以找出每个连通区域,实现对二

值图像连通区域组件的标记。大致步骤为:

1.      扫描图像的每个像素点,获得位置信息与图像的灰度值强度(0~255)成为图的节点

2.      对每个节点,初始化状态与获取它的上下左右四个邻域节点


1.      遍历每个节点- BFS

2.      输出结果与显示

三:运行效果

四:关键程序实现代码

图的搜索算法,节点状态有三种,未访问(Unvisit),已经访问(Visited),已经标记(Marked)

package com.gloomyfish.image.watershed;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 * Breath First Search for graphics
 * @author gloomyfish
 *
 */
public class BFSAlgorithm {
  private List<PixelPoint> pixelList = null;
  private int grayLevel = 1;
  public int getGrayLevel() {
    return grayLevel;
  }
  
  public int getTotalOfLabels()
  {
    Map<Integer, Integer> labelMap = new HashMap<Integer, Integer>();
    for(PixelPoint p : pixelList)
    {
      if(p.getValue() >= grayLevel)
      {
        if(labelMap.containsKey(p.getLabel()))
        {
          Integer count = labelMap.get(p.getLabel());
          count += 1;
          labelMap.put(p.getLabel(), count);
        }
        else
        {
          labelMap.put(p.getLabel(), new Integer(1));
        }
      }
    }
    Integer[] keys = labelMap.keySet().toArray(new Integer[0]);
    for(Integer key : keys)
    {
      System.out.println("Label index : " + key);
    }
    System.out.println("total labels : " + labelMap.size());
    return labelMap.size();
  }
 
  public void setGrayLevel(int grayLevel) {
    this.grayLevel = grayLevel;
  }
 
  public BFSAlgorithm(List<PixelPoint> pixelList)
  {
    this.pixelList = pixelList;
    grayLevel = 1; // front color - target pixel
  }
  
  public void process()
  {
    if(this.pixelList == null) return;
    int label = 1;
    for(PixelPoint pp : pixelList)
    {
      if(pp.getValue() >= grayLevel)
      {
        if(pp.getStatus() == PixelPoint.UNMARKED)
        {
          pp.setStatus(PixelPoint.VISITED);
          pp.setLabel(label);
          MyQueue mq = new MyQueue(10000);
          for(PixelPoint npp : pp.getNeighbours())
          {
            if(npp.getStatus() == PixelPoint.UNMARKED && npp.getValue() >= grayLevel)
            {
              npp.setStatus(PixelPoint.MARKED);
              mq.enqueue(npp);
            }
          }
          while(!mq.isEmpty())
          {
            PixelPoint obj = (PixelPoint)mq.dequeue();
            if(obj.getStatus() == PixelPoint.MARKED)
            {
              obj.setLabel(label);
              obj.setStatus(PixelPoint.VISITED);
            }
            for(PixelPoint nnpp : obj.getNeighbours())
            {
              if(nnpp.getStatus() == PixelPoint.UNMARKED && nnpp.getValue() >= grayLevel)
              {
                nnpp.setStatus(PixelPoint.MARKED);
                mq.enqueue(nnpp);
              }
            }
          }
          label++;
        }
      }
    }
  }
 
}

图像组件标记算法代码:

package com.gloomyfish.image.watershed;
 
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
 
import com.gloomyfish.filter.study.AbstractBufferedImageOp;
/**
 * work for binary image
 * @author fish
 *
 */
public class LabelledConnectedRegionAlg extends AbstractBufferedImageOp {
 
  @Override
  public BufferedImage filter(BufferedImage src, BufferedImage dest) {
    int width = src.getWidth();
        int height = src.getHeight();
 
        if ( dest == null )
            dest = createCompatibleDestImage( src, null );
        List<PixelPoint> pixelList = new ArrayList<PixelPoint>();
        int[] inPixels = new int[width*height];
        int[] outPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        int index = 0;
        for(int row=0; row<height; row++) {
          for(int col=0; col<width; col++) {
            index = row * width + col;
            PixelPoint p = new PixelPoint(row, col, (inPixels[index] >> 16) & 0xff);
            pixelList.add(p);
          }
        }
        
        for(int row=0; row<height; row++) {
          for(int col=0; col<width; col++) {
            index = row * width + col;
            PixelPoint p = pixelList.get(index);
            
            // add four neighbors for each pixel
            if((row - 1) >= 0)
            {
              index = (row-1) * width + col;
              p.addNeighour(pixelList.get(index));
            }
            if((row + 1) < height)
            {
              index = (row+1) * width + col;
              p.addNeighour(pixelList.get(index));
            }
            if((col - 1) >= 0)
            {
              index = row * width + col-1;
              p.addNeighour(pixelList.get(index));
            }
            if((col+1) < width)
            {
              index = row * width + col+1;
              p.addNeighour(pixelList.get(index));
            }
          }
        }
 
        BFSAlgorithm bfs = new BFSAlgorithm(pixelList);
        bfs.process();
        int labels = bfs.getTotalOfLabels();
        int unit = 255 / (labels+1);
        
        // post process - color different labels
        for(int row=0; row<height; row++) {
          int ta = 0, tr = 0, tg = 0, tb = 0;
          for(int col=0; col<width; col++) {
            index = row * width + col;
            PixelPoint p = pixelList.get(index);
            ta = 255;
            if(p.getLabel() > 0)
            {
              tr = 0; // unit * p.getLabel();
                  tg = unit * p.getLabel();
                  tb = unit * p.getLabel();
            }
            else
            {
                tr = p.getValue();
                    tg = p.getValue();
                    tb = p.getValue();
            }
                outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;
          }
        }
        
        setRGB( dest, 0, 0, width, height, outPixels );
        return dest;
  }
 
}

转载请务必注明

相关实践学习
RocketMQ一站式入门使用
从源码编译、部署broker、部署namesrv,使用java客户端首发消息等一站式入门RocketMQ。
消息队列 MNS 入门课程
1、消息队列MNS简介 本节课介绍消息队列的MNS的基础概念 2、消息队列MNS特性 本节课介绍消息队列的MNS的主要特性 3、MNS的最佳实践及场景应用 本节课介绍消息队列的MNS的最佳实践及场景应用案例 4、手把手系列:消息队列MNS实操讲 本节课介绍消息队列的MNS的实际操作演示 5、动手实验:基于MNS,0基础轻松构建 Web Client 本节课带您一起基于MNS,0基础轻松构建 Web Client
相关文章
|
5天前
|
存储 算法 Java
Java中,树与图的算法涉及二叉树的前序、中序、后序遍历以及DFS和BFS搜索。
【6月更文挑战第21天】Java中,树与图的算法涉及二叉树的前序、中序、后序遍历以及DFS和BFS搜索。二叉树遍历通过访问根、左、右子节点实现。DFS采用递归遍历图的节点,而BFS利用队列按层次访问。以下是简化的代码片段:[Java代码略]
16 4
|
19天前
|
算法 计算机视觉
图像处理之积分图应用四(基于局部均值的图像二值化算法)
图像处理之积分图应用四(基于局部均值的图像二值化算法)
25 0
|
19天前
|
监控 算法 图计算
图像处理之积分图应用三(基于NCC快速相似度匹配算法)
图像处理之积分图应用三(基于NCC快速相似度匹配算法)
19 0
|
19天前
|
文字识别 算法 计算机视觉
图像处理之Zhang Suen细化算法
图像处理之Zhang Suen细化算法
12 0
|
9天前
|
存储 算法 Java
广度优先搜索(Breadth-First Search,BFS)是一种用于图的遍历或搜索的算法。
广度优先搜索(Breadth-First Search,BFS)是一种用于图的遍历或搜索的算法。
|
19天前
|
算法 Java 计算机视觉
图像处理之积分图算法
图像处理之积分图算法
13 2
|
19天前
|
算法 计算机视觉
图像处理之三种常见双立方插值算法
图像处理之三种常见双立方插值算法
16 2
|
19天前
|
算法 Java API
记录我第一次在Android开发图像处理算法的经历
记录我第一次在Android开发图像处理算法的经历
20 1
|
19天前
|
资源调度 算法 计算机视觉
图像处理之积分图应用二(快速边缘保留滤波算法)
图像处理之积分图应用二(快速边缘保留滤波算法)
11 0
|
19天前
|
算法 BI 计算机视觉
图像处理之积分图应用一(半径无关的快速模糊算法)
图像处理之积分图应用一(半径无关的快速模糊算法)
13 0