# 图像处理加噪

## 数字图像处理：图像加噪与复原

2019-11-19 12:52:55 qq_29598161 阅读数 209
• ###### 本课程教学安排及特色介绍

通过本课程学习，初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目，有较高的实用性。

205人学习 刘山
免费试看

## 待处理图像：

``````def add_gaussian_noise(image_in, noise_sigma=25):
temp_image = np.float64(np.copy(image_in))

h = temp_image.shape[0]
w = temp_image.shape[1]
noise = np.random.randn(h, w) * noise_sigma

noisy_image = np.zeros(temp_image.shape, np.float64)
if len(temp_image.shape) == 2:
noisy_image = temp_image + noise
else:
noisy_image[:, :, 0] = temp_image[:, :, 0] + noise
noisy_image[:, :, 1] = temp_image[:, :, 1] + noise
noisy_image[:, :, 2] = temp_image[:, :, 2] + noise
"""
print('min,max = ', np.min(noisy_image), np.max(noisy_image))
print('type = ', type(noisy_image[0][0][0]))
"""
return noisy_image

def sp_noisy(image, s_vs_p=0.5, amount=0.08):
out = np.copy(image)
num_salt = np.ceil(amount * image.size * s_vs_p)
coords = [np.random.randint(0, i - 1, int(num_salt)) for i in image.shape]
out[tuple(coords)] = 255
num_pepper = np.ceil(amount * image.size * (1. - s_vs_p))
coords = [np.random.randint(0, i - 1, int(num_pepper)) for i in image.shape]
out[tuple(coords)] = 0
return out
``````

### 滤波函数

``````def filter(image, op):
new_image = np.zeros(image.shape)
image = cv2.copyMakeBorder(image, 1, 1, 1, 1, cv2.BORDER_DEFAULT)
for i in range(1, image.shape[0] - 1):
for j in range(1, image.shape[1] - 1):
new_image[i - 1, j - 1] = op(image[i - 1:i + 2, j - 1:j + 2])
new_image = (new_image - np.min(image)) * (255 / np.max(image))
return new_image.astype(np.uint8)
``````

### 几何均值滤波器

``````k1 = np.array([
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]
], np.float32)/9
``````

### 算术均值滤波器

``````def GeometricMeanOperator(roi):
roi = roi.astype(np.float64)
p = np.prod(roi)
re = p ** (1 / (roi.shape[0] * roi.shape[1]))
if re < 0:
re = 0
if re > 255:
re = 255
return re
``````

### 谐波均值滤波器

``````def HMeanOperator(roi):
roi = roi.astype(np.float64)
re = roi.shape[0] * roi.shape[1] / np.sum([1/(p+0.0001) for p in roi])
if re < 0:
re = 0
if re > 255:
re = 255
return re
``````

### 逆谐波均值滤波器

``````def IHMeanOperator(roi, q):
roi = roi.astype(np.float64)
return np.mean(roi ** (q + 1)) / np.mean(roi ** q)

def IHMeanAlogrithm(image, q):
new_image = np.zeros(image.shape)
image = cv2.copyMakeBorder(image, 1, 1, 1, 1, cv2.BORDER_DEFAULT)
for i in range(1, image.shape[0] - 1):
for j in range(1, image.shape[1] - 1):
new_image[i - 1, j - 1] = IHMeanOperator(image[i - 1:i + 2, j - 1:j + 2], q)
new_image = (new_image - np.min(image)) * (255 / np.max(image))
return new_image.astype(np.uint8)

``````

q>0时消除胡椒噪声：

q<0时消除盐噪声：

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

2015-07-24 09:26:49 mao0514 阅读数 2666
• ###### 本课程教学安排及特色介绍

通过本课程学习，初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目，有较高的实用性。

205人学习 刘山
免费试看

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

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）

Pout = Pin + XMeans + sigma *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.     高斯噪声

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;

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

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

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

mean是的值为0.

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, 00, 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, 00, width, height, inPixels );
22.        return dst;
23. }

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, 00, 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, 00, width, height, outPixels );
70.         return dst;
71.     }

## 图像的加噪与去噪（python）

2020-04-03 12:15:27 XITMan 阅读数 408
• ###### 本课程教学安排及特色介绍

通过本课程学习，初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目，有较高的实用性。

205人学习 刘山
免费试看

``````#import os              #import语句的作用是用来导入模块，可以出现在程序任何位置
import cv2 as cv        #导入openCV库
import skimage          #导入skimage模块.scikit-image是一个图像处理算法的集合。它是基于scipy的一款图像处理包，它将图片作为numpy数组进行处理，方便进行后续运算。
#必须首先安装numpy,scipy,matplotlib
import numpy as np      #导入numpy模块。numpy是python扩展程序库，支持数组和矩阵运算，针对数组运算提供大量数学函数库。

def boxBlur(img):
# 使用5x5的滤波核进行平滑
blur = cv.boxFilter(img,-1,(5, 5))
return blur

def gaussianBlur(img):
#     使用高斯核进行平滑
blur = cv.GaussianBlur(img,(5, 5),1.5)
return blur

def main():
# 2. 定义图片类img
path = r"C:\Users\98238\Desktop\Lenna.jpg"
start_t = cv.getTickCount()
# 5. 加噪声，绘图
##############################################3

gauss_noiseImg = skimage.util.random_noise(img, mode='gaussian')# 添加10%的高斯噪声
gauss_noiseImg=gauss_noiseImg
salt_noiseImg = skimage.util.random_noise(img, mode='salt')  # 添加椒盐噪声

