图像处理------图像加噪

图像噪声源于现实世界中数字信号总会受到各种各样的干扰，最终接受的图像和源于的数字信号之间总

是存在一定的差异，对于图像噪声，使用均值滤波和中值滤波来消除图像噪声的做法已经是很常见的图

像消噪手段。

一：图像加噪原理

1.     椒盐噪声（Salt And Pepper Noise）

椒盐噪声是一种因为信号脉冲强度引起的噪声，信噪比（Signal NoiseRate）是衡量图像噪声的一个数字指标。

给一副数字图像加上椒盐噪声的处理顺序应该如下：

1. 指定信噪比 SNR 其取值范围在[0, 1]之间
2. 计算总像素数目 SP， 得到要加噪的像素数目 NP = SP * (1-SNR)
3. 随机获取要加噪的每个像素位置P（i, j）
4. 指定像素值为255或者0。
5. 重复c, d两个步骤完成所有像素的NP个像素
6. 输出加噪以后的图像

2.     高斯噪声（Gaussian Noise）

高斯噪声的密度取决于公式G(x, sigma) 其中X是代表平均值，sigma代表的标准方差，每个输入像素 Pin, 

一个正常的高斯采样分布公式G(d), 得到输出像素Pout.

       Pout = Pin + XMeans + sigma *G(d)

其中d为一个线性的随机数，G(d)是随机数的高斯分布随机值。

给一副数字图像加上高斯噪声的处理顺序如下：

a.      输入参数sigam 和 X mean

b.      以系统时间为种子产生一个伪随机数

c.      将伪随机数带入G（d）得到高斯随机数

d.      根据输入像素计算出输出像素

e.      重新将像素值防缩在[0 ~ 255]之间

f.       循环所有像素

g.      输出图像

二：关键程序解析

1.     椒盐噪声

根据信噪比，获取要加入椒盐噪声的像素数目

int size= (int)(inPixels.length * (1-SNR));

随机得到像素，完成椒盐噪声的加入

for(int i=0; i<size; i++) {

int row = (int)(Math.random()* (double)height);

int col = (int)(Math.random()* (double)width);

index= row * width + col;

inPixels[index]= (255 << 24) | (255 << 16) | (255 << 8) | 255;

}

2.     高斯噪声

根据标准方差，和伪随机数的范围，首先计算出一个伪随机数d ，根据d得到高斯分布的随机数值，整个代码如下：

    float d = (float)Math.random()*RANDOM_SCOPE - RANDOM_SCOPE/2;

    float sigma2 = sigma*sigma*2;

    float PI2 = (float)Math.PI * 2;

    float sigmaPI2 = (float)Math.sqrt(PI2*sigma);

    float result = (float)Math.exp(-d/sigma2)/sigmaPI2;

伪随机数的范围为[-127~ 127]之间。

获取高斯噪声的像素代码如下：

tr = (int)((float)tr + getGaussianValue() + this.means);

tg = (int)((float)tg + getGaussianValue() + this.means);

tb = (int)((float)tb + getGaussianValue() + this.means);

mean是的值为0.

三：程序效果如下

加入白色椒盐噪声的图片

加入高斯噪声的图片

椒盐噪声的代码如下：

[java] view plaincopy

1. private BufferedImage addSaltAndPepperNoise(BufferedImage src, BufferedImage dst) {  
2.     int width = src.getWidth();  
3.        int height = src.getHeight();  
4.   
5.        if ( dst == null )  
6.            dst = createCompatibleDestImage( src, null );  
7.   
8.        int[] inPixels = new int[width*height];  
9.        getRGB( src, 0, 0, width, height, inPixels );  
10.          
11.        int index = 0;  
12.        int size = (int)(inPixels.length * (1-SNR));  
13.   
14.        for(int i=0; i<size; i++) {  
15.         int row = (int)(Math.random() * (double)height);  
16.         int col = (int)(Math.random() * (double)width);  
17.         index = row * width + col;  
18.         inPixels[index] = (255 << 24) | (255 << 16) | (255 << 8) | 255;  
19.        }  
20.   
21.        setRGB( dst, 0, 0, width, height, inPixels );  
22.        return dst;  
23. }  

高斯噪声的代码如下：

[java] view plaincopy

1. private BufferedImage gaussianNoise(BufferedImage src, BufferedImage dst) {  
2.         int width = src.getWidth();  
3.         int height = src.getHeight();  
4.   
5.         if ( dst == null )  
6.             dst = createCompatibleDestImage( src, null );  
7.   
8.         int[] inPixels = new int[width*height];  
9.         int[][][] tempPixels = new int[height][width][4];   
10.         int[] outPixels = new int[width*height];  
11.         getRGB( src, 0, 0, width, height, inPixels );  
12.         int index = 0;  
13.         float inMax = 0;  
14.         float outMax = 0;  
15.         for(int row=0; row<height; row++) {  
16.             int ta = 0, tr = 0, tg = 0, tb = 0;  
17.             for(int col=0; col<width; col++) {  
18.                 index = row * width + col;  
19.                 ta = (inPixels[index] >> 24) & 0xff;  
20.                 tr = (inPixels[index] >> 16) & 0xff;  
21.                 tg = (inPixels[index] >> 8) & 0xff;  
22.                 tb = inPixels[index] & 0xff;  
23.                 if(inMax < tr) {  
24.                     inMax = tr;  
25.                 }  
26.                 if(inMax < tg) {  
27.                     inMax = tg;  
28.                 }  
29.                 if(inMax < tb) {  
30.                     inMax = tb;  
31.                 }  
32.                 tr = (int)((float)tr + getGaussianValue() + this.means);  
33.                 tg = (int)((float)tg + getGaussianValue() + this.means);  
34.                 tb = (int)((float)tb + getGaussianValue() + this.means);  
35.                 if(outMax < tr) {  
36.                     outMax = tr;  
37.                 }  
38.                 if(outMax < tg) {  
39.                     outMax = tg;  
40.                 }  
41.                 if(outMax < tb) {  
42.                     outMax = tb;  
43.                 }  
44.                 tempPixels[row][col][0] = ta;  
45.                 tempPixels[row][col][1] = tr;  
46.                 tempPixels[row][col][2] = tg;  
47.                 tempPixels[row][col][3] = tb;  
48.             }  
49.         }  
50.   
51.         // Normalization  
52.         index = 0;  
53.         float rate = inMax/outMax;  
54.         for(int row=0; row<height; row++) {  
55.             int ta = 0, tr = 0, tg = 0, tb = 0;  
56.             for(int col=0; col<width; col++) {  
57.                 index = row * width + col;  
58.                 ta = tempPixels[row][col][0];  
59.                 tr = tempPixels[row][col][1];  
60.                 tg = tempPixels[row][col][2];  
61.                 tb = tempPixels[row][col][3];  
62.   
63.                 tr = (int)((float)tr * rate);  
64.                 tg = (int)((float)tg * rate);  
65.                 tb = (int)((float)tb * rate);  
66.                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
67.             }  
68.         }  
69.         setRGB( dst, 0, 0, width, height, outPixels );  
70.         return dst;  
71.     }