圖像處理之雙邊濾波效果(Bilateral Filtering for Gray and Color Image)

基本介紹：

普通的時空域的低通濾波器，在像素空間完成濾波以后，導致圖像的邊緣部分也變得不那么明顯，

整張圖像都變得同樣的模糊，圖像邊緣細節丟失。雙邊濾波器（ABilateral Filter）可以很好的保

留邊緣的同時消除噪聲。雙邊濾波器能做到這些原因在于它不像普通的高斯/卷積低通濾波，只考

慮了位置對中心像素的影響，它還考慮了卷積核中像素與中心像素之間相似程度的影響，根據位置

影響與像素值之間的相似程度生成兩個不同的權重表(WeightTable)，在計算中心像素的時候加以

考慮這兩個權重，從而實現雙邊低通濾波。據說AdobePhotoshop的高斯磨皮功能就是應用了

雙邊低通濾波算法實現。

程序效果：

看我們的美女lena應用雙邊濾鏡之后

程序關鍵代碼解釋：

建立距離高斯權重表(Weight Table)如下：

private void buildDistanceWeightTable() {
	int size = 2 * radius + 1;
	cWeightTable = new double[size][size];
	for(int semirow = -radius; semirow <= radius; semirow++) {
		for(int semicol = - radius; semicol <= radius; semicol++) {
			// calculate Euclidean distance between center point and close pixels
			double delta = Math.sqrt(semirow * semirow + semicol * semicol)/ds;
			double deltaDelta = delta * delta;
			cWeightTable[semirow+radius][semicol+radius] = Math.exp(deltaDelta * factor);
		}
	}
}

建立RGB值像素度高斯權重代碼如下：

private void buildSimilarityWeightTable() {
	sWeightTable = new double[256]; // since the color scope is 0 ~ 255
	for(int i=0; i<256; i++) {
		double delta = Math.sqrt(i * i ) / rs;
		double deltaDelta = delta * delta;
		sWeightTable[i] = Math.exp(deltaDelta * factor);
	}
}

完成權重和計算與像素×權重和計算代碼如下：

for(int semirow = -radius; semirow <= radius; semirow++) {
	for(int semicol = - radius; semicol <= radius; semicol++) {
		if((row + semirow) >= 0 && (row + semirow) < height) {
			rowOffset = row + semirow;
		} else {
			rowOffset = 0;
		}
		
		if((semicol + col) >= 0 && (semicol + col) < width) {
			colOffset = col + semicol;
		} else {
			colOffset = 0;
		}
		index2 = rowOffset * width + colOffset;
		ta2 = (inPixels[index2] >> 24) & 0xff;
        tr2 = (inPixels[index2] >> 16) & 0xff;
        tg2 = (inPixels[index2] >> 8) & 0xff;
        tb2 = inPixels[index2] & 0xff;
        
        csRedWeight = cWeightTable[semirow+radius][semicol+radius]  * sWeightTable[(Math.abs(tr2 - tr))];
        csGreenWeight = cWeightTable[semirow+radius][semicol+radius]  * sWeightTable[(Math.abs(tg2 - tg))];
        csBlueWeight = cWeightTable[semirow+radius][semicol+radius]  * sWeightTable[(Math.abs(tb2 - tb))];
        
        csSumRedWeight += csRedWeight;
        csSumGreenWeight += csGreenWeight;
        csSumBlueWeight += csBlueWeight;
        redSum += (csRedWeight * (double)tr2);
        greenSum += (csGreenWeight * (double)tg2);
        blueSum += (csBlueWeight * (double)tb2);
	}
}

完成歸一化，得到輸出像素點RGB值得代碼如下：

tr = (int)Math.floor(redSum / csSumRedWeight);
tg = (int)Math.floor(greenSum / csSumGreenWeight);
tb = (int)Math.floor(blueSum / csSumBlueWeight);
outPixels[index] = (ta << 24) | (clamp(tr) << 16) | (clamp(tg) << 8) | clamp(tb);

關于什么卷積濾波，請參考：

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

關于高斯模糊算法，請參考：
http://blog.csdn.net/jia20003/article/details/7234741
最后想說，不給出源代碼的博文不是好博文，基于Java完成的雙邊濾波速度有點慢

可以自己優化，雙邊濾鏡完全源代碼如下：

package com.gloomyfish.blurring.study;
/**
 *  A simple and important case of bilateral filtering is shift-invariant Gaussian filtering
 *  refer to - http://graphics.ucsd.edu/~iman/Denoising/
 *  refer to - http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
 *  thanks to cyber
 */
import java.awt.image.BufferedImage;

public class BilateralFilter extends AbstractBufferedImageOp {
	private final static double factor = -0.5d;
	private double ds; // distance sigma
	private double rs; // range sigma
	private int radius; // half length of Gaussian kernel Adobe Photoshop 
	private double[][] cWeightTable;
	private double[] sWeightTable;
	private int width;
	private int height;
	
	public BilateralFilter() {
		this.ds = 1.0f;
		this.rs = 1.0f;
	}
	
