# 图像处理为什么要去噪

## 数字图像处理基础实验（四）：图像去噪

2019-04-25 19:40:03 lyd1995 阅读数 1613
• ###### matlab基于形态学的权重自适应图像去噪

matlab基于形态学的权重自适应图像去噪 </p>

3课时 16分钟 451人学习 刘昱显
免费试看

### 一、实验内容及原理

###### （1）算术均值滤波器

$\hat {f}(x,y)=\frac {1}{mn}\sum g(s,t)$

###### （2）几何均值滤波器

$\hat {f}(x,y)=[\prod g(s,t)]^{\frac {1}{mn}}$

###### （3）谐波均值滤波器

$\hat {f}(x,y)=\frac {mn}{\frac {1}{\sum g(s,t)}}$

###### （4）逆谐波均值滤波器

$\hat {f}(x,y)=\frac {\sum g(s,t)^{Q+1}}{\sum g(s,t)^Q}$

###### 3、自适应均值滤波。

$\hat {f}(x,y)=g(s,t)-\frac {\sigma_\eta^2}{\sigma_L^2}[g(s,t)-m_L]$

### 二、实验代码

（1）OpenCV3.4.3
（2）Ubuntu16.04
（3）VS Code
（4）C++

#include <iostream>
#include <opencv2/opencv.hpp>
#include <string>
#include <vector>
#include <math.h>
#include <cmath>
#include <algorithm>

