图像处理之积分图应用二(快速边缘保留滤波算法)

package com.gloomyfish.ii.demo;
 
import java.awt.image.BufferedImage;
 
/**
 * fast edge preserve filter algorithm base on integral image
 * @author zhigang jia
 * @E-mail:bfnh1998@hotmail.com
 *
 */
public class FastEPFilter extends AbstractImageOptionFilter {
  // 窗口半径大小
  private int xr;
  private int yr;
  private float sigma;
  public FastEPFilter() {
  }
  
  public void setWinsize(int radius) {
    this.xr = radius;
    this.yr = radius;
  }
 
  public float getSigma() {
    return sigma;
  }
 
  public void setSigma(float sigma) {
    this.sigma = sigma;
  }
 
  @Override
  public BufferedImage process(BufferedImage image) {
    long time = System.currentTimeMillis();
    int width = image.getWidth();
    int height = image.getHeight();
    // get image data
    int[] pixels = new int[width * height];
    int[] outPixels = new int[width * height];
    getRGB(image, 0, 0, width, height, pixels);
    int size = (xr * 2 + 1) * (yr * 2 + 1);
    int r = 0, g = 0, b = 0;
    float sigma2 = sigma*sigma;
    
    // per-calculate integral image
    byte[] R = new byte[width*height];
    byte[] G = new byte[width*height];
    byte[] B = new byte[width*height];
    getRGB(width, height, pixels, R, G, B);
    IntIntegralImage rii = new IntIntegralImage();
    rii.setImage(R);
    rii.process(width, height);
    IntIntegralImage gii = new IntIntegralImage();
    gii.setImage(G);
    gii.process(width, height);
    IntIntegralImage bii = new IntIntegralImage();
    bii.setImage(B);
    bii.process(width, height);
    int index = 0;
    
    for (int row = yr; row < height - yr; row++) {
      for (int col = xr; col < width - xr; col++) {
        index = row * width + col;
        r = ((pixels[index] >> 16) & 0xff);
        g = (pixels[index] >> 8) & 0xff;
        b = (pixels[index] & 0xff);
        
        int sr = rii.getBlockSum(col, row, (yr * 2 + 1), (xr * 2 + 1));
        int sg = gii.getBlockSum(col, row, (yr * 2 + 1), (xr * 2 + 1));
        int sb = bii.getBlockSum(col, row, (yr * 2 + 1), (xr * 2 + 1));
        
        float vr = rii.getBlockSquareSum(col, row, (yr * 2 + 1), (xr * 2 + 1));
        float vg = gii.getBlockSquareSum(col, row, (yr * 2 + 1), (xr * 2 + 1));
        float vb = bii.getBlockSquareSum(col, row, (yr * 2 + 1), (xr * 2 + 1));
        
        // 计算均值
        float mr = sr / size;
        float mg = sg / size;
        float mb = sb / size;
        
        // 计算方差
        float dr = (vr - (sr*sr)/size)/size;
        float dg = (vg - (sg*sg)/size)/size;
        float db = (vb - (sb*sb)/size)/size;
        
        // 计算系数K
        float kr = dr / (dr+sigma2);
        float kg = dg / (dg+sigma2);
        float kb = db / (db+sigma2);
        
        // 得到滤波后的像素值
        r = (int)((1-kr)*mr + kr*r);
        g = (int)((1-kg)*mg + kg*g);
        b = (int)((1-kb)*mb + kb*b);
        
        outPixels[row * width + col] = (0xff << 24) | (clamp(r) << 16) | (clamp(g) << 8) | clamp(b);
      }
    }
    System.out.println("FastEPFilter ->> time duration : " + (System.currentTimeMillis() - time));
    BufferedImage dest = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
    setRGB(dest, 0, 0, width, height, outPixels);
    return dest;
  }
  
  /** Returns the red, green and blue planes as 3 byte arrays. */
  public void getRGB(int width, int height, int[] pixels, byte[] R, byte[] G, byte[] B) {
    int c, r, g, b;
    for (int i=0; i < width*height; i++) {
      c = pixels[i];
      r = (c&0xff0000)>>16;
      g = (c&0xff00)>>8;
      b = c&0xff;
      R[i] = (byte)r;
      G[i] = (byte)g;
      B[i] = (byte)b;
    }
  }
 
}