图像复原——维纳滤波

最新推荐文章于 2022-10-22 20:43:52 发布
最新推荐文章于 2022-10-22 20:43:52 发布
阅读量1.2k 收藏 11
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t_t_t_t_/article/details/119039456
版权
本文详细介绍了如何在MATLAB和C++中实现维纳滤波图像复原过程，涉及函数分解、频域操作和复原步骤。通过ImaRestoration函数演示了从读取图像、PSF处理到最终结果的展示，为读者提供了跨平台的图像处理代码示例。
摘要由CSDN通过智能技术生成

Matlab

main函数

clc
clear

Ii=imread('Ii','bmp');
psf=imread('psf','bmp');

recovery=ima_restoration(Ii,psf,0.1);
figure;imagesc(recovery);axis square;

ima_restoration函数

function [ recovery ] = ima_restoration(Ii,psf,a)

H=newfft2(psf);
H=H./max(max(H));
Gi=newfft2(Ii);
recovery=newifft2(Gi./(H+a));
recovery=abs(recovery);
end

newfft2(f)函数

function u=newfft2(f)
f=fftshift(f);
u=fft2(f);
u=fftshift(u);

newifft2(f)函数

function u=newifft2(f)
f=ifftshift(f);
u=ifft2(f);
u=ifftshift(u);

Ii.bmp
psf.bmp

1. 合并MATLAB程序

clc
clear

Ii=imread('Ii','bmp');
psf=imread('psf','bmp');
ps=fftshift(psf);
M=fft2(ps);
H=fftshift(M);
S1=max(H);
S = max(S1);
Hh=H ./ S;
pf=fftshift(Ii);
Mm=fft2(pf);
Gi=fftshift(Mm);
a=0.1;
Hhh=Hh+a;
GG=Gi./Hhh;
ff=ifftshift(GG);
uu=ifft2(ff);
imshow(uu);
recoveryy=ifftshift(uu);
recovery=abs(recoveryy);
figure;
imagesc(recovery);
axis square;

2. C++实现功能

1.main.cpp

#include"ImaRestoration.h"

int main(int argc, char* argv[])
{
	Mat Ii = imread("Ii.bmp", 0);
	Mat psf = imread("psf.bmp", 0);
	double a = 0.1;
	cv::Mat color = ImaRestoration(Ii, psf, a);
	imshow("color", color);
	waitKey(0);
	return 0;
}

2.ImaRestoration.h

ImaRestoration函数三个参数，返回一个参数
color = ImaRestoration(Ii, psf, a);

function [ recovery ] = ima_restoration(Ii,psf,a)

H=newfft2(psf);
H=H./max(max(H));
Gi=newfft2(Ii);
recovery=newifft2(Gi./(H+a));
recovery=abs(recovery);
end

ImaRestoration函数分解成：

ps=fftshift(psf);
M=fft2(ps);
H=fftshift(M);
S1=max(H);
S = max(S1);
Hh=H ./ S;
pf=fftshift(Ii);
Mm=fft2(pf);
Gi=fftshift(Mm);
a=0.1;
Hhh=Hh+a;
GG=Gi./Hhh;
ff=ifftshift(GG);
uu=ifft2(ff);
imshow(uu);
recoveryy=ifftshift(uu);
recovery=abs(recoveryy);
figure;
imagesc(recovery);
axis square;

matlab程序中ima_restoration 主要是先对psf.bmp进行newfft2变换得到H，找到H中像素值最大的值进行归一化处理得到H，之后对Ii.bmp进行newfft2变换得到Gi，然后，对Gi点除(H+a)后的结果进行newifft2处理，最后得到变换后的幅值图像输出。

使用opencv来实现：

