连通组件标记算法–算法修正版

简介: 连通组件标记算法–算法修正版

连通组件标记算法–算法修正版

昨天使用自己修改的连通组件标记算法代码去对一个稍微复杂点的图片做皮肤的最大连通

区域识别,发现Java报了栈溢出错误,自己想了想,感觉是合并标记时其中一段递归的代

码的问题,修改为非递归以后,运行结果吓我一跳,发现更加的不对,最后发现原来我读

取标记时候使用了逻辑操作符&,导致标记超过255时候被低位截取。为了找到这个错误,

花了一个下午的时间重新完成了代码与测试。

 

一:基本原理如下

1338717591_1887.png

以前的有问题的算法版本连接,看这里:

http://blog.csdn.net/jia20003/article/details/7596443

二:完整的算法代码如下:

package com.gloomyfish.face.detection;
 
import java.util.Arrays;
import java.util.HashMap;
 
/**
 * fast connected component label algorithm
 * 
 * @date 2012-05-23
 * @author zhigang
 *
 */
public class AdjustableConnectedComponentLabelAlg {
  private int bgColor;
  public int getBgColor() {
    return bgColor;
  }
 
  public void setBgColor(int bgColor) {
    this.bgColor = bgColor;
  }
 
  private int[] outData;
  private int dw;
  private int dh;
  
  public AdjustableConnectedComponentLabelAlg() {
    bgColor = 255; // black color
  }
 
  public int[] doLabel(int[] inPixels, int width, int height) {
    dw = width;
    dh = height;
    int nextlabel = 1;
    int result = 0;
    outData = new int[dw * dh];
    for(int i=0; i<outData.length; i++) {
      outData[i] = 0;
    }
    
    // we need to define these two variable arrays.
    int[] eightNeighborhoodPixels = new int[8];
    int[] eightNeighborhoodLabels = new int[8];
    int[] knownLabels = new int[8];
    
    int srcrgb = 0, index = 0;
    boolean existedLabel = false;
    for(int row = 0; row < height; row ++) {
      for(int col = 0; col < width; col++) {
        index = row * width + col;
        srcrgb = inPixels[index] & 0x000000ff;
        if(srcrgb == bgColor) {
          result = 0; // which means no labeled for this pixel.
        } else {
          // we just find the eight neighborhood pixels.
          eightNeighborhoodPixels[0] = getPixel(inPixels, row-1, col); // upper cell
          eightNeighborhoodPixels[1] = getPixel(inPixels, row, col-1); // left cell
          eightNeighborhoodPixels[2] = getPixel(inPixels, row+1, col); // bottom cell
          eightNeighborhoodPixels[3] = getPixel(inPixels, row, col+1); // right cell
          
          // four corners pixels
          eightNeighborhoodPixels[4] = getPixel(inPixels, row-1, col-1); // upper left corner
          eightNeighborhoodPixels[5] = getPixel(inPixels, row-1, col+1); // upper right corner
          eightNeighborhoodPixels[6] = getPixel(inPixels, row+1, col-1); // left bottom corner
          eightNeighborhoodPixels[7] = getPixel(inPixels, row+1, col+1); // right bottom corner
          
          // get current possible existed labels
          eightNeighborhoodLabels[0] = getLabel(outData, row-1, col); // upper cell
          eightNeighborhoodLabels[1] = getLabel(outData, row, col-1); // left cell
          eightNeighborhoodLabels[2] = getLabel(outData, row+1, col); // bottom cell
          eightNeighborhoodLabels[3] = getLabel(outData, row, col+1); // right cell
          
          // four corners labels value
          eightNeighborhoodLabels[4] = getLabel(outData, row-1, col-1); // upper left corner
          eightNeighborhoodLabels[5] = getLabel(outData, row-1, col+1); // upper right corner
          eightNeighborhoodLabels[6] = getLabel(outData, row+1, col-1); // left bottom corner
          eightNeighborhoodLabels[7] = getLabel(outData, row+1, col+1); // right bottom corner
          
          int minLabel = 0;
          int count = 0;
          for(int i=0; i<knownLabels.length; i++) {
            if(eightNeighborhoodLabels[i] > 0) {
              existedLabel = true;
              knownLabels[i] = eightNeighborhoodLabels[i];
              minLabel = eightNeighborhoodLabels[i];
              count++;
            }
          }
          
          if(existedLabel) {
            if(count == 1) {
              result = minLabel;
            } else {
              int[] tempLabels = new int[count];
              int idx = 0;
              for(int i=0; i<knownLabels.length; i++) {
                if(knownLabels[i] > 0){
                  tempLabels[idx++] = knownLabels[i];
                }
                if(minLabel > knownLabels[i] && knownLabels[i] > 0) {
                  minLabel = knownLabels[i];
                }
              }
              result = minLabel;
              mergeLabels(index, result, tempLabels);
            }
          } else {
            result = nextlabel;
            nextlabel++;
          }
          outData[index] = result;
          // reset and cleanup the known labels now...
          existedLabel = false;
          for(int kl = 0; kl < knownLabels.length; kl++) {
            knownLabels[kl] = 0;
          }
        }
      }
    }
    
    // labels statistic
    HashMap<Integer, Integer> labelMap = new HashMap<Integer, Integer>();
    for(int d=0; d<outData.length; d++) {
      if(outData[d] != 0) {
        if(labelMap.containsKey(outData[d])) {
          Integer count = labelMap.get(outData[d]);
          count+=1;
          labelMap.put(outData[d], count);
        } else {
          labelMap.put(outData[d], 1);
        }
      }
    }
    
    // try to find the max connected component
    Integer[] keys = labelMap.keySet().toArray(new Integer[0]);
    Arrays.sort(keys);
    int maxKey = 1;
    int max = 0;
    for(Integer key : keys) {
      if(max < labelMap.get(key)){
        max = labelMap.get(key);
        maxKey = key;
      }
      System.out.println( "Number of " + key + " = " + labelMap.get(key));
    }
    System.out.println("maxkey = " + maxKey);
    System.out.println("max connected component number = " + max);
    return outData;
  }
  