class Exp4{
public:
// 1 初始化：彩色图片、灰度图片、加噪图片
Exp4(std::vector<std::string> path){
noise_name.push_back("高斯噪声");
noise_name.push_back("胡椒噪声");
noise_name.push_back("盐噪声");
noise_name.push_back("椒盐噪声");

filter_name.push_back("算术均值滤波");
filter_name.push_back("几何均值滤波");
filter_name.push_back("谐波均值滤波");
filter_name.push_back("逆谐波均值滤波");
filter_name.push_back("中值滤波");
filter_name.push_back("自适应均值滤波");
filter_name.push_back("自适应中值滤波");

pic_color.push_back("灰度");
pic_color.push_back("彩色");
for(int i = 0; i < path.size(); i++){
// 读取彩色图片、灰度图片
original_gray_image.push_back(color2Gray(original_color_image[i]));

// 彩色图片加噪

// 灰度图片加噪
}
}
// 1.1 彩色图像转灰度图像
cv::Mat color2Gray(cv::Mat src_image){
//创建与原图同类型和同大小的矩阵
cv::Mat gray_image(src_image.rows, src_image.cols, CV_8UC1);
if(src_image.channels()!=1){
for(int i = 0; i < src_image.rows; i++)
for(int j = 0; j < src_image.cols; j++)
gray_image.at<uchar>(i, j) = (src_image.at<cv::Vec3b>(i, j)[0] + src_image.at<cv::Vec3b>(i, j)[1] + src_image.at<cv::Vec3b>(i, j)[2]) / 3;
}
else
gray_image = src_image.clone();
return gray_image;
}
// 2 灰度图像滤波
void grayFiltering(int id, int select, int filter_size=5, double Q=1){
int size = filter_size;
if(select == 6 || select == 5)
size = 7;
int m = size/2;
int n=size*size;
cv::Mat image = cv::Mat::zeros(noise_gray_image[id].size(), noise_gray_image[id].type());

for(int i=m; i < noise_gray_image[id].rows - m; i++)
for(int j=m; j < noise_gray_image[id].cols - m; j++){
cv::Mat sub_matrix = noise_gray_image[id](cv::Rect(j - m, i - m, size, size));
if(select == 0)
image.at<uchar>(i,j) = arithmeticMeanValueConvolution(sub_matrix);
else if(select == 1)
image.at<uchar>(i,j) = geometryMeanValueConvolution(sub_matrix);
else if(select == 2)
image.at<uchar>(i,j) = harmonicMeanValueConvolution(sub_matrix);
else if(select == 3)
image.at<uchar>(i,j) = inverseHarmonicMeanValueConvolution(sub_matrix);
else if(select == 4)
image.at<uchar>(i,j) = middleValueConvolution(sub_matrix);
else if(select == 5)
else if(select == 6)
}
noise_gray_image_process.push_back(image);
}

// 2.1 算术均值
int arithmeticMeanValueConvolution(cv::Mat& image_block, int size=5){
cv::Mat c_template(size, size, CV_8UC1, 1);
int n=size*size;
return c_template.dot(image_block) / n + 0.5;
}

// 2.2 几何平均
int geometryMeanValueConvolution(cv::Mat& image_block, int size=5){
std::vector<double> product(5,1);
double n = 1.0 / double(size * size);
for(int k1 = 0; k1 < size; k1++){
double temp=1;
for(int k2 = 0; k2 < size; k2++){
temp = temp * ((image_block.at<uchar>(k1,k2) > 0) ? double(image_block.at<uchar>(k1,k2)) : 1.0);
product[k1] = pow(temp, n);
}
}
return int(product[0] * product[1] * product[2] * product[3] * product[4]);
}

// 2.3 谐波均值
int harmonicMeanValueConvolution(cv::Mat& image_block, int size=5){
std::vector<double> product(5,1);
double sum=0;
double n = double(size * size);
for(int k1 = 0; k1 < size; k1++){
for(int k2 = 0; k2 < size; k2++){
double temp;
if(image_block.at<uchar>(k1,k2))
temp = 1.0 / double(image_block.at<uchar>(k1,k2));
else
temp=0;
sum += temp;
}
}
return int(n / sum);
}

// 2.4 逆谐波均值
int inverseHarmonicMeanValueConvolution(cv::Mat& image_block, int size=5, double Q=1){
double sum1=0, sum2=0;
for(int k1 = 0; k1 < size; k1++){
for(int k2 = 0; k2 < size; k2++){
sum1 += pow(double(image_block.at<uchar>(k1, k2)), Q);
sum2 += pow(double(image_block.at<uchar>(k1, k2)), Q+1);
}
}
return int(sum2 / sum1);
}

// 3.1 中值滤波
int middleValueConvolution(cv::Mat& image_block, int size=5){
int min = 0, k = 0, pos = size*size/2;
std::vector<int> nums;
for(int k1 = 0; k1 < size; k1++)
for(int k2 = 0; k2 < size; k2++)
nums.push_back(image_block.at<uchar>(k1,k2));
int middle = findMiddleNum(nums, 0, size*size - 1, pos);
return middle;
}

// 3.2.1 快速查找中位数
int findMiddleNum(std::vector<int>& nums, int begin, int end, int n){
int i = partition(nums, begin, end);
if(i == n)
return nums[i];
else if(i > n)
return findMiddleNum(nums, begin, i-1, n);
else
return findMiddleNum(nums, i+1, end, n);
}

// 3.2.2 交换
void exchange(std::vector<int>& nums, int a,int b){
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
return;
}

// 3.2.2 快速查找中位数
int partition(std::vector<int>& nums, int begin, int end){
int i = begin, j = end + 1;
int x = nums[begin];
while (true) {
while (nums[++i] < x) {// 向右扫描
if (i == end)
break;
}
while (nums[--j] > x) {// 向左扫描
if (j == begin)
break;
}
if (i >= j) // 指针相遇，切分位置确定
break;
exchange(nums, i, j);// 交换左右逆序元素
}
// 运行到最后：i指向从左往右第一个大于x的元素，j指向从右往左第一个小于x的元素。
exchange(nums, begin, j);// 将切分元素放在切分位置
return j;
}

// 4、自适应均值滤波
int selfAdaptionMeanValueConvolution(cv::Mat& image_block, int value, int size=7, int sigma_n=3000){
int center = size/2;
int mean = computerMeanValue(image_block);
int sigma = computerVariance(image_block, mean);
//std::cout<<sigma<<"\n";
double rate = double(sigma_n)/double(sigma);
if(rate > 1.0)
rate = 1;
int ans = value - rate * (value - mean);
return ans;
}

// 4.1 计算图像块的平均值
int computerMeanValue(cv::Mat& image_block, int size=7){
int sum = 0,n = size*size;
for(int k1 = 0; k1 < size; k1++)
for(int k2 = 0; k2 < size; k2++)
sum += image_block.at<uchar>(k1,k2);
return (sum / n);
}

// 4.2 计算图像块的方差
int computerVariance(cv::Mat& image_block, int mean, int size=7){
int sum = 0,n = size*size;
for(int k1 = 0; k1 < size; k1++)
for(int k2 = 0; k2 < size; k2++)
sum += pow((image_block.at<uchar>(k1,k2) - mean), 2);
return (sum / n);
}

// 5、自适应中值滤波
int selfAdaptionMiddleValueConvolution(cv::Mat& image_, int size=3, int sizemax=7){
int center = sizemax/2;
int zxy = image_.at<uchar>(center, center);
int m = size/2;
cv::Mat image_block = image_(cv::Rect(center - m, center - m, size, size)).clone();
std::vector<int> nums;
for(int k1 = 0; k1 < size; k1++)
for(int k2 = 0; k2 < size; k2++)
nums.push_back(image_block.at<uchar>(k1,k2));

sort(nums.begin(), nums.end());
int zmin = nums[0], zmax = nums[nums.size()-1], zmid = nums[(size*size)/2];
int A1 = (zmid - zmin), A2 = (zmid - zmax);
if(A1 > 0 && A2 < 0){
int B1 = (zxy - zmin), B2 = (zxy - zmax);
if(B1 > 0 && B2 < 0)
return zxy;
else
return zmid;
}
else{
if(size < sizemax)
else
return zmid;
}
}

// 6、彩色图像滤波器
void colorFiltering(int id, int select, int filter_size=5, int Q=1){
int size = filter_size;
if(select == 6)
size = 7;
int m = size/2;
int n=size*size;
cv::Mat image = cv::Mat::zeros(noise_color_image[id].rows, noise_color_image[id].cols, noise_color_image[id].type());
std::vector<cv::Mat> channels;
cv::split(noise_color_image[id], channels);

for(int i=m; i < noise_color_image[id].rows - m; i++)
for(int j=m; j < noise_color_image[id].cols - m; j++)
for(int k=0;k < 3;k++){
cv::Mat sub_matrix = channels.at(k)(cv::Rect(j - m, i - m, size, size));
if(select == 0)
image.at<cv::Vec3b>(i,j)[k] = arithmeticMeanValueConvolution(sub_matrix, size);
else if(select == 1)
image.at<cv::Vec3b>(i,j)[k] = geometryMeanValueConvolution(sub_matrix, size);
else if(select == 2)
image.at<cv::Vec3b>(i,j)[k] = harmonicMeanValueConvolution(sub_matrix, size);
else if(select == 3)
image.at<cv::Vec3b>(i,j)[k] = inverseHarmonicMeanValueConvolution(sub_matrix, size, Q);
else if(select == 4)
image.at<cv::Vec3b>(i,j)[k] = middleValueConvolution(sub_matrix, size);
else if(select == 5)
else if(select == 6)
}
noise_color_image_process.push_back(image);
}

// 7、运行代码
void test_gray_filter(int num){
int id = num;
for(int i = 0; i < noise_name.size(); i++){
grayFiltering(i, id);
std::cout<< pic_color[0] << "-----" <<noise_name[i]<<"-----"<<filter_name[id]<<": 运行完毕!!!!  \n";
}

cv::imshow(filter_name[id] + "----准备就绪,可以开始!", original_color_image[0]);
cv::waitKey(0);

// 3 显示灰度滤波结果
for(int i = 0; i < noise_name.size(); i++){
cv::imshow(noise_name[i], noise_gray_image[i]);
cv::waitKey(0);
cv::imshow(noise_name[i] + "-----" + filter_name[id] + "-----" + pic_color[0], noise_gray_image_process[id * 4 + i]);
cv::waitKey(0);
}
std::cout<<"\n \n";
cv::destroyAllWindows();
}

void test_color_filter(int num){
int id = num;
for(int i = 0; i < noise_name.size(); i++){
colorFiltering(i, id);
std::cout<< pic_color[1] << "-----" <<noise_name[i]<<"-----"<<filter_name[id]<<": 运行完毕!!!!  \n";
}

cv::imshow(filter_name[id] + "----准备就绪,可以开始!", original_color_image[0]);
cv::waitKey(0);

// 3 显示灰度滤波结果
for(int i = 0; i < noise_name.size(); i++){
cv::imshow(noise_name[i], noise_color_image[i]);
cv::waitKey(0);
cv::imshow(noise_name[i] + "-----" + filter_name[id] + "-----" + pic_color[0], noise_color_image_process[id * 4 + i]);
cv::waitKey(0);
}
std::cout<<"\n \n";
cv::destroyAllWindows();
}
private:
std::vector<std::string> noise_name;
std::vector<std::string> filter_name;
std::vector<std::string> pic_color;

std::vector<cv::Mat> original_color_image;
std::vector<cv::Mat> original_gray_image;

std::vector<cv::Mat>  noise_color_image;
std::vector<cv::Mat>  noise_gray_image;

std::vector<cv::Mat>  noise_color_image_process;
std::vector<cv::Mat>  noise_gray_image_process;

/************************** 添加噪声***************************************/

cv::Mat addNoise(cv::Mat src_image, int select=0, int gray=1, double SNR=0.99, double mean=0.0, double sigma=10.0, int k=2){
cv::Mat outImage;
cv::Mat image;
if(gray){
image = color2Gray(src_image);
if(select==0)
outImage = addGaussNoise(image, mean, sigma, k);
else if(select==1)
outImage = addPepperSaltNoise(image, SNR, select - 1);
else if(select==2)
outImage = addPepperSaltNoise(image, SNR, select - 1);
else if(select==3)
outImage = addPepperSaltNoise(image, SNR, select - 1);
}
else{
std::vector<cv::Mat> channels, ch;
cv::Mat image = src_image.clone();
cv::split(src_image, channels);
cv::split(image, ch);
for(int k=0; k < 3; k++){
if(select==0)
ch.at(k) = addGaussNoise(channels.at(k), mean, sigma, k);
else if(select==1)
ch.at(k) = addPepperSaltNoise(channels.at(k), SNR, select - 1);
else if(select==2)
ch.at(k) = addPepperSaltNoise(channels.at(k), SNR, select - 1);
else if(select==3)
ch.at(k) = addPepperSaltNoise(channels.at(k), SNR, select - 1);
}
cv::merge(ch, outImage);
}
return outImage;
}

// 1、添加高斯噪声
cv::Mat addGaussNoise(cv::Mat src_image, double mean=0.0, double sigma=100.0, int k=2, int gray=1){
cv::Mat outImage;
cv::Mat image = src_image.clone();
//cv::Mat image = color2Gray(src_image);
outImage.create(image.rows,image.cols,image.type());
int PixcelMax = 255, PixcelMin = 0;
for(int x=0;x<image.rows;x++){
for(int y=0;y<image.cols;y++){
double temp = image.at<uchar>(x, y) + k * generateGaussianNoise(mean,sigma);
if(temp>PixcelMax)
temp=PixcelMax;
else if(temp<PixcelMin)
temp=PixcelMin;
outImage.at<uchar>(x, y) = temp;
}
}
return outImage;
}

// 1.1、生成高斯噪声（其实就是服从高斯分布的随机数）
double generateGaussianNoise(double mean, double sigma){
static double V1, V2, S;
static int phase = 0;
double X;
double U1,U2;
if ( phase == 0 ) {
do {
U1 = (double)rand() / RAND_MAX;
U2 = (double)rand() / RAND_MAX;

V1 = 2 * U1 - 1;
V2 = 2 * U2 - 1;
S = V1 * V1 + V2 * V2;
} while(S >= 1 || S == 0);

X = V1 * sqrt(-2 * log(S) / S);
}
else{
X = V2 * sqrt(-2 * log(S) / S);
}
phase = 1 - phase;
return mean + sigma * X;
}

// 2、添加椒盐噪声(根据图像的信噪比，添加椒盐噪声)根据选择，可以添加：盐噪声（又称白噪声，白色点255）、胡椒噪声（黑色点）、椒盐噪声。
cv::Mat addPepperSaltNoise(cv::Mat src_image, double SNR=0.9, int select=0, int gray=1){
cv::Mat outImage;
cv::Mat image = src_image.clone();
//outImage.create(image.rows,image.cols,image.type());
int SP = image.rows * image.cols;
int NP = SP*(1-SNR);
outImage = image.clone();
// 噪声点的总个数 与 信噪比有关
for(int i=0; i<NP; i++) {
// 随机选取图像上的点
int x = (int)(double(rand())*1.0/RAND_MAX* (double)image.rows);
int y = (int)(double(rand())*1.0/RAND_MAX* (double)image.cols);
// 峰值（255）和零值（0）出现的概率相同
if(select==0)
outImage.at<uchar>(x,y) = 0;
else if(select==1)
outImage.at<uchar>(x,y) = 255;
else{
int r = rand()%2;
outImage.at<uchar>(x,y) = (r > 0) ? 255 : 0;
}
}
return outImage;
}
};