//ImaRestoration函数
Mat ImaRestoration(cv::Mat Ii, cv::Mat psf, double a = 0.1)
{	
	Mat ps = fftshift(psf);
	Mat M = fft2(ps);
	Mat H = fftshift(M);
	//获取最大值像素
	double minValue = -1;
	double maxValue = -1;
	cv::Vec2d comp;
	cv::Vec2d* HPtr = H.ptr<cv::Vec2d>(0);
	for (int i = 0; i < H.size().area(); i++)
	{
		double val = sqrtf(HPtr[i][0] * HPtr[i][0] + HPtr[i][1] * HPtr[i][1]);
		if (val > maxValue)
		{
			maxValue = val;
			comp = HPtr[i];
		}
	}
	Mat Hh = H.clone();
	int rowNumber = Hh.rows;
	int colNumber = Hh.cols;
	for (int i = 0; i < rowNumber; i++)
	{
		cv::Vec2d*data = Hh.ptr<cv::Vec2d>(i);
		for (int j = 0; j < colNumber; j++)
		{
			double a = data[j][0];
			double b = data[j][1];
			double c = comp[0];
			double d = comp[1];
			data[j][0] = (a*c + b * d) / (c*c + d * d);
			data[j][1] = (b*c - a * d) / (c*c + d * d);
		}
	}
	Mat pf = fftshift(Ii);
	Mat Mm = fft2(pf);
	Mat Gi = fftshift(Mm);
	Mat Hhh = Hh + a;
	Mat GG(Gi.size(), Gi.type());
	for (int i = 0; i < rowNumber; i++)
	{
		cv::Vec2d*data = Hhh.ptr<cv::Vec2d>(i);
		cv::Vec2d*dataG = Gi.ptr<cv::Vec2d>(i);
		cv::Vec2d*dataGG = GG.ptr<cv::Vec2d>(i);
		for (int j = 0; j < colNumber; j++)
		{
			double a = dataG[j][0];
			double b = dataG[j][1];
			double c = data[j][0];
			double d = data[j][1];
			dataGG[j][0] = (a*c + b * d) / (c*c + d * d);
			dataGG[j][1] = (b*c - a * d) / (c*c + d * d);
		}
	}

	Mat ff = ifftshift(GG);
	Mat uu = ifft2(ff);
	Mat recovery = ifftshift(uu);
	double* imptr = recovery.ptr<double>(0);
	int pixSZ = recovery.size().area();
	double maxV = std::numeric_limits<double>::min();
	double minV = std::numeric_limits<double>::max();
	int normMin = 0;
	int normMax = 63;
	for (int p = 0; p < pixSZ; p++)
	{
		if (imptr[p] > maxV) maxV = imptr[p];
		if (imptr[p] < minV) minV = imptr[p];
	}

	double k = (double)(normMax - normMin) / (maxV - minV);
	double b = normMin - k * minV;
	cv::Mat3b color(recovery.size());
	cv::Vec3b* cPtr = color.ptr<cv::Vec3b>(0);
	for (int p = 0; p < pixSZ; p++)
	{
		int index = (int)(k* (imptr[p]) + b);
		cPtr[p][0] = lutArr[index * 3];
		cPtr[p][1] = lutArr[index * 3 + 1];
		cPtr[p][2] = lutArr[index * 3 + 2];
	}
	return color;
}

循环位移函数circshift

Mat circshift(Mat out, const Point delta)
{
	Size sz = out.size();
	assert(sz.height > 0 && sz.width > 0);

	if ((sz.height == 1 && sz.width == 1) || (delta.x == 0 && delta.y == 0))
		return Mat();

	int x = delta.x;
	int y = delta.y;
	if (x > 0) x = x % sz.width;
	if (y > 0) y = y % sz.height;
	if (x < 0) x = x % sz.width + sz.width;
	if (y < 0) y = y % sz.height + sz.height;

	vector<Mat> planes;
	split(out, planes);

	for (size_t i = 0; i < planes.size(); i++)
	{
		// 竖直方向移动
		Mat tmp0, tmp1, tmp2, tmp3;
		Mat q0(planes[i], Rect(0, 0, sz.width, sz.height - y));
		Mat q1(planes[i], Rect(0, sz.height - y, sz.width, y));
		q0.copyTo(tmp0);
		q1.copyTo(tmp1);
		tmp0.copyTo(planes[i](Rect(0, y, sz.width, sz.height - y)));
		tmp1.copyTo(planes[i](Rect(0, 0, sz.width, y)));

		// 水平方向移动
		Mat q2(planes[i], Rect(0, 0, sz.width - x, sz.height));
		Mat q3(planes[i], Rect(sz.width - x, 0, x, sz.height));
		q2.copyTo(tmp2);
		q3.copyTo(tmp3);
		tmp2.copyTo(planes[i](Rect(x, 0, sz.width - x, sz.height)));
		tmp3.copyTo(planes[i](Rect(0, 0, x, sz.height)));
	}

	merge(planes, out);
	return out;
}

