精华内容
下载资源
问答
  • 高斯滤波器matlab实现

    2012-09-06 21:21:35
    高斯滤波器matlab实现 function h = d2gauss(n1,std1,n2,std2,theta),还有主函数和一些具体实例
  • 高斯滤波器是一种线性滤波器,能够有效的抑制噪声,平滑图像。其作用原理和均值滤波器类似,都是取滤波器窗口内的像素的均值作为输出。其窗口模板的系数和均值滤波器不同,均值滤波器的模板系数都是相同的为1;而高斯...

    c1d7f7d4ee6ebd5f1f11915f1313cf2b.png
    高斯滤波器是一种线性滤波器,能够有效的抑制噪声,平滑图像。其作用原理和均值滤波器类似,都是取滤波器窗口内的像素的均值作为输出。其窗口模板的系数和均值滤波器不同,均值滤波器的模板系数都是相同的为1;而高斯滤波器的模板系数,则随着距离模板中心的增大而系数减小。所以,高斯滤波器相比于均值滤波器对图像个模糊程度较小。
    电子学习资料大礼包mp.weixin.qq.com

    什么是高斯滤波器

    既然名称为高斯滤波器,那么其和高斯分布(正态分布)是有一定的关系的。一个二维的高斯函数如下:

    f2289c695b40434c7dc909cd34681395.png

    其中(x,y)(x,y)为点坐标,在图像处理中可认为是整数;σσ是标准差。要想得到一个高斯滤波器的模板,可以对高斯函数进行离散化,得到的高斯函数值作为模板的系数。例如:要产生一个3×33×3的高斯滤波器模板,以模板的中心位置为坐标原点进行取样。模板在各个位置的坐标,如下所示(x轴水平向右,y轴竖直向下)

    6aca668ae9916542f8092f07dfb7b7f5.png

    这样,将各个位置的坐标带入到高斯函数中,得到的值就是模板的系数。

    对于窗口模板的大小为(2k+1)×(2k+1),模板中各个元素值的计算公式如下:

    4bd7e48d9d44ee251341fd02fa23e1b8.png

    这样计算出来的模板有两种形式:小数和整数。

    • 小数形式的模板,就是直接计算得到的值,没有经过任何的处理;
    • 整数形式的,则需要进行归一化处理,将模板左上角的值归一化为1,下面会具体介绍。使用整数的模板时,需要在模板的前面加一个系数,系数为

    640a7bba0eb62c03f0ec2f59526a3f8b.png

    也就是模板系数和的倒数。

    高斯模板的生成

    知道模板生成的原理,实现起来也就不困难了

    void generateGaussianTemplate(double window[][11], int ksize, double sigma)
    {
        static const double pi = 3.1415926;
        int center = ksize / 2; // 模板的中心位置,也就是坐标的原点
        double x2, y2;
        for (int i = 0; i < ksize; i++)
        {
            x2 = pow(i - center, 2);
            for (int j = 0; j < ksize; j++)
            {
                y2 = pow(j - center, 2);
                double g = exp(-(x2 + y2) / (2 * sigma * sigma));
                g /= 2 * pi * sigma;
                window[i][j] = g;
            }
        }
        double k = 1 / window[0][0]; // 将左上角的系数归一化为1
        for (int i = 0; i < ksize; i++)
        {
            for (int j = 0; j < ksize; j++)
            {
                window[i][j] *= k;
            }
        }
    }

    需要一个二维数组,存放生成的系数(这里假设模板的最大尺寸不会超过11);第二个参数是模板的大小(不要超过11);第三个参数就比较重要了,是高斯分布的标准差。生成的过程,首先根据模板的大小,找到模板的中心位置ksize/2。然后就是遍历,根据高斯分布的函数,计算模板中每个系数的值。

    需要注意的是,最后归一化的过程,使用模板左上角的系数的倒数作为归一化的系数(左上角的系数值被归一化为1),模板中的每个系数都乘以该值(左上角系数的倒数),然后将得到的值取整,就得到了整数型的高斯滤波器模板。

    下面截图生成的是,大小为3×3,σ=0.83×3,σ=0.8的模板

    43bf7cfe230645477d4be5b38416de0c.png

    对上述解结果取整后得到如下模板:

    5be752d7793c98319080729880622af8.png

    这个模板就比较熟悉了,其就是根据σ=0.8的高斯函数生成的模板。

    至于小数形式的生成也比较简单,去掉归一化的过程,并且在求解过程后,模板的每个系数要除以所有系数的和。具体代码如下:

    void generateGaussianTemplate(double window[][11], int ksize, double sigma)
    {
        static const double pi = 3.1415926;
        int center = ksize / 2; // 模板的中心位置,也就是坐标的原点
        double x2, y2;
        double sum = 0;
        for (int i = 0; i < ksize; i++)
        {
            x2 = pow(i - center, 2);
            for (int j = 0; j < ksize; j++)
            {
                y2 = pow(j - center, 2);
                double g = exp(-(x2 + y2) / (2 * sigma * sigma));
                g /= 2 * pi * sigma;
                sum += g;
                window[i][j] = g;
            }
        }
        //double k = 1 / window[0][0]; // 将左上角的系数归一化为1
        for (int i = 0; i < ksize; i++)
        {
            for (int j = 0; j < ksize; j++)
            {
                window[i][j] /= sum;
            }
        }
    }

    3×3,σ=0.8的小数型模板。

    2f4daa41ff39ca7fe633c79e477da6ef.png

    σσ值的意义及选取

    通过上述的实现过程,不难发现,高斯滤波器模板的生成最重要的参数就是高斯分布的标准差σσ。标准差代表着数据的离散程度,如果σσ较小,那么生成的模板的中心系数较大,而周围的系数较小,这样对图像的平滑效果就不是很明显;反之,σσ较大,则生成的模板的各个系数相差就不是很大,比较类似均值模板,对图像的平滑效果比较明显。

    来看下一维高斯分布的概率分布密度图:

    294676c4b2b0305aa1d662ea07f304a5.png

    横轴表示可能得取值x,竖轴表示概率分布密度F(x),那么不难理解这样一个曲线与x轴围成的图形面积为1。σσ(标准差)决定了这个图形的宽度,可以得出这样的结论:σσ越大,则图形越宽,尖峰越小,图形较为平缓;σσ越小,则图形越窄,越集中,中间部分也就越尖,图形变化比较剧烈。这其实很好理解,如果sigma也就是标准差越大,则表示该密度分布一定比较分散,由于面积为1,于是尖峰部分减小,宽度越宽(分布越分散);同理,当σσ越小时,说明密度分布较为集中,于是尖峰越尖,宽度越窄!

    于是可以得到如下结论:

    σσ越大,分布越分散,各部分比重差别不大,于是生成的模板各元素值差别不大,类似于平均模板;

    σσ越小,分布越集中,中间部分所占比重远远高于其他部分,反映到高斯模板上就是中心元素值远远大于其他元素值,于是自然而然就相当于中间值得点运算。

    基于OpenCV的实现

    在生成高斯模板好,其简单的实现和其他的空间滤波器没有区别,具体代码如下:

    void GaussianFilter(const Mat &src, Mat &dst, int ksize, double sigma)
    {
        CV_Assert(src.channels() || src.channels() == 3); // 只处理单通道或者三通道图像
        const static double pi = 3.1415926;
        // 根据窗口大小和sigma生成高斯滤波器模板
        // 申请一个二维数组,存放生成的高斯模板矩阵
        double **templateMatrix = new double*[ksize];
        for (int i = 0; i < ksize; i++)
            templateMatrix[i] = new double[ksize];
        int origin = ksize / 2; // 以模板的中心为原点
        double x2, y2;
        double sum = 0;
        for (int i = 0; i < ksize; i++)
        {
            x2 = pow(i - origin, 2);
            for (int j = 0; j < ksize; j++)
            {
                y2 = pow(j - origin, 2);
                // 高斯函数前的常数可以不用计算,会在归一化的过程中给消去
                double g = exp(-(x2 + y2) / (2 * sigma * sigma));
                sum += g;
                templateMatrix[i][j] = g;
            }
        }
        for (int i = 0; i < ksize; i++)
        {
            for (int j = 0; j < ksize; j++)
            {
                templateMatrix[i][j] /= sum;
                cout << templateMatrix[i][j] << " ";
            }
            cout << endl;
        }
        // 将模板应用到图像中
        int border = ksize / 2;
        copyMakeBorder(src, dst, border, border, border, border, BorderTypes::BORDER_REFLECT);
        int channels = dst.channels();
        int rows = dst.rows - border;
        int cols = dst.cols - border;
        for (int i = border; i < rows; i++)
        {
            for (int j = border; j < cols; j++)
            {
                double sum[3] = { 0 };
                for (int a = -border; a <= border; a++)
                {
                    for (int b = -border; b <= border; b++)
                    {
                        if (channels == 1)
                        {
                            sum[0] += templateMatrix[border + a][border + b] * dst.at<uchar>(i + a, j + b);
                        }
                        else if (channels == 3)
                        {
                            Vec3b rgb = dst.at<Vec3b>(i + a, j + b);
                            auto k = templateMatrix[border + a][border + b];
                            sum[0] += k * rgb[0];
                            sum[1] += k * rgb[1];
                            sum[2] += k * rgb[2];
                        }
                    }
                }
                for (int k = 0; k < channels; k++)
                {
                    if (sum[k] < 0)
                        sum[k] = 0;
                    else if (sum[k] > 255)
                        sum[k] = 255;
                }
                if (channels == 1)
                    dst.at<uchar>(i, j) = static_cast<uchar>(sum[0]);
                else if (channels == 3)
                {
                    Vec3b rgb = { static_cast<uchar>(sum[0]), static_cast<uchar>(sum[1]), static_cast<uchar>(sum[2]) };
                    dst.at<Vec3b>(i, j) = rgb;
                }
            }
        }
        // 释放模板数组
        for (int i = 0; i < ksize; i++)
            delete[] templateMatrix[i];
        delete[] templateMatrix;
    }

    只处理单通道或者三通道图像,模板生成后,其滤波(卷积过程)就比较简单了。不过,这样的高斯滤波过程,其循环运算次数为m×n×ksize2,其中m,n为图像的尺寸;ksize为高斯滤波器的尺寸。这样其时间复杂度为O(ksize2),随滤波器的模板的尺寸呈平方增长,当高斯滤波器的尺寸较大时,其运算效率是极低的。为了,提高滤波的运算速度,可以将二维的高斯滤波过程分解开来。

    分离实现高斯滤波

    由于高斯函数的可分离性,尺寸较大的高斯滤波器可以分成两步进行:首先将图像在水平(竖直)方向与一维高斯函数进行卷积;然后将卷积后的结果在竖直(水平)方向使用相同的一维高斯函数得到的模板进行卷积运算。具体实现代码如下:

    // 分离的计算
    void separateGaussianFilter(const Mat &src, Mat &dst, int ksize, double sigma)
    {
        CV_Assert(src.channels()==1 || src.channels() == 3); // 只处理单通道或者三通道图像
        // 生成一维的高斯滤波模板
        double *matrix = new double[ksize];
        double sum = 0;
        int origin = ksize / 2;
        for (int i = 0; i < ksize; i++)
        {
            // 高斯函数前的常数可以不用计算,会在归一化的过程中给消去
            double g = exp(-(i - origin) * (i - origin) / (2 * sigma * sigma));
            sum += g;
            matrix[i] = g;
        }
        // 归一化
        for (int i = 0; i < ksize; i++)
            matrix[i] /= sum;
        // 将模板应用到图像中
        int border = ksize / 2;
        copyMakeBorder(src, dst, border, border, border, border, BorderTypes::BORDER_REFLECT);
        int channels = dst.channels();
        int rows = dst.rows - border;
        int cols = dst.cols - border;
        // 水平方向
        for (int i = border; i < rows; i++)
        {
            for (int j = border; j < cols; j++)
            {
                double sum[3] = { 0 };
                for (int k = -border; k <= border; k++)
                {
                    if (channels == 1)
                    {
                        sum[0] += matrix[border + k] * dst.at<uchar>(i, j + k); // 行不变,列变化;先做水平方向的卷积
                    }
                    else if (channels == 3)
                    {
                        Vec3b rgb = dst.at<Vec3b>(i, j + k);
                        sum[0] += matrix[border + k] * rgb[0];
                        sum[1] += matrix[border + k] * rgb[1];
                        sum[2] += matrix[border + k] * rgb[2];
                    }
                }
                for (int k = 0; k < channels; k++)
                {
                    if (sum[k] < 0)
                        sum[k] = 0;
                    else if (sum[k] > 255)
                        sum[k] = 255;
                }
                if (channels == 1)
                    dst.at<uchar>(i, j) = static_cast<uchar>(sum[0]);
                else if (channels == 3)
                {
                    Vec3b rgb = { static_cast<uchar>(sum[0]), static_cast<uchar>(sum[1]), static_cast<uchar>(sum[2]) };
                    dst.at<Vec3b>(i, j) = rgb;
                }
            }
        }
        // 竖直方向
        for (int i = border; i < rows; i++)
        {
            for (int j = border; j < cols; j++)
            {
                double sum[3] = { 0 };
                for (int k = -border; k <= border; k++)
                {
                    if (channels == 1)
                    {
                        sum[0] += matrix[border + k] * dst.at<uchar>(i + k, j); // 列不变,行变化;竖直方向的卷积
                    }
                    else if (channels == 3)
                    {
                        Vec3b rgb = dst.at<Vec3b>(i + k, j);
                        sum[0] += matrix[border + k] * rgb[0];
                        sum[1] += matrix[border + k] * rgb[1];
                        sum[2] += matrix[border + k] * rgb[2];
                    }
                }
                for (int k = 0; k < channels; k++)
                {
                    if (sum[k] < 0)
                        sum[k] = 0;
                    else if (sum[k] > 255)
                        sum[k] = 255;
                }
                if (channels == 1)
                    dst.at<uchar>(i, j) = static_cast<uchar>(sum[0]);
                else if (channels == 3)
                {
                    Vec3b rgb = { static_cast<uchar>(sum[0]), static_cast<uchar>(sum[1]), static_cast<uchar>(sum[2]) };
                    dst.at<Vec3b>(i, j) = rgb;
                }
            }
        }
        delete[] matrix;
    }

    代码没有重构较长,不过其实现原理是比较简单的。首先得到一维高斯函数的模板,在卷积(滤波)的过程中,保持行不变,列变化,在水平方向上做卷积运算;接着在上述得到的结果上,保持列不边,行变化,在竖直方向上做卷积运算。这样分解开来,算法的时间复杂度为O(ksize)O(ksize),运算量和滤波器的模板尺寸呈线性增长。

    在OpenCV也有对高斯滤波器的封装GaussianBlur,其声明如下:

    CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,
                                    double sigmaX, double sigmaY = 0,
                                    int borderType = BORDER_DEFAULT );

    二维高斯函数的标准差在x和y方向上应该分别有一个标准差,在上面的代码中一直设其在x和y方向的标准是相等的,在OpenCV中的高斯滤波器中,可以在x和y方向上设置不同的标准差。

    下图是自己实现的高斯滤波器和OpenCV中的GaussianBlur的结果对比

    61389169745044b84a0907876e06db3b.png

    上图是5×5,σ=0.8的高斯滤波器,可以看出两个实现得到的结果没有很大的区别。

    总结

    高斯滤波器是一种线性平滑滤波器,其滤波器的模板是对二维高斯函数离散得到。由于高斯模板的中心值最大,四周逐渐减小,其滤波后的结果相对于均值滤波器来说更好。

    高斯滤波器最重要的参数就是高斯分布的标准差σσ,标准差和高斯滤波器的平滑能力有很大的能力,σσ越大,高斯滤波器的频带就较宽,对图像的平滑程度就越好。通过调节σσ参数,可以平衡对图像的噪声的抑制和对图像的模糊。

    展开全文
  • matlab版本 #include using namespace std; int gaussian(double **gaus, const int size, const double sigma); int main() { int size = 4; double **gaus = new double *[size]; for (int i = 0; i ; i+...

    c++版本

    #include <iostream>
    using namespace std;
    int gaussian(double **gaus, const int size, const double sigma);
    int main()
    {
    	int size = 4;
    	double **gaus = new double *[size];
    	for (int i = 0; i < size; i++) {
    		gaus[i] = new double[size];  //生成动态矩阵
    	}
    	gaussian(gaus,4, 1);
    	return 0;
    	 
    }
    int gaussian(double **gaus, const int size, const double sigma)
    {
    	const double PI = 4*atan(1.0);
    	double radius;
    	double center = (size+1) / 2;
    	double sum = 0;
    	for (int i = 0; i < size; i++)
    	{
    		for (int j = 0; j < size; j++) {
    			radius = ((i + 1 - center)*(i + 1 - center) + (j + 1 - center)*(j + 1 - center));
    			gaus[i][j] = (1/(2 * PI *sigma*sigma))* exp(-(radius / (2 * sigma*sigma)));
    			sum += gaus[i][j];
    		}
    	}
    	cout << sum << endl;
    	for (int i = 0; i < size; i++) {
    		for (int j = 0; j < size; j++) {
    			gaus[i][j] /= sum;
    			cout << gaus[i][j] << "	  ";
    		}
    		cout << endl;
    	}
    	return 0;
    }

    matlab版本

    #include <iostream>
    using namespace std;
    int gaussian(double **gaus, const int size, const double sigma);
    int main()
    {
    	int size = 4;
    	double **gaus = new double *[size];
    	for (int i = 0; i < size; i++) {
    		gaus[i] = new double[size];  //生成动态矩阵
    	}
    	gaussian(gaus,4, 1);
    	return 0;
    	 
    }
    int gaussian(double **gaus, const int size, const double sigma)
    {
    	const double PI = 4*atan(1.0);
    	double radius;
    	double center = (size+1) / 2;
    	double sum = 0;
    	for (int i = 0; i < size; i++)
    	{
    		for (int j = 0; j < size; j++) {
    			radius = ((i + 1 - center)*(i + 1 - center) + (j + 1 - center)*(j + 1 - center));
    			gaus[i][j] = (1/(2 * PI *sigma*sigma))* exp(-(radius / (2 * sigma*sigma)));
    			sum += gaus[i][j];
    		}
    	}
    	cout << sum << endl;
    	for (int i = 0; i < size; i++) {
    		for (int j = 0; j < size; j++) {
    			gaus[i][j] /= sum;
    			cout << gaus[i][j] << "	  ";
    		}
    		cout << endl;
    	}
    	return 0;
    }

     

    展开全文
  • 高斯差分滤波器 matlab

    热门讨论 2012-05-03 16:54:39
    这是高斯差分滤波器matlab实现
  • 几种常见空间滤波器MATLAB实现

    万次阅读 多人点赞 2018-05-24 20:47:22
    一、目的实现算术均值滤波器、几何均值滤波器、中值滤波器、修正的阿尔法均值滤波器、自适应中值滤波器,并比较不同滤波器的降噪结果。二、代码代码的思路如下:(1)先对原始的电路图先后进行加高斯噪声和椒盐噪声...


    一、目的

    实现算术均值滤波器、几何均值滤波器、中值滤波器、修正的阿尔法均值滤波器、自适应中值滤波器,并比较不同滤波器的降噪结果。

    二、代码

    代码的思路如下:

    (1)先对原始的电路图先后进行加高斯噪声和椒盐噪声;之后设置滤波器的模板大小为5*5,分别对被噪声污染的图像进行算术均值、几何均值、中值、修正的阿尔法滤波,并输出图像,方便结果比较。

    (2)为了比较中值滤波器和自适应中值滤波器的滤波结果,先对原始电路图添加椒盐噪声;接着对噪声图像进行模板大小为5*5的中值滤波;最后对噪声图像进行最大模板为5*5的自适应中值滤波,分别输出滤波后的图像,比较结果。

    代码具体实现如下:

    %******************************************************%
    %目的:比较几种不同均值滤波器和自适应中值滤波器的去噪声效果
    %日期:2018.5.18
    %******************************************************%
    
    %读入图像
    img = imread('img.tif');
    figure;
    subplot(1,3,1);
    imshow(img);
    title('原始图像');
    %分别添加加入高斯噪声和椒盐噪声
    f1 = imnoise(img,'gaussian');
    subplot(1,3,2)
    imshow(f1);
    title('添加高斯噪声');
    f2 = imnoise(f1,'salt & pepper');
    subplot(1,3,3)
    imshow(f2);
    title('再添加椒盐噪声');
    f2 = double(f2);
    [M,N] = size(f2);
    
    %%%%比较几种均值滤波器及中值滤波器的滤波结果%%%%%%
    %算术均值滤波器
    n = 5; %模板大小
    f11 = f2;
    for i = 1:M-n+1
        for j = 1:N-n+1
            g1 = f2(i:i+n-1,j:j+n-1);
            s1 = sum(sum(g1));
            %中心点的值用子图像的算术均值代替
            f11(i+(n-1)/2,j+(n-1)/2) = s1/(n*n); 
        end
    end
    img1 = uint8(f11);
    figure;
    subplot(1,2,1);
    imshow(img1);
    title('算术均值滤波结果');
    
    %几何均值滤波器
    n = 5; %模板大小
    f21 = f2 + ones(M,N); %防止有个像素点为0而导致乘积为0
    f12 = f21;
    for i = 1:M-n+1
        for j = 1:N-n+1
            g2 = f21(i:i+n-1,j:j+n-1);
            s2 = prod(g2(:));
            %中心点的值用子图像的几何均值代替
            f12(i+(n-1)/2,j+(n-1)/2) = s2.^(1/numel(g2)); 
        end
    end
    img2 = uint8(f12);
    subplot(1,2,2);
    imshow(img2);
    title('几何均值滤波结果');
    
    %中值滤波器
    img3 = uint8(medfilt2(f2,[5 5]));
    figure;
    subplot(1,2,1);
    imshow(img3);
    title('中值滤波结果');
    
    %修正的阿尔法均值滤波器
    n = 5; %模板大小
    d = 5; %去掉最值灰度值的个数
    f13 = f2;
    for i = 1:M-n+1
        for j = 1:N-n+1
            g3 = f2(i:i+n-1,j:j+n-1);
            g3 = sort(g3(:)); %对邻域内的像素点进行排序
            min_num = ceil(d/2); %去掉最小灰度值的个数
            max_num = floor(d/2); %去掉最大灰度值的个数
            %去掉d个最值灰度级后求算术均值
            g3(1:min_num) = zeros(min_num,1);
            g3(n-max_num+1:n) = zeros(max_num,1);
            s3 = sum(g3);
            %中心点的值用子图像的算术均值代替
            f13(i+(n-1)/2,j+(n-1)/2) = s3/(n*n-d); 
        end
    end
    img4 = uint8(f13);
    subplot(1,2,2);
    imshow(img4);
    title('修正的阿尔法均值滤波结果');
    
    
    %%%%%%%比较中值滤波器及自适应中值滤波器的滤波结果%%%%%%%
    f2 = imnoise(img,'salt & pepper');
    figure;
    subplot(1,4,1);
    imshow(img);
    title('原图');
    subplot(1,4,2);
    imshow(f2);
    title('添加椒盐噪声的图像');
    
    %中值滤波器
    img5 = uint8(medfilt2(f2,[5 5]));
    subplot(1,4,3);
    imshow(img5);
    title('中值滤波结果');
    
    %自适应中值滤波器
    f14 = f2;  
    alreadyPro = false(size(f2)); %看是否完成进程
    Smax=5;       %最大窗口尺寸
    for s = 3:2:Smax    %起始窗口尺寸设为3
       %得到特定的灰度值
       zmin = ordfilt2(f2, 1, ones(s, s), 'symmetric');  
       zmax = ordfilt2(f2, s * s, ones(s, s), 'symmetric');  
       zmed = medfilt2(f2, [s s], 'symmetric');  
       %进程B
       processB = (zmed > zmin) & (zmax > zmed) & ~alreadyPro;   
       %进程A
       processA = (f2 > zmin) & (zmax > f2);  
       outZxy  = processB & processA;  
       outZmed = processB & ~processA;  
       f14(outZxy) = f2(outZxy);  
       f14(outZmed) = zmed(outZmed);   
       alreadyPro = alreadyPro | processB;  
       if all(alreadyPro(:))  
          break;  
       end  
    end  
    f14(~alreadyPro) = zmed(~alreadyPro);  
    img6 = uint8(f14);
    subplot(1,4,4);
    imshow(img6);
    title('自适应中值滤波结果');
    

    三、结果分析

    得到的结果如下:





     由滤波结果,我们可以看出,对于添加了高斯噪声和椒盐噪声的图像,算术均值和几何均值滤波器的效果比较差,尤其是几何均值滤波器;而中值滤波器和修正后的阿尔法均值滤波器的降噪效果比前面两种滤波器的效果要好很多,修正的阿尔法均值滤波器的效果最好,使图像变得更平滑。中值滤波器和自适应中值滤波器进行比较,两者的降噪效果都不错,不过中值滤波器导致了原始图像细节的丢失,而自适应中值滤波器则很好地保持了原始图像的清晰度和细节。


    展开全文
  • C++实现高斯滤波器

    2014-03-31 16:58:00
    matlab中,我们经常用到高斯滤波器,生成滤波器一般都是这样的函数psf= fspecial('gauss', GaussSize, sigma),但是在vs2010中用到的高斯滤波器不能自己直接定义一个滤波器,所以我就用c++与OPENCV的mat类实现了...

      在matlab中,我们经常用到高斯滤波器,生成滤波器一般都是这样的函数psf =   fspecial('gauss', GaussSize, sigma),但是在vs2010中用到的高斯滤波器不能自己直接定义一个滤波器,所以我就用c++与OPENCV的mat类实现了高斯滤波器,具体代码如下:

      

    #include"opencv24.h"
    using namespace std;
    Mat MakeGaussFilt(int GauSize, double Sigma)
    {
        double siz = (GauSize-1.0)/2;
        Mat x = Mat(GauSize,GauSize,CV_64F);
        Mat y = Mat(GauSize,GauSize,CV_64F);
        for (int i=0;i<GauSize;i++)
        {
            x.col(i)=double(i-siz);
            y.row(i)=double(i-siz);
        }
        Mat argu = Mat(GauSize,GauSize,CV_64F);
        Mat x2=x.mul(x);
        Mat y2=y.mul(y);
        argu = -(x2+y2)/(2*Sigma*Sigma);
        Mat h = Mat(GauSize,GauSize,CV_64F);
        exp(argu,h);
        Scalar sumh=sum(h);
        double summ=sumh.val[0];
        h=h/summ;
        return h;
    }

     

     

    其中Mat类用到了OPENCV库,自己要在VS上进行库的导入,函数经过亲测,可行。

    转载于:https://www.cnblogs.com/mu-tou-man/p/3636147.html

    展开全文
  • 智慧石资源:
  • matlab实现高斯粒子滤波器代码

    热门讨论 2010-06-28 10:18:55
    matlab实现高斯粒子滤波器,很好,很有参考价值。
  • 低通滤波器 一、理想低通滤波器(ILPF) 1.1 理想低通滤波器介绍 1.2 理想低通滤波器Matlab实现 1.3 理想低通滤波器的... 3.2 高斯低通滤波器Matlab实现 3.3 高斯低通滤波器的实现结果 总结 一.
  • 高斯滤波器matlab实现,不是matlab自带的函数。 高斯滤波器matlab实现,不是matlab自带的函数。
  • MATLAB--高斯低通滤波器实现

    千次阅读 2020-04-06 16:25:53
    高斯低通滤波器函数 function [image_out] = GLPF(image_in,D0) %GLPF为高斯低通滤波器,D0为截止频率 %输入为需要进行高斯低通滤波的灰度图像,输出为经过滤波之后的灰度图像 f=image_in; f=im2double(f); % 1、...
  • 一般来说,如果您真的关心如何获得与MATLAB完全相同的结果,最简单的方法就是直接查看MATLAB函数的源代码.在这种情况下,编辑fspecial:...case 'gaussian' % Gaussian filtersiz = (p2-1)/2;std = p3;[x,y] = meshgrid...
  • 前言:粒子滤波器相较于卡尔曼滤波器或者UKF无迹卡尔曼滤波器而言,可以表达强非线性的变换且无需假设后验分布为高斯分布,在描述多峰分布时具有非常大的优势。粒子滤波器被广泛的应用于机器人系统中,如著名的...
  • matlab实现的2D高斯带通滤波器,支持2D时间序列滤波。
  • 双边滤波器—— Matlab实现

    千次阅读 2018-04-25 22:26:06
    双边滤波的特点是保边去噪,相较于高斯滤波,在平滑图像的同时,增加了对图像边缘的保护,其主要原因是由于该滤波器由两部分组成,一部分与像素空间距离相关,另一部分与像素点的像素差值相关。 下面结合公式来说说...
  • 我有一个关于高斯低通滤波器的问题, 在许多的博客上(同样的情况在matlab的fspecial函数中),产生空间域滤波器 使用的公式都是A*exp(-u/(2*sigma^2)),之后再进行了归一化。但是这个公式不是高斯函数在频域域中的...
  • 关于高斯滤波器的一些疑问

    千次阅读 2016-01-30 17:42:02
    我有一个关于高斯低通滤波器的问题, 在许多的博客上(同样的情况在matlab的fspecial函数中),产生空间域滤波器 使用的公式都是A*exp(-u/(2*sigma^2)),之后再进行了归一化。但是这个公式不是高斯函数在频域域中的...
  • 高斯滤波器使用模块确定的领域内像素的加权平均值代替图像中的每个像素的值,这种处理的降低了图像灰度的剧烈变化,由于典型的随机噪声表现为灰度的急剧变化,因此,使用这种加权平均的滤波器的结果就是降低噪声,...
  • 实现方式可以分为:LC滤波器、声表面波/体声波滤波器、螺旋滤波器、介质滤波器、腔体滤波器、高温超导滤波器、平面结构滤波器。按不同的频率响应函数可以分为:切比雪夫、广义切比雪夫、巴特沃斯、高斯...
  • 双边滤波器原理及Matlab实现

    万次阅读 2017-08-30 17:11:58
    双边滤波器是什么? 双边滤波(Bilateral filter)是一种可以保边去噪的...可以与其相比较的两个filter:高斯低通滤波器(http://en.wikipedia.org/wiki/Gaussian_filter)和α-截尾均值滤波器(去掉百分率为α的最小
  • 该程序是在matlab实现的,主要用于图像的高斯低通滤波。
  • 双边滤波器原理及其matlab实现

    千次阅读 2017-08-21 23:34:07
    之前做过图像细节增强方面的工作,处理的是红外灰度14bit图像,图像信号由14bit AD...  双边滤波的特点是保边去噪,相较于高斯滤波,在平滑图像的同时,增加了对图像边缘的保护,其主要原因是由于该滤波器由两部分组
  • 使用Matlab实现美颜功能(双边滤波器

    千次阅读 热门讨论 2020-04-14 23:43:01
    使用Matlab实现美颜功能(双边滤波器) 先晒美颜效果 借用一张lena小姐的图 题外话 lena小姐的全图真的 sex 可以看出美颜效果还是明显的,下面进行过程实现 基本原理 保留边界细节,模糊变化不明显的区域 我们知道...
  • 四 使用高斯滤波器进行图像的平滑 ()高斯简介 http://research.microsoft.com/en-us/um/people/kahe/eccv10/何凯明 matlab 实现 http://www.ruanyifeng.com/blog/2012/11/gaussian_blur.html 阮一峰 ...
  • 图像滤波—高斯滤波——MATLAB实现

    千次阅读 2017-06-20 11:19:03
    产生对应的3*3滤波器模板;σ为标准差。 函数fspecial(‘gaussian’,5,4.5);产生一个σ=4.5的5*5滤波模板。 创建时用 返回模板为: %图像滤波-高斯滤波 close clear all; img=imread(‘sophie.jpg’
  • 依据评估结果,指导工程设计实现。在实际工程中,高斯白噪声的不相关性并一定能够很好近似反映实际使用的噪声环境。这会使得利用高斯白噪声获得的性能评估结果通常是实际工程问题的过估计。本节将从接收通道的噪声...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 144
精华内容 57
关键字:

高斯滤波器matlab实现

matlab 订阅