int main(){
std::vector<std::string> path;
path.push_back("/home/lyd/image_process/pic/lena.jpg");
Exp4 a(path);
//a.run();
for(int i=0; i < 7; i++)
a.test_gray_filter(i);
for(int i=0; i < 7; i++)
a.test_color_filter(i);
return 1;
}


1、 均值滤波

2、 中值滤波

3、 自适应均值滤波

4、 自适应中值滤波

5、 彩色图像均值滤波

## python数字图像处理-图像噪声与去噪算法

2017-12-16 17:36:21 u012123989 阅读数 19860
• ###### matlab基于形态学的权重自适应图像去噪

matlab基于形态学的权重自适应图像去噪 </p>

3课时 16分钟 451人学习 刘昱显
免费试看

# python数字图像处理-图像噪声与去噪算法

## 图像噪声

### 椒盐噪声

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

## 数字图像处理冈萨雷斯-图像去噪之频率域去噪

2020-02-17 14:40:30 ab136681 阅读数 192
• ###### matlab基于形态学的权重自适应图像去噪

matlab基于形态学的权重自适应图像去噪 </p>

3课时 16分钟 451人学习 刘昱显
免费试看

# 频率域去噪

1. 代码过于简单，像书上这样的例子这样的
2. 自己并没有这类周期噪声的例子，也不想去手动去添加，因为这样的还原效果太好。像自欺欺人