fftshift函数

Mat fftshift(Mat Src)
{
	Size sz = Src.size();
	Point pt(0, 0);
	pt.x = (int)floor(sz.width / 2.0);
	pt.y = (int)floor(sz.height / 2.0);
	Mat out = circshift(Src, pt);
	return out;
}

fft2函数

Mat fft2(const Mat src)
{
	int mat_type = src.type();
	Mat Fourier;

	assert(mat_type < 15); //不支持的数据格式

	if (mat_type < 7)
	{
		Mat planes[] = { Mat_<double>(src), Mat::zeros(src.size(), CV_64F) };
		merge(planes, 2, Fourier);
		dft(Fourier, Fourier);
	}
	else // 7<mat_type<15
	{
		Mat tmp;
		dft(src, tmp);
		vector<Mat> planes;
		split(tmp, planes);
		magnitude(planes[0], planes[1], planes[0]); //将复数转化为幅值
		Fourier = planes[0];
	}
	return Fourier;
}

ifft2函数

Mat ifft2(const Mat src)
{
	Mat Fourier;
	int mat_type = src.type();
	assert(mat_type < 15); //不支持的数据格式
	if (mat_type < 7)
	{
		Mat planes[] = { Mat_<double>(src), Mat::zeros(src.size(), CV_64F) };
		merge(planes, 2, Fourier);
		dft(Fourier, Fourier, DFT_INVERSE + DFT_SCALE, 0);
	}
	else // 7<mat_type<15
	{
		Mat tem;
		dft(src, tem, DFT_INVERSE + DFT_SCALE, 0);
		vector<Mat> planes;
		split(tem, planes);
		magnitude(planes[0], planes[1], planes[0]); //将复数转化为幅值
		Fourier = planes[0];
	}
	return Fourier;
}

ifftshift函数

Mat ifftshift(Mat Scr)
{
	Size sz = Scr.size();
	Point pt(0, 0);
	pt.x = (int)ceil(sz.width / 2.0);
	pt.y = (int)ceil(sz.height / 2.0);
	Mat out = circshift(Scr, pt);
	return out;
}

完整的ImaRestoration程序：ImaRestoration.h

#ifndef IMA_RESTORATION_H
#define IMA_RESTORATION_H
#include<opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv2/imgproc/imgproc.hpp>
#include <math.h>
#include <stdio.h>
using namespace cv;
using namespace std;


int lutArr[192] = {
	135, 42, 53,
	147, 48, 54,
	160, 55, 54,
	173, 61, 53,
	186, 67, 50,
	199, 74, 44,
	212, 83, 32,
	221, 92, 15,
	225, 99, 3,
	225, 104, 2,
	224, 109, 4,
	222, 113, 8,
	220, 117, 13,
	218, 121, 16,
	216, 125, 18,
	214, 129, 20,
	212, 133, 20,
	211, 137, 19,
	210, 142, 16,
	210, 147, 12,
	209, 152, 9,
	207, 156, 7,
	205, 160, 6,
	202, 164, 6,
	198, 167, 6,
	194, 169, 7,
	190, 172, 10,
	185, 174, 15,
	180, 177, 21,
	175, 179, 29,
	169, 181, 37,
	164, 183, 46,
	158, 185, 56,
	152, 187, 66,
	146, 188, 77,
	140, 189, 89,
	134, 190, 101,
	128, 191, 113,
	123, 191, 124,
	119, 191, 135,
	115, 191, 146,
	111, 191, 156,
	107, 190, 165,
	103, 190, 174,
	100, 189, 183,
	96, 188, 192,
	93, 188, 200,
	89, 187, 209,
	86, 186, 217,
	82, 185, 225,
	78, 185, 233,
	74, 185, 241,
	68, 187, 248,
	61, 190, 253,
	55, 195, 255,
	50, 200, 254,
	46, 206, 252,
	42, 211, 250,
	38, 216, 247,
	33, 222, 245,
	29, 228, 245,
	24, 235, 245,
	19, 243, 246,
	14, 251, 249
};