  private void mergeLabels (int index, int result, int[] labels) {
    for(int i=0; i<labels.length; i++) {
      if(labels[i] == result) continue;
      mergeLabel(index, result, labels[i]);
    }
  }
 
  private void mergeLabel(int index, int result, int i) {
 
    int row = index / dw;
    int idx = 0;
    for(int k = 0; k <= row; k++) {
      for(int col = 0; col < dw; col++) {
        idx = k * dw + col;
        if(outData[idx] == i) {
          outData[idx] = result;
        }
      }
    }
    
  }
  
  private int getLabel(int[] data, int row, int col) {
    // handle the edge pixels
    if(row < 0 || row >= dh) {
      return 0;
    }
    
    if(col < 0 || col >= dw) {
      return 0;
    }
    
    int index = row * dw + col;
    return (data[index] & 0xffffffff);
    
    // it's difficulty for me to find the data overflow issue......
    // return (data[index] & 0x000000ff); defect, @_@
  }
 
  private int getPixel(int[] data, int row, int col) {
    // handle the edge pixels
    if(row < 0 || row >= dh) {
      return bgColor;
    }
    
    if(col < 0 || col >= dw) {
      return bgColor;
    }
    
    int index = row * dw + col;
    return (data[index] & 0x000000ff);
  }
 
  /**
   * binary image data:
   * 
   * 255, 0,   0,   255,   0,   255, 255, 0,   255, 255, 255,
   * 255, 0,   0,   255,   0,   255, 255, 0,   0,   255, 0,
   * 255, 0,   0,   0,     255, 255, 255, 255, 255, 0,   0,
   * 255, 255, 0,   255,   255, 255, 0,   255, 0,   0,   255
   * 255, 255, 0,   0,     0,   0,   255, 0,   0,   0,   0
   * 
   * height = 5, width = 11
   * @param args
   */
  public static int[] imageData = new int[]{
     255, 0,   0,   255,   0,   255, 255, 0,   255, 255, 255,
     255, 0,   0,   255,   0,   255, 255, 0,   0,   255, 0,
     255, 0,   0,   255,     255, 255, 255, 255, 255, 0,   0,
     255, 255, 0,   255,   255, 255, 0,   255, 0,   0,   255,
     255, 255, 0,   0,     0,   0,   255, 255,   0,   0,   0,
     255, 255, 255, 255,   255, 255, 255, 255, 255, 255, 255,
     255, 0,   255, 0,     255, 0,   0,   255, 255, 255, 255,
     255, 255, 0,   0,     255, 255, 255, 0,   0,   255, 255
  };
  