f 为还原图
g 为待处理图
w 为系数
n 为噪声模式

## 图像处理——去噪

2019-03-03 15:42:00 weixin_34301307 阅读数 322
• ###### matlab基于形态学的权重自适应图像去噪

matlab基于形态学的权重自适应图像去噪 </p>

3课时 16分钟 451人学习 刘昱显
免费试看

f(x,y)表示给定原始图象,g(x,y)表示图象信号,n(x,y)表示噪声。

（1）加性噪声,此类噪声与输入图象信号无关,含噪图象可表示为f(x,y)=g(x,y)+n(x,y),信道噪声及光导摄像管的摄像机扫描图象时产生的噪声就属这类噪声；典型的加性噪声有高斯噪声，

（2）乘性噪声,此类噪声与图象信号有关,含噪图象可表示为f(x,y)=g(x,y)+n(x,y)g(x,y),飞点扫描器扫描图象时的噪声,电视图象中的相关噪声,胶片中的颗粒噪声就属于此类噪声；

（3）量化噪声,此类噪声与输入图象信号无关,是量化过程存在量化误差,再反映到接收端而产生。

（1）高斯噪声：指噪声服从高斯分布，即某个强度的噪声点个数最多，离这个强度越远噪声点个数越少，且这个规律服从高斯分布。高斯噪声是一种加性噪声，即噪声直接加到原图像上，因此可以用线性滤波器滤除。