Mat circshift(Mat out, const Point delta)
{
	Size sz = out.size();
	assert(sz.height > 0 && sz.width > 0);

	if ((sz.height == 1 && sz.width == 1) || (delta.x == 0 && delta.y == 0))
		return Mat();

	int x = delta.x;
	int y = delta.y;
	if (x > 0) x = x % sz.width;
	if (y > 0) y = y % sz.height;
	if (x < 0) x = x % sz.width + sz.width;
	if (y < 0) y = y % sz.height + sz.height;

	vector<Mat> planes;
	split(out, planes);

	for (size_t i = 0; i < planes.size(); i++)
	{
		// 竖直方向移动
		Mat tmp0, tmp1, tmp2, tmp3;
		Mat q0(planes[i], Rect(0, 0, sz.width, sz.height - y));
		Mat q1(planes[i], Rect(0, sz.height - y, sz.width, y));
		q0.copyTo(tmp0);
		q1.copyTo(tmp1);
		tmp0.copyTo(planes[i](Rect(0, y, sz.width, sz.height - y)));
		tmp1.copyTo(planes[i](Rect(0, 0, sz.width, y)));

		// 水平方向移动
		Mat q2(planes[i], Rect(0, 0, sz.width - x, sz.height));
		Mat q3(planes[i], Rect(sz.width - x, 0, x, sz.height));
		q2.copyTo(tmp2);
		q3.copyTo(tmp3);
		tmp2.copyTo(planes[i](Rect(x, 0, sz.width - x, sz.height)));
		tmp3.copyTo(planes[i](Rect(0, 0, x, sz.height)));
	}

	merge(planes, out);
	return out;
}

Mat fftshift(Mat Src)
{
	Size sz = Src.size();
	Point pt(0, 0);
	pt.x = (int)floor(sz.width / 2.0);
	pt.y = (int)floor(sz.height / 2.0);
	Mat out = circshift(Src, pt);
	return out;
}

Mat fft2(const Mat src)
{
	int mat_type = src.type();
	Mat Fourier;

	assert(mat_type < 15); //不支持的数据格式

	if (mat_type < 7)
	{
		Mat planes[] = { Mat_<double>(src), Mat::zeros(src.size(), CV_64F) };
		merge(planes, 2, Fourier);
		dft(Fourier, Fourier);
	}
	else // 7<mat_type<15
	{
		Mat tmp;
		dft(src, tmp);
		vector<Mat> planes;
		split(tmp, planes);
		magnitude(planes[0], planes[1], planes[0]); //将复数转化为幅值
		Fourier = planes[0];
	}
	return Fourier;
}


Mat ifft2(const Mat src)
{
	Mat Fourier;
	int mat_type = src.type();
	assert(mat_type < 15); //不支持的数据格式
	if (mat_type < 7)
	{
		Mat planes[] = { Mat_<double>(src), Mat::zeros(src.size(), CV_64F) };
		merge(planes, 2, Fourier);
		dft(Fourier, Fourier, DFT_INVERSE + DFT_SCALE, 0);
	}
	else // 7<mat_type<15
	{
		Mat tem;
		dft(src, tem, DFT_INVERSE + DFT_SCALE, 0);
		vector<Mat> planes;
		split(tem, planes);
		magnitude(planes[0], planes[1], planes[0]); //将复数转化为幅值
		Fourier = planes[0];
	}
	return Fourier;
}


Mat ifftshift(Mat Scr)
{
	Size sz = Scr.size();
	Point pt(0, 0);
	pt.x = (int)ceil(sz.width / 2.0);
	pt.y = (int)ceil(sz.height / 2.0);
	Mat out = circshift(Scr, pt);
	return out;
}