lb_gauss=cv.medianBlur(gauss_noiseImg.astype('float32'), 1)#中值滤波

lb_salt=cv.medianBlur(salt_noiseImg.astype('float32'), 1)#中值滤波
print(gauss_noiseImg.dtype, "gaussian noisy image dtype")#输出一个注释
print(gauss_noiseImg.shape, "gaussian noisy image shape")#输出一个注释

print(salt_noiseImg.dtype, "salt noisy image dtype")#输出一个注释
print(salt_noiseImg.shape, "salt noisy image shape")#输出一个注释

cv.namedWindow("Original Image", cv.WINDOW_NORMAL)#输出原图片的标题
cv.imshow('Original Image', img)#输出原图片

# Gaussian noisy image

# Salt noisy image

#滤波后的图像
cv.namedWindow("lbguass Image", cv.WINDOW_NORMAL)#输出滤波后高斯噪声图片标题
cv.imshow('lbguass Image', lb_gauss)#输出滤波后高斯噪声图片
cv.namedWindow("lbsalt Image", cv.WINDOW_NORMAL)#输出滤波后椒盐噪声图片标题
cv.imshow('lbsalt Image', lb_salt)#输出滤波后椒盐噪声图片

#####################################################

stop_t = ((cv.getTickCount() - start_t) / cv.getTickFrequency()) * 1000#运行时间

print(stop_t, "ms")#输出时间并加上单位

cv.waitKey(0)
cv.destroyAllWindows()

if __name__ == "__main__":
main()
``````

## 图像处理基本操作和添加噪音（Matlab）

2018-07-06 18:31:04 JonyHwang 阅读数 14754
• ###### 本课程教学安排及特色介绍

通过本课程学习，初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目，有较高的实用性。

205人学习 刘山
免费试看

>>imshow( f )

>>figure,imshow( g )

>>imwrite( f, 'filename')

g=imnoise( f , type , parameters )

g=imnoise( f , 'gaussian' , m , var )将均值为m、方差为var的高斯噪声加到图像f上。默认值为均值是0、方差是0.01的噪声。

g=imnoise( f , 'localvar' , V )将均值为0、局部方差为V的高斯噪声加到图像f上。其中V是与f大小相同的一个数组，它包含了每个点的理想方差值。【这个函数和下面这个函数我暂时没实现，需要找下问题，请大牛指点】

g=imnoise( f , 'localvar' , image_intensity , var )将均值为0的高斯噪声添加到图像f上，其中噪声的局部方差var是图像f的亮度值的函数。参量image_intensity和var是大小相同的向量，plot（image_intensity , var）绘制出噪声方差和图像亮度的函数关系。向量image_intensity必须包含范围在【0,1】内的归一化亮度值。

g=imnoise( f , 'salt & pepper' , d )用椒盐噪声污染图像f，其中d是噪声密度（即包含噪声值的图像区域的百分比）。因此，大约有d*numel（f）个像素收到了影响。默认噪声密度为0.05。

g=imnoise( f , 'poisson' )从数据中生成泊松噪声。

## 图像处理之图像加噪

2012-01-06 15:53:38 jia20003 阅读数 27145
• ###### 本课程教学安排及特色介绍

通过本课程学习，初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目，有较高的实用性。

205人学习 刘山
免费试看

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

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）

Pout = Pin + XMeans + sigma *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.     高斯噪声

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;

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

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

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

mean是的值为0.

```	private BufferedImage addSaltAndPepperNoise(BufferedImage src, BufferedImage dst) {
int width = src.getWidth();
int height = src.getHeight();

if ( dst == null )
dst = createCompatibleDestImage( src, null );

int[] inPixels = new int[width*height];
getRGB( src, 0, 0, width, height, inPixels );

int index = 0;
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;
}

setRGB( dst, 0, 0, width, height, inPixels );
return dst;
}
```

```private BufferedImage gaussianNoise(BufferedImage src, BufferedImage dst) {
int width = src.getWidth();
int height = src.getHeight();

if ( dst == null )
dst = createCompatibleDestImage( src, null );

int[] inPixels = new int[width*height];
int[][][] tempPixels = new int[height][width][4];
int[] outPixels = new int[width*height];
getRGB( src, 0, 0, width, height, inPixels );
int index = 0;
float inMax = 0;
float outMax = 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;
if(inMax < tr) {
inMax = tr;
}
if(inMax < tg) {
inMax = tg;
}
if(inMax < tb) {
inMax = tb;
}
tr = (int)((float)tr + getGaussianValue() + this.means);
tg = (int)((float)tg + getGaussianValue() + this.means);
tb = (int)((float)tb + getGaussianValue() + this.means);
if(outMax < tr) {
outMax = tr;
}
if(outMax < tg) {
outMax = tg;
}
if(outMax < tb) {
outMax = tb;
}
tempPixels[row][col][0] = ta;
tempPixels[row][col][1] = tr;
tempPixels[row][col][2] = tg;
tempPixels[row][col][3] = tb;
}
}

// Normalization
index = 0;
float rate = inMax/outMax;
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 = tempPixels[row][col][0];
tr = tempPixels[row][col][1];
tg = tempPixels[row][col][2];
tb = tempPixels[row][col][3];

tr = (int)((float)tr * rate);
tg = (int)((float)tg * rate);
tb = (int)((float)tb * rate);
outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;
}
}
setRGB( dst, 0, 0, width, height, outPixels );
return dst;
}```