（2）椒盐噪声（脉冲噪声）：类似把椒盐撒在图像上，因此得名，是一种在图像上出现很多白点或黑点的噪声，如电视里的雪花噪声等。椒盐噪声可以认为是一种逻辑噪声，用线性滤波器滤除的结果不好，一般采用中值滤波器滤波可以得到较好的结果。

（3）均匀噪声：是指功率谱密度（信号功率在频域的分布状况）在整个频域内是常数的噪声。 所有频率具有相同能量密度的随机噪声称为白噪声。

（4）瑞利噪声：噪声分布为瑞利分布。

（5）指数噪声：噪声分布为指数分布。

（6）伽马噪声：噪声分布为瑞利分布。

（以下是对图像加入高斯，椒盐等噪声的python代码）

 1 # -*- coding: utf-8 -*-
2 """
3 Created on Sat Mar  2 14:00:30 2019
4
6 """
7
8 '''
9 图像添加噪声，去除噪声
10 '''
11 import matplotlib.pyplot as plt
12 import numpy as np
13 from skimage.util import random_noise
14 from PIL import Image
15
17
18 fig = plt.figure(figsize = (8.0,6.0))
20 ##  show the original picture
21 ax1.imshow(img)
22 plt.title('original_picture')
23
24 ##　gray_picture
25 gravity= np.array([0.299,0.587,0.114])
26 #red*0.299+green*0.587+blue*0.114
27 img_gravity=np.dot(img,gravity)
29 ##  show the gray_picture
30 ax2.imshow(img_gravity,cmap='gray')
31 plt.title('gray_picture')
32
33
34 img_gaussian =  random_noise(img, mode='gaussian', seed=100, clip=True)
36 ax3.imshow(img_gaussian)
38
39
40 img_salt =  random_noise(img, mode='salt', seed=100, clip=True)
42 ax4.imshow(img_salt)
44
45
46 img_pepper =  random_noise(img, mode='pepper', seed=100, clip=True)
48 ax4.imshow(img_pepper)
50
51
52 img_sp =  random_noise(img, mode='s&p', seed=100, clip=True)
54 ax4.imshow(img_sp)
55 plt.title('add_sp')
View Code