Mat ImaRestoration(cv::Mat Ii, cv::Mat psf, double a = 0.1)
{
	
	Mat ps = fftshift(psf);
	Mat M = fft2(ps);
	Mat H = fftshift(M);
	//获取最大值像素
	double minValue = -1;
	double maxValue = -1;
	cv::Vec2d comp;
	cv::Vec2d* HPtr = H.ptr<cv::Vec2d>(0);
	for (int i = 0; i < H.size().area(); i++)
	{
		double val = sqrtf(HPtr[i][0] * HPtr[i][0] + HPtr[i][1] * HPtr[i][1]);
		if (val > maxValue)
		{
			maxValue = val;
			comp = HPtr[i];
		}
	}
	Mat Hh = H.clone();
	int rowNumber = Hh.rows;
	int colNumber = Hh.cols;
	for (int i = 0; i < rowNumber; i++)
	{
		cv::Vec2d*data = Hh.ptr<cv::Vec2d>(i);
		for (int j = 0; j < colNumber; j++)
		{
			double a = data[j][0];
			double b = data[j][1];
			double c = comp[0];
			double d = comp[1];
			data[j][0] = (a*c + b * d) / (c*c + d * d);
			data[j][1] = (b*c - a * d) / (c*c + d * d);
		}
	}
	Mat pf = fftshift(Ii);
	Mat Mm = fft2(pf);
	Mat Gi = fftshift(Mm);
	Mat Hhh = Hh + a;
	Mat GG(Gi.size(), Gi.type());
	for (int i = 0; i < rowNumber; i++)
	{
		cv::Vec2d*data = Hhh.ptr<cv::Vec2d>(i);
		cv::Vec2d*dataG = Gi.ptr<cv::Vec2d>(i);
		cv::Vec2d*dataGG = GG.ptr<cv::Vec2d>(i);
		for (int j = 0; j < colNumber; j++)
		{
			double a = dataG[j][0];
			double b = dataG[j][1];
			double c = data[j][0];
			double d = data[j][1];
			dataGG[j][0] = (a*c + b * d) / (c*c + d * d);
			dataGG[j][1] = (b*c - a * d) / (c*c + d * d);
		}
	}

	Mat ff = ifftshift(GG);
	Mat uu = ifft2(ff);
	Mat recovery = ifftshift(uu);
	double* imptr = recovery.ptr<double>(0);
	int pixSZ = recovery.size().area();
	double maxV = std::numeric_limits<double>::min();
	double minV = std::numeric_limits<double>::max();
	int normMin = 0;
	int normMax = 63;
	for (int p = 0; p < pixSZ; p++)
	{
		if (imptr[p] > maxV) maxV = imptr[p];
		if (imptr[p] < minV) minV = imptr[p];
	}

	double k = (double)(normMax - normMin) / (maxV - minV);
	double b = normMin - k * minV;
	cv::Mat3b color(recovery.size());
	cv::Vec3b* cPtr = color.ptr<cv::Vec3b>(0);
	for (int p = 0; p < pixSZ; p++)
	{
		int index = (int)(k* (imptr[p]) + b);
		cPtr[p][0] = lutArr[index * 3];
		cPtr[p][1] = lutArr[index * 3 + 1];
		cPtr[p][2] = lutArr[index * 3 + 2];
	}
	return color;
}
#endif

图像复原——维纳滤波
main.cpp

#include"ImaRestoration.h"