  public static void main(String[] args) {
    AdjustableConnectedComponentLabelAlg ccl = new AdjustableConnectedComponentLabelAlg();
    int[] outData = ccl.doLabel(imageData, 11, 8);
    for(int i=0; i<8; i++) {
      System.out.println("--------------------");
      for(int j = 0; j<11; j++) {
        int index = i * 11 + j;
        if(j != 0) {
          System.out.print(",");
        }
        System.out.print(outData[index]);
      }
      System.out.println();
    }
  }
 
}

相关文章
|
1月前
|
存储 算法 Java
【JVM】垃圾释放方式:标记-清除、复制算法、标记-整理、分代回收
【JVM】垃圾释放方式:标记-清除、复制算法、标记-整理、分代回收
49 2
|
2月前
|
XML JavaScript 前端开发
学习react基础(1)_虚拟dom、diff算法、函数和class创建组件
本文介绍了React的核心概念,包括虚拟DOM、Diff算法以及如何通过函数和类创建React组件。
26 2
|
4月前
|
算法 Java
Java面试题:解释垃圾回收中的标记-清除、复制、标记-压缩算法的工作原理
Java面试题:解释垃圾回收中的标记-清除、复制、标记-压缩算法的工作原理
58 1
|
4月前
|
算法 Java
Java演进问题之标记-复制算法导致更多的内存占用如何解决
Java演进问题之标记-复制算法导致更多的内存占用如何解决
|
4月前
|
算法 Java 程序员
Java面试题:解释Java的垃圾回收机制,包括常见的垃圾回收算法。介绍一下Java的垃圾回收算法中的标记-压缩算法。
Java面试题:解释Java的垃圾回收机制,包括常见的垃圾回收算法。介绍一下Java的垃圾回收算法中的标记-压缩算法。
49 0
|
5月前
|
存储 算法 安全
JVM-内存划分-垃圾回收器-回收算法-双亲委派-三色标记
JVM-内存划分-垃圾回收器-回收算法-双亲委派-三色标记
|
5月前
|
算法 计算机视觉
图像处理之基于图的广度优先搜索组件标记算法
图像处理之基于图的广度优先搜索组件标记算法
32 0
|
23天前
|
算法 安全 数据安全/隐私保护
基于game-based算法的动态频谱访问matlab仿真
本算法展示了在认知无线电网络中,通过游戏理论优化动态频谱访问,提高频谱利用率和物理层安全性。程序运行效果包括负载因子、传输功率、信噪比对用户效用和保密率的影响分析。软件版本:Matlab 2022a。完整代码包含详细中文注释和操作视频。
|
8天前
|
算法 数据挖掘 数据安全/隐私保护
基于FCM模糊聚类算法的图像分割matlab仿真
本项目展示了基于模糊C均值(FCM)算法的图像分割技术。算法运行效果良好,无水印。使用MATLAB 2022a开发,提供完整代码及中文注释,附带操作步骤视频。FCM算法通过隶属度矩阵和聚类中心矩阵实现图像分割,适用于灰度和彩色图像,广泛应用于医学影像、遥感图像等领域。
|
9天前
|
算法 调度
基于遗传模拟退火混合优化算法的车间作业最优调度matlab仿真,输出甘特图
车间作业调度问题(JSSP)通过遗传算法(GA)和模拟退火算法(SA)优化多个作业在并行工作中心上的加工顺序和时间,以最小化总完成时间和机器闲置时间。MATLAB2022a版本运行测试,展示了有效性和可行性。核心程序采用作业列表表示法,结合遗传操作和模拟退火过程,提高算法性能。