中值滤波法是一种非线性平滑技术，它将每一像素点的灰度值设置为该点某邻域窗口内的所有像素点灰度值的中值。

高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。

均值滤波也称为线性滤波，其采用的主要方法为邻域平均法。线性滤波的基本原理是用均值代替原图像中的各个像素值，即对待处理的当前像素点（x，y），选择一个模板，该模板由其近邻的若干像素组成，求模板中所有像素的均值，再把该均值赋予当前像素点（x，y），作为处理后图像在该点上的灰度g（x，y），即g（x，y）=1/m ∑f（x，y） m为该模板中包含当前像素在内的像素总个数。

维纳滤波（wiener filtering) 一种基于最小均方误差准则、对平稳过程的最优估计器。这种滤波器的输出与期望输出之间的均方误差为最小，因此，它是一个最佳滤波系统。它可用于提取被平稳噪声所污染的信号。

（以下是几种滤波方法（不一定全）在python代码中的应用）

 1 # -*- coding: utf-8 -*-
2 """
3 Created on Sat Mar  2 21:17:58 2019
4
6 """
7
8 '''
9 图像去除噪声
10 '''
11 import matplotlib.pyplot as plt
12 import numpy as np
13 from skimage.util import random_noise
14 from PIL import Image
15 import cv2
16
18 fig = plt.figure(figsize=(8.0,6.0))
20 ax1.imshow(img)
21 plt.title('blur_picture')
22
23 ###  中值滤波
24 median_filter_img = cv2.medianBlur(img, 3)
26 ax2.imshow(median_filter_img)
27 plt.title('median_filter')
28
29 #### 高斯滤波
30 Gaussian_filter_img = cv2.GaussianBlur(img, (3,3), 0)
32 ax2.imshow(Gaussian_filter_img)
33 plt.title('Gaussian_filter')
34
35 ####　均值滤波
36 mean_vaule_filter = cv2.blur(img, (5,5))
38 ax2.imshow(mean_vaule_filter)
39 plt.title('mean_vaule_filter')
40
41 #### 双边滤波
42 #9 邻域直径，两个 75 分别是空间高斯函数标准差，灰度值相似性高斯函数标准差
43 blur = cv2.bilateralFilter(img,9,75,75)
45 ax2.imshow(blur)
46 plt.title('bilatral-filter')
View Code

