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

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

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

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

图的遍历算法最常用是广度优先搜索算法(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版:基础消息收发功能体验
本实验场景介绍消息队列RocketMQ版的基础消息收发功能,涵盖实例创建、Topic、Group资源创建以及消息收发体验等基础功能模块。
消息队列 MNS 入门课程
1、消息队列MNS简介 本节课介绍消息队列的MNS的基础概念 2、消息队列MNS特性 本节课介绍消息队列的MNS的主要特性 3、MNS的最佳实践及场景应用 本节课介绍消息队列的MNS的最佳实践及场景应用案例 4、手把手系列:消息队列MNS实操讲 本节课介绍消息队列的MNS的实际操作演示 5、动手实验:基于MNS,0基础轻松构建 Web Client 本节课带您一起基于MNS,0基础轻松构建 Web Client
相关文章
|
13天前
|
算法 安全 Java
算法系列之广度优先搜索解决妖怪和尚过河问题
BFS 是一种逐层扩展的搜索算法,适用于寻找最短路径。我们可以将每个状态看作图中的一个节点,合法的移动就是节点之间的边。通过 BFS,我们可以找到从初始状态到目标状态的最短路径。
82 30
算法系列之广度优先搜索解决妖怪和尚过河问题
|
10天前
|
算法 Java
算法系列之深度/广度优先搜索解决水桶分水的最优解及全部解
在算法学习中,广度优先搜索(BFS)适用于解决最短路径问题、状态转换问题等。深度优先搜索(DFS)适合路径搜索等问题。本文将介绍如何利用广度优先搜索解决寻找`3 个 3、5、8 升水桶均分 8 升水`的最优解及深度优先搜索寻找可以解决此问题的所有解决方案。
48 7
 算法系列之深度/广度优先搜索解决水桶分水的最优解及全部解
|
15天前
|
监控 算法 安全
公司电脑网络监控场景下 Python 广度优先搜索算法的深度剖析
在数字化办公时代,公司电脑网络监控至关重要。广度优先搜索(BFS)算法在构建网络拓扑、检测安全威胁和优化资源分配方面发挥重要作用。通过Python代码示例展示其应用流程,助力企业提升网络安全与效率。未来,更多创新算法将融入该领域,保障企业数字化发展。
38 10
|
1月前
|
存储 算法
算法系列之搜索算法-广度优先搜索BFS
广度优先搜索(BFS)是一种非常强大的算法,特别适用于解决最短路径、层次遍历和连通性问题。在面试中,掌握BFS的基本实现和应用场景,能够帮助你高效解决许多与图或树相关的问题。
38 1
算法系列之搜索算法-广度优先搜索BFS
|
16天前
|
监控 算法 安全
基于 Python 广度优先搜索算法的监控局域网电脑研究
随着局域网规模扩大,企业对高效监控计算机的需求增加。广度优先搜索(BFS)算法凭借其层次化遍历特性,在Python中可用于实现局域网内的计算机设备信息收集、网络连接状态监测及安全漏洞扫描,确保网络安全与稳定运行。通过合理选择数据结构与算法,BFS显著提升了监控效能,助力企业实现智能化的网络管理。
27 7
|
4月前
|
JSON 算法 数据挖掘
基于图论算法有向图PageRank与无向图Louvain算法构建指令的方式方法 用于支撑qwen agent中的统计相关组件
利用图序列进行数据解读,主要包括节点序列分析、边序列分析以及结合节点和边序列的综合分析。节点序列分析涉及节点度分析(如入度、出度、度中心性)、节点属性分析(如品牌、价格等属性的分布与聚类)、节点标签分析(如不同标签的分布及标签间的关联)。边序列分析则关注边的权重分析(如关联强度)、边的类型分析(如管理、协作等关系)及路径分析(如最短路径计算)。结合节点和边序列的分析,如子图挖掘和图的动态分析,可以帮助深入理解图的结构和功能。例如,通过子图挖掘可以发现具有特定结构的子图,而图的动态分析则能揭示图随时间的变化趋势。这些分析方法结合使用,能够从多个角度全面解读图谱数据,为决策提供有力支持。
182 0
|
5月前
|
存储 算法 Java
【JVM】垃圾释放方式:标记-清除、复制算法、标记-整理、分代回收
【JVM】垃圾释放方式:标记-清除、复制算法、标记-整理、分代回收
128 2
|
6月前
|
XML JavaScript 前端开发
学习react基础(1)_虚拟dom、diff算法、函数和class创建组件
本文介绍了React的核心概念,包括虚拟DOM、Diff算法以及如何通过函数和类创建React组件。
68 3
|
5月前
|
机器学习/深度学习 存储 算法
数据结构与算法——BFS(广度优先搜索)
数据结构与算法——BFS(广度优先搜索)
|
8月前
|
算法 Java
Java演进问题之标记-复制算法导致更多的内存占用如何解决
Java演进问题之标记-复制算法导致更多的内存占用如何解决

热门文章

最新文章