int main(int argc, char* argv[])
{
	Mat Ii = imread("Ii.bmp", 0);
	Mat psf = imread("psf.bmp", 0);
	double a = 0.1;
	cv::Mat color = ImaRestoration(Ii, psf, a);
	imshow("color", color);
	waitKey(0);
	return 0;
}
凶萌的小老虎
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
现代数字图像处理作业----用维纳滤波器进行图像复原
qq_56133122的博客
04-12 4388
1、任选一张彩色风景图片作为源图像，设置不同的模糊参数实现任一幅图像的运动模糊（fspecial,imfilter），再用imadd和imnoise给图像添加不同类型的噪声，显示噪声图像。 2、对1产生的图像分别进行复原，选用维纳滤波器进行图像复原，显示处理结果。
【图像修复】基于维纳滤波实现图像复原matlab源码含GUI
m0_60703264的博客
10-12 1408
一、简介 维纳滤波的基本思路与传统的滤波器相似，不过在输入输出上有所不同，维纳滤波的输入为带噪语音信号，其输出为纯净语音信号的估计值。维纳滤波的数学表达如式所示。 2 DD算法：当前帧的先验信噪比的估计： 3 优化 二、源代码 function varargout = wiener_filter(varargin) % WIENER_FILTER M-file for wiener_filter.fig % WIENER_FILTER, by itself, creates a new
matlab图像复原(逆滤波、维纳滤波等)
05-27
这是用matlab实现图像复原的程序，包括逆滤波、维纳滤波、约束最小二乘方滤波。
维纳滤波实现的图像复原
03-29
维纳滤波器实现图像的复原，并采用了自相关算法进行处理，使得恢复效果更好
opencv2.1+VS2008实现维纳滤波复原
01-09
花了本人三天时间实现维纳滤波对图像进行复原，亲测无误，注意我是用的opencv静态库，你可能需要配置一下
维纳滤波在图像复原中的应用
沉心修炼
04-25 2万+
图像退化/复原模型      g(x,y) = h(x,y)*f(x,y)+n(x,y)     频域：G(u,v) = H(u,v)F(u,v) +N(u,v)       其中f(x,y)为原始图像，h(x,y)为退化函数，n(x,y)为噪声函数，目标就是根据观测图像g(x,y)以及一些先验或者估计信息复原f(x,y)      图像复原的核心内容就是估计退化函数，因为当噪声N
循序渐进之（八）图像复原之维纳滤波
coming_is_winter的博客
06-09 2264
循序渐进之（八）图像复原之维纳滤波 维纳滤波为图像复原中对于逆滤波处理不了带有噪声的情况下使用的算法。 首先是运动模糊。手动对于图像进行对应PSF的模糊处理，方便后边使用。 算法来自于：【OpenCV】motion blur 的简单实现 ...
图象恢复——（逆滤波，维纳滤波）
热门推荐
IMWTJ123的博客
04-06 5万+
目的：对获取图像在频域用高斯函数进行退化并叠加白噪声，对退化图像进行逆滤波和维纳滤波恢复，比较原始图像和恢复图像，对利用逆滤波和维纳滤波恢复方法恢复图像进行比较。 一、基本原理       图像复原是一种客观的操作，通过使用退化现象的先验知识重建或恢复一副退化的图像；图像在形成、传输和记录的过程中，由于受多种原因的影响，图像的质量会有下降，典型表现为图像模糊、失真、有噪声等，这一降质的过程称为...
基于matlab的最小二乘方滤波程序（最小二乘方+逆滤波+维纳滤波复原图对比）
最新发布
06-19
本文将详细介绍基于MATLAB实现的三种滤波方法：最小二乘方滤波、逆滤波和维纳滤波，以及它们在图像复原中的应用。提供的压缩包文件包含了一个名为"MAIN.7z"的主程序，以及一个名为"bianji1.jpg"的示例图像。 1. **...
正则维纳滤波matlab,正则化约束维纳滤波
weixin_42367557的博客
03-19 947
在图像盲反卷积的过程中,最主要的难点是缺少点扩散函数的足够信息而导致的病态问题.解决此问题可以通过对原始图像和点扩散函数同时进行正则化约束.为了在图像复原过程......关键词图像复原,维纳滤波,点扩散函数,振铃,边缘提取 1. 引言随着科技和多媒体...目前 的图像复原及抑制振铃方法有:基于边缘分离的去振铃复原,图像去模糊正则化......——确定性方法和正则化方法,确定性方法具有明确的滤波函数...
维纳滤波opencv
08-01
用opencv编写的维纳滤波器 实现图像去噪和图像恢复
维纳滤波算法代码matlab-GPUWienerDespeckling:在GPU中正确设计的一种新开发的基于频域的方法呈现为经典Wiener滤
06-01
维纳比算法代码matlab GPU维纳去斑 在 GPU 中正确设计的一种新开发的基于频域的方法呈现为经典 Wiener 滤波器的增强，它考虑了图像的局部特征。 这种技术能够在非常有限的处理时间内提供有效的结果，如 中所述。 作者 比勒卡农 () 詹保罗·费拉奥利 () 维托·帕斯卡齐奥 () 吉尔达·席林兹 () 先决条件 代码在Matlab R2018b环境中Matlab R2018b ， Linux Debian作为操作系统。 在这种情况下使用的 GPU 需要CUDA v9.1和cudnn v7.1.3 。 执照 版权所有 (c) 2019 那不勒斯大学“Parthenope”。 版权所有。 这项工作只能用于非营利目的。 下载和/或使用这些文件中的任何一个，即表示您默示同意许可的所有条款，如文档 LICENSE.txt（包含在此目录中）中所指定。 请注意，在使用此代码时，请引用以下参考： B. Kanoun、G. Ferraioli、V. Pascazio 和 G. Schirinzi，基于 GPU 的快速去斑算法 SAR 数据滤波器，遥感，编号。 印刷中，（2019）。 资金 目
基于opencv的维纳滤波算法
10-12
基于opencv的维纳滤波算法
opencv实现逆滤波
11-06
matlab逆滤波改由opencv实现，测试可用
matlab逆滤波复原代码-Image_restoration:图像处理从内核恢复模糊图像
06-01
GUI，用于应用逆滤波、截断逆滤波、维纳滤波和约束最小二乘滤波“metrics.m”——一个用户定义的函数来计算 PSNR 和 SSIM。 在“ImageRestoration.m”中被调用 “Butter_LPF.m” - 一个用户定义的函数，用于在具有...
【老生谈算法】matlab实现图像复原算法源码——图像复原
m0_53407570的博客
10-22 1031
而图像复原试图利用退化现象的某种先验知识（即退化模型），把已经退化了得图像加以重建和复原。其目的就是尽可能地减少或去除在获取图像过程中发生的图像质量的下降（退化），恢复被退化图像的本来面目。图像在形成、传输和记录的过程中，由于受多种原因的影响，图像的质量会有下降，典型表现为图像模糊、失真、有噪声等。这一降质的过程称为图像的退化。2、用维纳滤波复原函数deconvwnr对模糊图像进行复原重建。1、读入一副图像，加入运动模糊和椒盐噪声；2、 提交实验的原始图像和结果图像。1、 实验中用到源程序代码；
维纳滤波复原噪声图像
Mr_Page的博客
04-21 3733
一．实验设备 计算机，MATLAB软件 二．实验目的 1.理解并掌握维纳滤波复原噪声图像的原理。 2.学习使用matlab对图像进行加噪声的操作。 3.学习使用matlab对噪声进行维纳滤波恢复原图像。 三．实验原理 实验原理维纳(wiener)滤波 可以归于反卷积(或反转滤波)算法一类，它是由Wiener首提出的，并应用于一维信号，并取得很好的效果。以后算法又被引入二维信号理，也取得相当满意的效果，尤其在图象复原领域，由于维纳滤波器的复原效良好，计算量较低，并且抗噪性能优良，因而在图象复原领域得到了广泛的
数字图像处理(10)：图像复原（去噪，C语言）
ZhaoDongyu_AK47的博客
06-26 3588
文章目录1. 复原被加性高斯噪声污染的图像2. 复原被椒盐噪声污染的图像3. 代码实现遇到的问题 1. 复原被加性高斯噪声污染的图像 在数字图像中的高斯噪声的主要来源出现在采集期间。 由于不良照明和/或高温引起的传感器噪声。在数字图像处理中，可以使用空间滤波器来降低高斯噪声，但是当对图像进行平滑时，结果可能导致精细缩放的图像边缘和细节的模糊，因为它们也对应于被阻挡的高频。 用于噪声去除的常规空间滤波技术包括：平均（卷积）滤波，中值滤波和高斯平滑。 分析：对于加性高斯噪声污染的图像分别用了3x3算术均值滤波
MATLAB维纳滤波：图像退化恢复的利器
论文首先介绍了维纳滤波的基本原理，包括其理论基础——线性预测和最小均方误差优化。接着，作者详细阐述了如何在MATLAB环境中构建维纳滤波器，这通常涉及到噪声模型的建立、自相关函数的估计以及滤波器系数的计算。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值