posted on 2019-03-03 15:42 E-Dreamer 阅读(...) 评论(...) 编辑 收藏

## 图像处理实例--图像去噪

2017-08-24 16:12:58 second24 阅读数 18474
• ###### matlab基于形态学的权重自适应图像去噪

matlab基于形态学的权重自适应图像去噪 </p>

3课时 16分钟 451人学习 刘昱显
免费试看

# 常见的噪声种类

f=imread('3.jpg');
g=imnoise(f,'salt & pepper',0.06);
h=imnoise(f,'gaussian',0.05,0.05);
subplot(1, 3, 1), imshow(f), title('原图');
subplot(1, 3, 2), imshow(g), title('椒盐');
subplot(1, 3, 3), imshow(h), title('高斯');

# 去噪方法

## 空域

g1 = imfilter(g, fspecial('average'));
g2 = medfilt2(g, [5 5]);
subplot(2, 2, 3), imshow(g1), title('均值滤波');
subplot(2, 2, 4), imshow(g2), title('中值滤波');

1、图像信息的保持

2、图像边缘的提取

3、图像骨架的提取

4、图像处理的效率

## 权重自适应的多结构形态学去噪

>> i=imread('food.jpg');
>> i=rgb2gray(i);
>> %添加噪声
>> ig=imnoise(i,'poisson');
>> %获取算子
>> s=GetStrelList();
>> %串联去噪
>> edit erodeList
>> e=erodeList(ig,s);
>> edit getRateList
>> %计算权重
>> f=getRateList(ig,e);
>> edit getRemoveResult
>> %并联
>> igo=getRemoveResult(f,e);
>> %显示结果
>> subplot(1,2,1),imshow(f);
>> subplot(1,2,1),imshow(i);
>> title('原图像');
>> subplot(1,2,2),imshow(ig),title('噪声图像');
>> figure;
>> subplot(2,2,1),imshow(e.eroded_co12);title('串联1处理结果');
>> subplot(2,2,2),imshow(e.eroded_co22);title('串联2处理结果');
>> subplot(2,2,3),imshow(e.eroded_co32);title('串联3处理结果');
>> subplot(2,2,4),imshow(e.eroded_co42);title('串联4处理结果');
>> figure;
>> subplot(1,2,1),imshow(ig),title('噪声图像');
>> subplot(1,2,2),imshow(igo),title('并联去噪图像');