	private void buildDistanceWeightTable() {
		int size = 2 * radius + 1;
		cWeightTable = new double[size][size];
		for(int semirow = -radius; semirow <= radius; semirow++) {
			for(int semicol = - radius; semicol <= radius; semicol++) {
				// calculate Euclidean distance between center point and close pixels
				double delta = Math.sqrt(semirow * semirow + semicol * semicol)/ds;
				double deltaDelta = delta * delta;
				cWeightTable[semirow+radius][semicol+radius] = Math.exp(deltaDelta * factor);
			}
		}
	}
	
	/**
	 * for gray image
	 * @param row
	 * @param col
	 * @param inPixels
	 */
	private void buildSimilarityWeightTable() {
		sWeightTable = new double[256]; // since the color scope is 0 ~ 255
		for(int i=0; i<256; i++) {
			double delta = Math.sqrt(i * i ) / rs;
			double deltaDelta = delta * delta;
			sWeightTable[i] = Math.exp(deltaDelta * factor);
		}
	}
	
	public void setDistanceSigma(double ds) {
		this.ds = ds;
	}
	
	public void setRangeSigma(double rs) {
		this.rs = rs;
	}

	@Override
	public BufferedImage filter(BufferedImage src, BufferedImage dest) {
		width = src.getWidth();
        height = src.getHeight();
        //int sigmaMax = (int)Math.max(ds, rs);
        //radius = (int)Math.ceil(2 * sigmaMax);
        radius = (int)Math.max(ds, rs);
        buildDistanceWeightTable();
        buildSimilarityWeightTable();
        if ( dest == null )
        	dest = createCompatibleDestImage( src, null );

        int[] inPixels = new int[width*height];
        int[] outPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        int index = 0;
		double redSum = 0, greenSum = 0, blueSum = 0;
		double csRedWeight = 0, csGreenWeight = 0, csBlueWeight = 0;
		double csSumRedWeight = 0, csSumGreenWeight = 0, csSumBlueWeight = 0;
        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;
        		ta = (inPixels[index] >> 24) & 0xff;
                tr = (inPixels[index] >> 16) & 0xff;
                tg = (inPixels[index] >> 8) & 0xff;
                tb = inPixels[index] & 0xff;
                int rowOffset = 0, colOffset = 0;
                int index2 = 0;
                int ta2 = 0, tr2 = 0, tg2 = 0, tb2 = 0;
        		for(int semirow = -radius; semirow <= radius; semirow++) {
        			for(int semicol = - radius; semicol <= radius; semicol++) {
        				if((row + semirow) >= 0 && (row + semirow) < height) {
        					rowOffset = row + semirow;
        				} else {
        					rowOffset = 0;
        				}
        				
        				if((semicol + col) >= 0 && (semicol + col) < width) {
        					colOffset = col + semicol;
        				} else {
        					colOffset = 0;
        				}
        				index2 = rowOffset * width + colOffset;
        				ta2 = (inPixels[index2] >> 24) & 0xff;
        		        tr2 = (inPixels[index2] >> 16) & 0xff;
        		        tg2 = (inPixels[index2] >> 8) & 0xff;
        		        tb2 = inPixels[index2] & 0xff;
        		        
        		        csRedWeight = cWeightTable[semirow+radius][semicol+radius]  * sWeightTable[(Math.abs(tr2 - tr))];
        		        csGreenWeight = cWeightTable[semirow+radius][semicol+radius]  * sWeightTable[(Math.abs(tg2 - tg))];
        		        csBlueWeight = cWeightTable[semirow+radius][semicol+radius]  * sWeightTable[(Math.abs(tb2 - tb))];
        		        
        		        csSumRedWeight += csRedWeight;
        		        csSumGreenWeight += csGreenWeight;
        		        csSumBlueWeight += csBlueWeight;
        		        redSum += (csRedWeight * (double)tr2);
        		        greenSum += (csGreenWeight * (double)tg2);
        		        blueSum += (csBlueWeight * (double)tb2);
        			}
        		}
        		
				tr = (int)Math.floor(redSum / csSumRedWeight);
				tg = (int)Math.floor(greenSum / csSumGreenWeight);
				tb = (int)Math.floor(blueSum / csSumBlueWeight);
				outPixels[index] = (ta << 24) | (clamp(tr) << 16) | (clamp(tg) << 8) | clamp(tb);
                
                // clean value for next time...
                redSum = greenSum = blueSum = 0;
                csRedWeight = csGreenWeight = csBlueWeight = 0;
                csSumRedWeight = csSumGreenWeight = csSumBlueWeight = 0;
                
        	}
        }
        setRGB( dest, 0, 0, width, height, outPixels );
        return dest;
	}
	
	public static int clamp(int p) {
		return p < 0 ? 0 : ((p > 255) ? 255 : p);
	}

	public static void main(String[] args) {
		BilateralFilter bf = new BilateralFilter();
		bf.buildSimilarityWeightTable();
	}
}

感覺不錯，請頂一下！

轉載文章請務必注明出自本博客