圖像處理------高斯模糊 分類： 視頻圖像處理 2015-07-24 09:32 29人閱讀 評論(0) 收藏

高斯模糊是一種兩維的卷積模糊操做，在圖像完成高斯模糊相對於均值模糊來講，

計算量會增長，可是高斯模糊能夠實現一些特殊效果，特別是在圖像噪聲(非椒鹽

噪聲)消去方面，更是有着很是好的效果。一維高斯公式以下：

其中x是制定[-n,n]範圍的整數，sigma表明標準方差。一般取值爲1.

一維高斯函數Java代碼以下：

private float[] get1DKernalData(int n, float sigma) {
    float sigma22 = 2*sigma*sigma;
    float Pi2 = 2*(float)Math.PI;
    float sqrtSigmaPi2 = (float)Math.sqrt(Pi2) * sigma ;
    int size = 2*n + 1;
    int index = 0;
    float[] kernalData = new float[size];
    for(int i=-n; i<=n; i++) {
        float distance = i*i;
        kernalData[index] = (float)Math.exp((-distance)/sigma22)/sqrtSigmaPi2;
        System.out.println("\t" + kernalData[index]);
        index++;
    }
    return kernalData;
}

假設輸入 n= 1, sigma = 1時，輸出的Kernel數據爲：

0.24197073, 0.3989423,0.24197073

兩維的高斯分佈函數爲：

對應的Java實現代碼爲：

public float[][] get2DKernalData(int n, float sigma) {
    int size = 2*n +1;
    float sigma22 = 2*sigma*sigma;
    float sigma22PI = (float)Math.PI * sigma22;
    float[][] kernalData = new float[size][size];
    int row = 0;
    for(int i=-n; i<=n; i++) {
        int column = 0;
        for(int j=-n; j<=n; j++) {
            float xDistance = i*i;
            float yDistance = j*j;
            kernalData[row][column] = (float)Math.exp(-(xDistance + yDistance)/sigma22)/sigma22PI;
            column++;
        }
        row++;
    }

    for(int i=0; i<size; i++) {
        for(int j=0; j<size; j++) {
            System.out.print("\t" + kernalData[i][j]);
        }
        System.out.println();
        System.out.println("\t ---------------------------");
    }
    return kernalData;
}

當n=1, sigma=1時對應輸出的Kernel數據爲：

    0.058549833   0.09653235     0.058549833

    0.09653235     0.15915494     0.09653235

    0.058549833   0.09653235     0.058549833

一個2D高斯分佈的圖能夠表示以下：

高斯過濾在圖像處理是一種低通濾波，會除去圖像的細節而保持總體不變化，在圖像美化和特效

方面，高斯過濾有這不少應用。高斯模糊不一樣於均值模糊！

 

本文實現完整的高斯模糊算法包括下面幾個步驟：

1. 生成高斯操做數即Kernel Data

2. 從圖像中讀取像素，利用第一步的操做數，完成卷積。

3. 發現圖像處理先後的最大像素值peak得出rate

4. 完成歸一化操做，返回處理後像素數組

關鍵程序解析：

利用操做數完成卷積的代碼參看之前的Blog文章《圖像處理之理解卷積》

完成歸一化操做的算法很是簡單, 主要是利用第三步計算出來的rate

    // normalization
    float rate = inMax/outMax;
    System.out.println("Rate = " + rate);
    for(int row=0; row<height; row++) {
        for(int col=0; col<width; col++) {
            index = row * width + col;
            int rgb1 = tempoutPixels[index];
int red = (rgb1 >> 16) & 0xff;
int green = (rgb1 >> 8) & 0xff;
int blue = rgb1 & 0xff;
red = (int)(rate * red);
green = (int)(rate * green);
blue = (int)(rate * blue);
outPixels[index] = (rgb1 & 0xff000000) | (red << 16) | (green << 8) | blue;
        }
    }

高斯模糊效果以下：

 - 左邊爲原圖                                                                                                                                                            - 右邊爲高斯模糊以後效果，發現皺紋和手部滑了

等等如今還不最cool的效果，高斯模糊以後若是與原圖像疊加會出現一種Glow的

效果，好像燈光打在圖像上同樣，Glow處理以後的運行效果以下：

原圖：

實現Glow Filter以後的圖像：

實現Glow算法只是高斯模糊輸出像素值疊加原來的像素值。

int index = 0;
for ( int y = 0; y < height; y++ ) {
    for ( int x = 0; x < width; x++ ) {
        int rgb1 = outPixels[index];
        int r1 = (rgb1 >> 16) & 0xff;
        int g1 = (rgb1 >> 8) & 0xff;
        int b1 = rgb1 & 0xff;

        int rgb2 = inPixels[index];
        int r2 = (rgb2 >> 16) & 0xff;
        int g2 = (rgb2 >> 8) & 0xff;
        int b2 = rgb2 & 0xff;

        r1 = PixelUtils.clamp( (int)(r1 + a * r2) );
        g1 = PixelUtils.clamp( (int)(g1 + a * g2) );
        b1 = PixelUtils.clamp( (int)(b1 + a * b2) );

        inPixels[index] = (rgb1 & 0xff000000) | (r1 << 16) | (g1 << 8) | b1;
        index++;
    }
}