精华内容
下载资源
问答
  • 中值滤波器

    2014-06-10 19:56:01
    一个简单的中值滤波器,基于matlab所编写的。比较入门
  • 巴特沃斯中值滤波器.pdf
  • 空间域滤波处理中值滤波器
  • MATLAB的.m文件,开关型矢量中值滤波器的实现,需要在标准CIELAB空间下使用,具体的开关型矢量中值滤波器的原理可以参考论文
  • 中值滤波器的V e r i l o g 实现代码,已通过测试,,可直接使用
  • C++实现均值滤波器和中值滤波器 数字图像处理课作业,代码实现均值滤波器和中值滤波器 由于中值滤波器是非线性滤波,不是卷积,所以均值和中值滤波分开实现。这里只给出代码,opencv版本为3.4.5 my_convolution...

    C++实现均值滤波器和中值滤波器

    代码实现均值滤波器和中值滤波器
    在这里插入图片描述
    由于中值滤波器是非线性滤波,不是卷积,所以均值和中值滤波分开实现。opencv版本为3.4.5

    my_convolution.h

    #ifndef MY_CONVOLUTION
    #define MY_CONVOLUTION
    
    #include <opencv2/opencv.hpp>
    
    class My_Convolution {
    public:
    	My_Convolution();
    	~My_Convolution();
    	bool load_kernal(const cv::Mat kernal);//加载卷积核
    	void convolute(const cv::Mat &image, cv::Mat &dst);//卷积操作
    
    private:
    	bool kernal_loaded;//是否已经加载卷积核
    	cv::Mat curr_kernal;//当前卷积核
    	int bios_x, bios_y;//记录偏移量
    
    	//计算每一个像素的掩模乘积之和
    	void compute_sum_of_product(int i, int j, int chan, cv::Mat &complete_image, cv::Mat & dst);
    	//将原图像转换成边框补全的图像
    	void complete_image_transform(const cv::Mat &image, cv::Mat &dst);
    };
    
    #endif // MY_CONVOLUTION
    
    

    my_convolution.cpp

    #include "my_convolution.h"
    
    using namespace std;
    using namespace cv;
    
    My_Convolution::My_Convolution() {
    	kernal_loaded = false;
    }
    My_Convolution::~My_Convolution() {}
    
    //加载卷积核
    bool My_Convolution::load_kernal(const Mat kernal) {
    	if (kernal.cols % 2 == 1 && kernal.rows % 2 == 1) {
    		curr_kernal = kernal.clone();
    		bios_x = (kernal.cols - 1) / 2;
    		bios_y = (kernal.rows - 1) / 2;
    		kernal_loaded = true;
    		return true;
    	}
    	else {
    		cout << "The size of kernal is not suitable!" << endl;
    		return false;
    	}
    }
    
    //卷积操作
    void My_Convolution::convolute(const Mat &image, Mat &dst) {
    	if (!kernal_loaded) {
    		cout << "kernal is empty!Please load the kernal first!" << endl;return;
    	}
    	Mat complete_image;
    	complete_image_transform(image, complete_image);
    	dst = Mat::zeros(image.rows, image.cols, image.type());
    	int channels = image.channels();//获取图像的通道数
    	if (channels == 3) {
    		for (int chan = 0;chan < channels;chan++) {
    			for (int i = 0;i < dst.rows;i++) {
    				for (int j = 0;j < dst.cols;j++) {
    					compute_sum_of_product(i, j, chan, complete_image, dst);
    				}
    			}
    		}
    		return;
    	}
    	if (channels == 1) {
    		for (int i = 0;i < dst.rows;i++) {
    			for (int j = 0;j < dst.cols;j++) {
    				compute_sum_of_product(i, j, 0, complete_image, dst);
    			}
    		}
    	}
    
    }
    
    //计算掩模乘积之和
    void My_Convolution::compute_sum_of_product(int i, int j, int chan, Mat &complete_image, Mat &dst) {
    	if (complete_image.channels() == 3) {
    		float sum = 0;
    		int bios_rows = i;
    		int bios_cols = j;
    		for (int curr_rows = 0;curr_rows < curr_kernal.rows;curr_rows++) {
    			for (int curr_cols = 0;curr_cols < curr_kernal.cols;curr_cols++) {
    				float a = curr_kernal.at<float>(curr_rows, curr_cols)*complete_image.at<Vec3b>(curr_rows + bios_rows, curr_cols + bios_cols)[chan];
    				sum += a;
    			}
    		}
    		dst.at<Vec3b>(i, j)[chan] = (int)sum;
    	}
    	else if (complete_image.channels() == 1) {
    			float sum = 0;
    			int bios_rows = i;
    			int bios_cols = j;
    			for (int curr_rows = 0;curr_rows < curr_kernal.rows;curr_rows++) {
    				for (int curr_cols = 0;curr_cols < curr_kernal.cols;curr_cols++) {
    					float a = curr_kernal.at<float>(curr_rows, curr_cols)*complete_image.at<uchar>(curr_rows + bios_rows, curr_cols + bios_cols);
    					sum += a;
    				}
    			}
    			dst.at<uchar>(i, j) = (int)sum;
    		}
    	else {
    			cout << "the type of image is not suitable!" << endl;return;
    		}
    	}
    
    
    
    
    //边框像素补全
    void My_Convolution::complete_image_transform(const Mat &image, Mat &dst) {
    	if (!kernal_loaded) {
    		cout << "kernal is empty!" << endl;
    		return;
    	}
    	//Mat的type()成员函数生成CV_<位数>(S/U/F)C<通道数>
    	//初始化一个补全图像的大小。
    	dst = Mat::zeros(2 * bios_y + image.rows, 2 * bios_x + image.cols, image.type());
    	Rect real_roi_of_image = Rect(bios_x, bios_y, image.cols, image.rows);
    	Mat real_mat_of_image = dst(real_roi_of_image);
    	image.copyTo(real_mat_of_image);
    }
    
    
    

    my_nedianfilter.h

    #ifndef MY_MEDIANFILTER
    #define MY_MEDIANFILTER
    
    #include <vector>
    #include <opencv2/opencv.hpp>
    using namespace cv;
    using namespace std;
    
    void MedianFilter(Mat& src, Mat& dst, int win_size);
    void Complete_Image_Transform(Mat &src, Mat &comp, int size);
    void Calc_Median(Mat& comp, Mat& dst, int r, int c, int s);
    
    #endif
    
    

    my_nedianfilter.cpp

    #include "my_medianfilter.h"
    
    void MedianFilter(Mat& src, Mat& dst, int win_size) {
    	Mat comp = src.clone();
    	Complete_Image_Transform(src, comp, win_size);
    
    	int rows = comp.rows, cols = comp.cols;
    	int start = win_size / 2;
    
    	if (comp.channels() > 1)
    	{
    		//彩色图片通道分离
    		vector<Mat> channels_c, channels_d;
    		split(comp, channels_c);
    		split(comp, channels_d);
    		//滤波
    		for (int i = 0; i < 3; i++)
    			Calc_Median(channels_c[i], channels_d[i], rows, cols, start);
    
    		//合并彩色通道
    		merge(channels_d, dst);
    	}
    	else
    		Calc_Median(comp, dst, rows, cols, start);
    }
    
    
    //边框像素补全
    void Complete_Image_Transform(Mat &src, Mat &comp, int size) {
    	
    	//初始化一个补全图像的大小
    	comp = Mat::zeros(2 * (size / 2) + src.rows, 2 * (size / 2) + src.cols, src.type());
    	Rect real_roi_of_image = Rect((size / 2), (size / 2), src.cols, src.rows);
    	Mat real_mat_of_image = comp(real_roi_of_image);
    	src.copyTo(real_mat_of_image);
    }
    
    void Calc_Median(Mat& comp, Mat& dst, int r, int c, int s)
    {
    	for (int m = s; m < r - s; m++) {
    		for (int n = s; n < c - s; n++) {
    			vector<uchar> model;
    			for (int i = -s + m; i <= s + m; i++) {
    				for (int j = -s + n; j <= s + n; j++) {
    					//cout << int(src.at<uchar>(i, j)) << endl;
    					model.push_back(comp.at<uchar>(i, j));
    				}
    			}
    			sort(model.begin(), model.end());     //采用快速排序进行
    			dst.at<uchar>(m - s, n - s) = model[(s * 2 + 1) * (s * 2 + 1) / 2];
    		}
    	}
    }
    
    
    展开全文
  • MATLAB中值滤波器

    千次阅读 2019-05-23 21:27:29
    对于中值滤波器,MATLAB也有自带的函数medfilt2(),中值滤波器对椒盐噪声的处理效果很好。 close all clc i=7; % filename='D:\Matlab2018a\work\meanfilter\Set12\08.png'; %图片路径 imgGray = im2double(imread...

    对于中值滤波器,MATLAB也有自带的函数medfilt2(),中值滤波器对椒盐噪声的处理效果很好。

    close all
    clc
    i=7;  %
    filename='D:\Matlab2018a\work\meanfilter\Set12\08.png'; %图片路径,改成你自己的
    imgGray = im2double(imread(filename)); %读入图片
    % imgnoise=imnoise(imgGray,'gaussian',0,0.01); %添加椒盐噪声
     imgnoise=imnoise(imgGray,'salt & pepper',0.2);
    %imgnoise=imnoise(imgGray,'speckle',0.04);
     output = medfilt2(imgnoise,[i,i],'symmetric' );%symmetric:边缘采用镜像反射外边界的方式来扩展,这种方式对边缘的处理效果最好
    imwrite(output,'D:\Matlab2018a\work\meanfilter\median\result\res_c_median7.png')%写出处理后的图片到指定目录
    imshow ([imgGray,imgnoise,doutput]);%分别显示原图,含噪图像,去噪图像
    PSNR = psnr(imgGray,output);% 计算PSNR 
    
    展开全文
  • 中值滤波器函数

    2014-10-18 17:37:56
    资源是针对图像处理中MATLAB学习,代码是中值滤波器函数文件,可用于实验练习
  • 基于联合加权稀疏表示的深度视频中值滤波器
  • C语言 中值滤波器

    2012-04-02 13:51:09
    C语言 实现中值滤波器 但是只能处理256位的图像
  • 最大最小滤波器等,对于少量椒盐噪声的处理,往往选择中值滤波器会有较好的效果,但是当椒盐噪声很大时,使用常规的中值滤波器往往会导致图像的严重失真(这点可以从例子中看出),NAFSM中值滤波器可以很好解决这个...

    去年大三时课上,医学图像处理老师讲解了这个算法,当时布置的作业就是实现这个中值滤波器,今天突然从一篇论文中看到过类似这种思想,就又想起来了,发现网上对这个算法的讲解很少,那我就在这分享一下咯!下面是原论文:
    K. K. V. Toh and N. A. Mat Isa, “Noise Adaptive Fuzzy Switching Median Filter for Salt-and-Pepper Noise Reduction,” in IEEE Signal Processing Letters, vol. 17, no. 3, pp. 281-284, March 2010.,链接:https://ieeexplore.ieee.org/document/5356178

    接下来我将从我对该算法理解、算法实现、算法MATLAB代码、实验报告这个顺序进行我的讲解,希望能帮助到一些人。
    一、NAFSM算法理解:
    首先发一张我的总结:

    NAFSM中值滤波器原理

    第一步:是一个二值化处理,对于图像像素灰度值最大和最小当做椒盐噪声,该像素值变成0。
    注意图中公式N(i,j)和X(i,j)的区别,这对于理解后面推导很重要,其中N代表二值化后的矩阵,值为1的像素代表该点不是噪声,为0的像素代表该点为噪声点,而对于X则还是原图的灰度值,后面M代表准恢复图像像素灰度值,Y代表最后处理后的图像像素灰度值大小。
    第二步:定义一个矩形框,图中s即代表矩形框的大小参数,如果s=1,代表矩形框大小为33;如果s=2,代表矩形框大小为55,以此类推;
    第三步:因为对于处理这类噪声,主要难点就是噪声点灰度大小恢复的问题,作者考虑当在该像素点矩形框内,有存在不是噪声点的点,也就是图片中G的大小不为0,则直接可以提取矩形框内那些不为0的点(非噪声像素点)灰度值的中值作为该点灰度值;
    第四步:然而,如果发现矩形框内都是噪声点,也就是矩形框内的N(i,j)都为0,这个时候就需要将矩形框扩大,比如s=1,变成s=2,继续第二步,如果最后发现s=3,也就是77矩形框内结果还是都为噪声点,即G=0,则直接将该点灰度值定义为其33框内,左上角四个像素灰度值的中值(这里解释一下,由于一张图处理一般都是从左上角像素开始,所以这里就假设了正在处理的像素点之前的像素点都已经获得比较靠谱的灰度值大小,所以这里就只选取图中几个像素点灰度大小的中值);
    第五步:经过前面几步,至此,M的大小已全部确定,但是这里作者没有直接取M值作为最后处理结果,作者对原始灰度图像计算33矩形框内与中心点灰度值绝对值相差最大值;
    第六步:通过一个函数计算F值大小,可参考下图理解:
    在这里插入图片描述
    结合图中那个求F公式可以知道,其主要思想是:当原始图像3
    3矩形框内有像素灰度差异比较大时,认为这个点灰度可信度比较低,也即是F为1,对应于Y值就是不考虑X(原始灰度)大小,当矩形框内像素灰度值差异很小时,认为这点可信度很高(因为如果框内存在椒盐噪声,则必为0或者225,大概率两者都有,所以这个时候值只会很大,不会很小),这个时候F就为0,也就是相信X值大小,同理可理解中间那段(如上图中间那段呈线性变化)。我在matlab程序里选取的T1和T2值分别为30和60,F值是用来衡量M与真实值之间误差;
    第七步:最后通过公式求出Y,即最后结果。

    二、算法实现
    这是matlab上运行部分结果图:
    加10%椒盐噪声:
    在这里插入图片描述

    加20%椒盐噪声

    在这里插入图片描述
    加50%椒盐噪声:在这里插入图片描述
    加70%椒盐噪声:在这里插入图片描述
    加90%椒盐噪声:
    在这里插入图片描述
    可以看到,NAFSM滤波器效果非常好,碾压普通中值滤波器。

    三、MATLAB代码:

    clear
    [Im,map]=imread('lena.gif');
    J=ind2gray(Im, map);
    I= imnoise(J,'salt & pepper',0.5);%加入椒盐噪声
    [m n]=size(I);
    N=zeros(m,n);%定义一个二值图空矩阵
    for i=1:1:m %确定图像二值图,将灰度值为0或者255的像素定义为椒盐噪声,二值图大小为0
        for j=1:1:n
            if I(i,j)==255||I(i,j)==0
                N(i,j)=0;
            else
                N(i,j)=1;
            end
        end
    end
    s=input('请输入大小为s*s的矩形窗,s=');
    G=zeros(m,n);%定义一用来保存矩形窗内二值总大小的矩阵
    for i=1:1:m%计算矩形窗内各像素大小,并且求预恢复值M(i,j) 
        for j=1:1:n
            W=zeros(s,s);%定义一个空的矩形窗
             for li=1:1:s
                for lj=1:1:s
                    if (i+li-(s+1)/2)<=0||(j+lj-(s+1)/2)<=0||(i+li-(s+1)/2)>m||(j+lj-(s+1)/2)>n%判断是否超出原始图像范围
                        continue;
                    end
                    W(li,lj)=N(i+li-(s+1)/2,j+lj-(s+1)/2);%获取矩形窗内数据
                end
             end
             G(i,j)=sum(sum(W));
             z=s;
             for k=s:2:5
            if G(i,j)==0
                z=k+2;
                W1=zeros(z,z);%定义一个空的矩形窗
              for li=1:1:z
                 for lj=1:1:z
                     if (i+li-(z+1)/2)<=0||(j+lj-(z+1)/2)<=0||(i+li-(z+1)/2)>m||(j+lj-(z+1)/2)>n%判断是否超出原始图像范围
                         continue;
                     end
                     W1(li,lj)=N(i+li-(z+1)/2,j+lj-(z+1)/2);%获取矩形窗内数据
                 end
              end
              G(i,j)=sum(sum(W1));
              if G(i,j)==0
                 continue;
              else
                  break;
              end
            else
                break;
            end
            end
            if z==7
                 M(i,j)=median(I(i-1,j-1),I(i,j-1),I(i+1,j-1),I(i-1,j));
    %            M(i,j)=I(i,j);
               continue;
            end
            W2=zeros(1,G(i,j));
            nn=1;
            for i1=1:1:z
                for j1=1:1:z
                    if (i+i1-(z+1)/2)<=0||(j+j1-(z+1)/2)<=0||(i+i1-(z+1)/2)>m||(j+j1-(z+1)/2)>n%判断是否超出原始图像范围
                        continue;      
                    elseif N(i+i1-(z+1)/2,j+j1-(z+1)/2)==1
                        W2(nn)=I(i+i1-(z+1)/2,j+j1-(z+1)/2);
                        nn=nn+1;
                    end
                end
            end
            M(i,j)=median(W2);
        end
    end
    W3=zeros(3,3);
    D=zeros(m,n);
    for i=1:1:m
        for j=1:1:n
            L=zeros(3,3);%定义一个m*n的矩形窗
            for li=1:1:3
                for lj=1:1:3
                    if (i+li-(3+1)/2)<=0||(j+lj-(3+1)/2)<=0||(i+li-(3+1)/2)>m||(j+lj-(3+1)/2)>n%判断是否超出原始图像范围
                        continue;
                    end
                    L(li,lj)=I(i+li-(3+1)/2,j+lj-(3+1)/2);%获取矩形窗内数据
                end
            end
            d=zeros(1,9);
            ii=1;
            for i1=1:1:3
                for j1=1:1:3
                    d(ii)=abs(L(i1,j1)-L(2,2));
                    ii=ii+1;
                end
            end
            D(i,j)=max(d);
        end
    end
    F=zeros(m,n);
    T1=20;
    T2=60;
    for i=1:1:m
        for j=1:1:n
            if D(i,j)<T1
                F(i,j)=0;
            elseif D(i,j)>=T1&&D(i,j)<T2
                F(i,j)=(D(i,j)-T1)/(T2-T1);
            else
                F(i,j)=1;
            end
            
        end
    end
    Y=zeros(m,n);
    for i=1:1:m
        for j=1:1:n
            Y(i,j)=(1-F(i,j))*I(i,j)+F(i,j)*M(i,j);
        end
    end
    figure(1)
    subplot(2,2,1)
    imshow(J);
    title('原始图像');
    subplot(2,2,2)
    imshow(I);
    title('加入椒盐噪声后的图像');
    subplot(2,2,3)
    T=Median_filter(I,s,s);
    T=uint8(T);
    imshow(T);
    title('普通中值滤波函数滤波后图像') 
    subplot(2,2,4)
    Y=uint8(Y);
    imshow(Y);
    title('NAFSM滤波器滤波后的图像'); 
    function [T]=Median_filter(I,m,n)
    [M,N]=size(I);
    T=zeros(M,N);
    for i=1:1:M
        for j=1:1:N
            L=zeros(m,n);%定义一个m*n的矩形窗
            for li=1:1:m
                for lj=1:1:n
                    if (i+li-(m+1)/2)<=0||(j+lj-(n+1)/2)<=0||(i+li-(m+1)/2)>M||(j+lj-(n+1)/2)>N%判断是否超出原始图像范围
                        continue;
                    end
                    L(li,lj)=I(i+li-(m+1)/2,j+lj-(n+1)/2);%获取矩形窗内数据
                end
            end
            T(i,j)=median(median(L));%求矩形窗内中值
        end
    end
    end

    对于本次实验报告、图片和源matlab代码,可以去我主页下载附件!!!!!!!!!!!
    转载请注明出处,谢谢

    展开全文
  • 自适应中值滤波器的python实现

    千次阅读 2019-10-23 09:57:16
    自适应中值滤波器的python实现@TOC 欢迎使用Markdown编辑器 具体原理可参照https://www.cnblogs.com/wangguchangqing/p/6379646.html,下面是用python版的opencv实现的自适应中值滤波器的代码: ''' 自适应中值...

    自适应中值滤波器的python实现

    具体原理可参照https://www.cnblogs.com/wangguchangqing/p/6379646.html,下面是用python版的opencv实现的自适应中值滤波器的代码:

    '''   自适应中值滤波器的python实现   '''
    def AdaptProcess(src, i, j, minSize, maxSize):
    
        filter_size = minSize
    
        kernelSize = filter_size // 2
        rio = src[i-kernelSize:i+kernelSize+1, j-kernelSize:j+kernelSize+1]
        minPix = np.min(rio)
        maxPix = np.max(rio)
        medPix = np.median(rio)
        zxy = src[i,j]
    
        if (medPix > minPix) and (medPix < maxPix):
            if (zxy > minPix) and (zxy < maxPix):
                return zxy
            else:
                return medPix
        else:
            filter_size = filter_size + 2
            if filter_size <= maxSize:
                return AdaptProcess(src, i, j, filter_size, maxSize)
            else:
                return medPix
    
    
    def adapt_meadian_filter(img, minsize, maxsize):
    
        borderSize = maxsize // 2
    
        src = cv2.copyMakeBorder(img, borderSize, borderSize, borderSize, borderSize, cv2.BORDER_REFLECT)
    
        for m in range(borderSize, src.shape[0] - borderSize):
            for n in range(borderSize, src.shape[1] - borderSize):
                src[m,n] = AdaptProcess(src, m, n, minsize, maxsize)
    
        dst = src[borderSize:borderSize+img.shape[0], borderSize:borderSize+img.shape[1]]
        return dst
    
    
    
    
    展开全文
  • C++图像处理中值滤波器
  • 心电信号去噪2--中值滤波器

    千次阅读 2019-06-02 19:57:34
    上一篇中我们说到基线漂移是心电信号中的主要噪音之一,本张介绍的中值滤波器可以较好的去除基线漂移的噪音。 中值滤波器原理 中值滤波器一种非线性的数字滤波技术,具有抑制噪声和保护边...
  • opencv 中值滤波器 C++实现 源代码 完全,可完好实现!
  • 传统中值滤波器处理低概率椒盐噪声退化的图像效果令人满意 但是对于 P = 0.2 的脉冲噪声退化过的图片的处理效果就很令人失望,会丢失很多细节,由此,自适应中值滤波器诞生,与传统不同的是,自适应中值滤波器尝试...
  • 针对高清图像在中值滤波预处理过程中排序量多、速度慢的特点,提出适合邻域图像并行处理...在流水线结构下,1个时钟周期可以并行处理32个3×3邻域的中值滤波运算,实现了高速、实时的1 920×1 080灰度图像中值滤波器
  • 一种结合自适应中值滤波器的双边滤波算法,林甲鑫,范新南,本文针对双边滤波器存在的不足,提出了一种结合自适应中值滤波器的双边滤波算法。实验结果表明,改进的双边滤波器在保留图像细节

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,086
精华内容 434
关键字:

中值滤波器