OpenCV 高斯模糊

最新推荐文章于 2024-08-24 00:28:01 发布
最新推荐文章于 2024-08-24 00:28:01 发布
阅读量7.9k 收藏 7
点赞数
分类专栏： OpenCV学习 OpenCV入门学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanggusheng/article/details/88847637
版权

高斯滤波器能够有效的抑制噪声，平滑图像。高斯滤波器相比于均值滤波器对图像个模糊程度较小。

高斯公式

matlab代码

clear;
a=0;sigma=0.8; 
x=-10:0.0001:10;
figure(1)
y=(1/((sqrt(2*pi))*sigma))*exp(-((x-a).^2)/(2*sigma.^2));
plot(x,y,'b','LineWidth',1.5);
hold on;
sigma=1.1
y=(1/((sqrt(2*pi))*sigma))*exp(-((x-a).^2)/(2*sigma.^2));
plot(x,y,'r','LineWidth',1.5);
legend('sigma = 0.8','sigma = 1.1')

从函数的结果来看，sigma值越大，曲线越“胖”；sigma值越小，曲线越“瘦”；对图像过滤来说，sigma值越大，滤波器中心点的权重也就越大，图像也就没有那么模糊。看一下代码原型和实例 

OpenCV高斯函数原型即部分源码解析

函数原型为

//_src _IN_ 输入的源影像
//_dst _OUT_ 输出的目标影像
//kSize 核大小 如果大小为负数的话，那么根据输入的sigma进行计算
//ksize 大小可以为1，3，5，7，最大值为7
//计算的公式为 sigma = 0.3\*((ksize - 1)\*0.5 - 1) + 0.8
//sigmal1 X方向上的sigma值
//sigmal2 Y方向上的sigma值
//如果sigmal值为负数的话，那么使用默认的滤波过滤器
void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
                   double sigma1, double sigma2,
                   int borderType )

 部分函数解析

void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
                   double sigma1, double sigma2,
                   int borderType )
{
    int type = _src.type();//获取通道类型 CV_8UC3 CV_8UC1...
    Size size = _src.size();//获取影像的大小 宽度和高度
    _dst.create( size, type );//创建目标影像，和源影像的大小和类型是相同的

	//borderType 边界类型参照的博客
	//https://blog.csdn.net/zhanggusheng/article/details/70197051
    if( borderType != BORDER_CONSTANT && (borderType & BORDER_ISOLATED) != 0 )
    {
        if( size.height == 1 )
            ksize.height = 1;
        if( size.width == 1 )
            ksize.width = 1;
    }

	//如果内核的宽度和高度都是1的话，那么源影像和目标影像是相同的
    if( ksize.width == 1 && ksize.height == 1 )
    {
        _src.copyTo(_dst);
        return;
    }

#ifdef HAVE_TEGRA_OPTIMIZATION
    Mat src = _src.getMat();
    Mat dst = _dst.getMat();
    if(sigma1 == 0 && sigma2 == 0 && tegra::useTegra() && tegra::gaussian(src, dst, ksize, borderType))
        return;
#endif

#if IPP_VERSION_X100 >= 801 && 0 // these functions are slower in IPP 8.1
    CV_IPP_CHECK()
    {
        int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);

        if ((depth == CV_8U || depth == CV_16U || depth == CV_16S || depth == CV_32F) && (cn == 1 || cn == 3) &&
                sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 )
        {
            IppiBorderType ippBorder = ippiGetBorderType(borderType);
            if (ippBorderConst == ippBorder || ippBorderRepl == ippBorder)
            {
                Mat src = _src.getMat(), dst = _dst.getMat();
                IppiSize roiSize = { src.cols, src.rows };
                IppDataType dataType = ippiGetDataType(depth);
                Ipp32s specSize = 0, bufferSize = 0;

                if (ippiFilterGaussianGetBufferSize(roiSize, (Ipp32u)ksize.width, dataType, cn, &specSize, &bufferSize) >= 0)
                {
                    IppFilterGaussianSpec * pSpec = (IppFilterGaussianSpec *)ippMalloc(specSize);
                    Ipp8u * pBuffer = (Ipp8u*)ippMalloc(bufferSize);

                    if (ippiFilterGaussianInit(roiSize, (Ipp32u)ksize.width, (Ipp32f)sigma1, ippBorder, dataType, 1, pSpec, pBuffer) >= 0)
                    {
#define IPP_FILTER_GAUSS(ippfavor, ippcn) \
        do \
        { \
            typedef Ipp##ippfavor ippType; \
            ippType borderValues[] = { 0, 0, 0 }; \
            IppStatus status = ippcn == 1 ? \
                ippiFilterGaussianBorder_##ippfavor##_C1R(src.ptr<ippType>(), (int)src.step, \
                    dst.ptr<ippType>(), (int)dst.step, roiSize, borderValues[0], pSpec, pBuffer) : \
                ippiFilterGaussianBorder_##ippfavor##_C3R(src.ptr<ippType>(), (int)src.step, \
                    dst.ptr<ippType>(), (int)dst.step, roiSize, borderValues, pSpec, pBuffer); \
            ippFree(pBuffer); \
            ippFree(pSpec); \
            if (status >= 0) \
            { \
                CV_IMPL_ADD(CV_IMPL_IPP); \
                return; \
            } \
        } while ((void)0, 0)

                        if (type == CV_8UC1)
                            IPP_FILTER_GAUSS(8u, 1);
                        else if (type == CV_8UC3)
                            IPP_FILTER_GAUSS(8u, 3);
                        else if (type == CV_16UC1)
                            IPP_FILTER_GAUSS(16u, 1);
                        else if (type == CV_16UC3)
                            IPP_FILTER_GAUSS(16u, 3);
                        else if (type == CV_16SC1)
                            IPP_FILTER_GAUSS(16s, 1);
                        else if (type == CV_16SC3)
                            IPP_FILTER_GAUSS(16s, 3);
                        else if (type == CV_32FC1)
                            IPP_FILTER_GAUSS(32f, 1);
                        else if (type == CV_32FC3)
                            IPP_FILTER_GAUSS(32f, 3);
#undef IPP_FILTER_GAUSS
                    }
                }
                setIppErrorStatus();
            }
        }
    }
#endif
	//创建高斯内核函数
    Mat kx, ky;
	//创建高斯内核函数
    createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2);
	//_src是源影像
	//_dst是目标影像
	//CV_MAT_DEPTH(type) 是CV_8U或者CV_16U
	//kx是滤波内核
	//ky是滤波内核
	//
    sepFilter2D(_src, _dst, CV_MAT_DEPTH(type), kx, ky, Point(-1,-1), 0, borderType );
}
static void createGaussianKernels( Mat & kx, Mat & ky, int type, Size ksize,
                                   double sigma1, double sigma2 )
{
    int depth = CV_MAT_DEPTH(type);//获取影像的深度 CV_8U、CV_16U...
    if( sigma2 <= 0 )
        sigma2 = sigma1;//如果sigma2小于0的话，那么sigma2和sigma相同

    // automatic detection of kernel size from sigma
	//自动决定sigma的大小
    if( ksize.width <= 0 && sigma1 > 0 )//如果内核的宽度小于0并且sigma1大于的0的话
		//如果数据类型为CV_8U的话 那么宽度大小为
		//(sigmal*3*2+1)|1 
		//'|'的操作原因是内核的宽度必须是奇数
        ksize.width = cvRound(sigma1*(depth == CV_8U ? 3 : 4)*2 + 1)|1;
    if( ksize.height <= 0 && sigma2 > 0 )//和内核的宽度获取是相同的
        ksize.height = cvRound(sigma2*(depth == CV_8U ? 3 : 4)*2 + 1)|1;

	//内核的宽度必须大于0，并且是奇数的。
	//内核的高度也是相同的
    CV_Assert( ksize.width > 0 && ksize.width % 2 == 1 &&
        ksize.height > 0 && ksize.height % 2 == 1 );

	//sigma值是大于等于0的
    sigma1 = std::max( sigma1, 0. );
    sigma2 = std::max( sigma2, 0. );

	//获取x方向的高斯内核
    kx = getGaussianKernel( ksize.width, sigma1, std::max(depth, CV_32F) );
	//如果内核的宽度和高度相同，并且sigma1和sigma2几乎相同的话，那么就是使用x方向的内核
    if( ksize.height == ksize.width && std::abs(sigma1 - sigma2) < DBL_EPSILON )
        ky = kx;
    else
        ky = getGaussianKernel( ksize.height, sigma2, std::max(depth, CV_32F) );
}
cv::Mat cv::getGaussianKernel( int n, double sigma, int ktype )
{
    const int SMALL_GAUSSIAN_SIZE = 7;
    static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =
    {
        {1.f},//内核大小为1
        {0.25f, 0.5f, 0.25f},//内核大小为3
        {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},//内核大小为5
        {0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}//内核大小为7
    };

	//如果sigma小于0的话，那么内核数组规则为
	//1、奇数
	//2、小于等于7
	//3、sigma 小于等于0
	//n>>1 就是n/2
    const float* fixed_kernel = n % 2 == 1 && n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 ?
        small_gaussian_tab[n>>1] : 0;

	//断言，数据类型必须为CV_32F 或者CV_64F,也就是float或者double类型
    CV_Assert( ktype == CV_32F || ktype == CV_64F );
	//内核矩阵为n行1列
    Mat kernel(n, 1, ktype);
	//获取内核数据的指针，分别指向float或者double类型
    float* cf = kernel.ptr<float>();
    double* cd = kernel.ptr<double>();

	//如果sigma是大于0的话，就是sigma的大小
	//如果sigma小于等于0的话，就是默认的大小

    double sigmaX = sigma > 0 ? sigma : ((n-1)*0.5 - 1)*0.3 + 0.8;
	//-sigma *sigmma/2
    double scale2X = -0.5/(sigmaX*sigmaX);
	//求和，是为了进行归一化处理
    double sum = 0;

    int i;

    for( i = 0; i < n; i++ )
    {
        double x = i - (n-1)*0.5;//例子如果n为3的话，那么x的值分别为-1、0、1。如果是5的话，那么x的值为-2，-1，0，1，2
        double t = fixed_kernel ? (double)fixed_kernel[i] : std::exp(scale2X*x*x);
        if( ktype == CV_32F )
        {
            cf[i] = (float)t;
            sum += cf[i];
        }
        else
        {
            cd[i] = t;
            sum += cd[i];
        }
    }

    sum = 1./sum;
    for( i = 0; i < n; i++ )
    {
        if( ktype == CV_32F )
            cf[i] = (float)(cf[i]*sum);
        else
            cd[i] *= sum;
    }

    return kernel;
}

 

 

 

//包含OpenCV的头文件
//参照github https://github.com/yoyoyo-yo/Gasyori100knock 
#include <opencv2/opencv.hpp>
#include <iostream>
using namespace  std;
//使用OpenCV的命名空间
using namespace cv;
//
//频道改变
int main()
{
	//读取源影像
	Mat Src = imread("C:/Users/GuSheng/Desktop/标准测试图片/Fig0638(a)(lenna_RGB).tif", IMREAD_COLOR);
	if (Src.empty())
	{
		return 0;
	}
	//创建目标影像,影像格式、大小和源影像相同
	//sigma = 0.8
	Mat Dst1 = Mat(Src.size(), Src.type());
	//sigma = 1.5
	Mat Dst2 = Mat(Src.size(), Src.type());
	//创建目标影像失败
	if (Dst1.empty() || Dst2.empty())
	{
		return 0;
	}
	GaussianBlur(Src, Dst1, cv::Size(5, 5), 0.8,0.8);
	GaussianBlur(Src, Dst2, cv::Size(5, 5), 1.5, 1.5);
	namedWindow("Src", WINDOW_AUTOSIZE);
	namedWindow("Dst sigma = 0.8", WINDOW_AUTOSIZE);
	namedWindow("Dst sigma = 1.5", WINDOW_AUTOSIZE);
	imshow("Src", Src);
	imshow("Dst sigma = 0.8", Dst1);
	imshow("Dst sigma = 1.5", Dst2);
	waitKey(0);
	return 0;
}
源影像

                               

sigma = 0.8
sigma = 1.5
zhanggusheng
关注
专栏目录
differenceOfGaussia​nFilter:differenceOfGaussianFilter() 在 2D (DoG) 中创建高斯通道滤波器的差异-matlab开发
05-29
使用示例： L=differenceOfGaussianFilter(); % 使用默认参数生成通道过滤器L=differenceOfGaussianFilter(imgSize); % 使用默认参数以给定的图像大小（作为 2D 矢量）生成通道过滤器L=differenceOfGaussianFilter(imgSize,N,std0,alpha,Q); % 以给定的图像大小（作为 2D 向量）和 std0、alpha 和 Q 的指定值生成 N 通道过滤器
卷积法求解光斑质心（附源码，C++、opencv）
Mrweng1996的博客
11-12 2695
1、求解步骤 第一步，初始化一个高斯模板： Mat GuassTemplate = (Mat_<uchar>(3, 3) << 1, 2, 1, 2, 4, 2, 1, 2, 1); //高斯核 第二步，将高斯模板与图像进行卷积，并将卷积结果存储到另一个矩阵Mat中，这个过程类似于高斯滤波： //进行卷积运算 double value = 0; for (i...
[OpenCV] 数字图像处理 C++ 学习——07图像模糊 附完整代码（小白入门篇）
最新发布
m0_60437290的博客
08-24 1037
图像模糊是图像处理中非常常见的操作之一，用于减少图像中的噪声和细节，使图像看起来更加平滑。OpenCV 提供了多种模糊技术，如均值模糊、高斯模糊、中值模糊和双边滤波等。本篇博客将介绍几种常用的图像模糊方法，并通过代码示例演示如何在 OpenCV 中实现这些方法，最后附上完整代码以便学习使用。
【OpenCV4】高斯滤波 cv::GaussianBlur() 用法详解和代码示例（c++）
AItrust的博客
08-15 6863
根据高斯分布公式，和滤波器所覆盖像素距离中心的距离，就可以计算每个像素被滤波后的像素值，即执行了一个卷积操作。可以看到，kernel 越大，去除噪声（平滑）的效果越明显，但同时，图像也会越模糊！高斯滤波考虑了像素离开滤波器中心的距离影响，中心位置为高斯分布均值，比如上图为 0。图像采集过程中，常常会引入高斯噪声，即这是一种按照高斯曲线进行分布的噪声。所以使用高斯滤波来进行图像去噪。...
opencv线性滤波：方框滤波，均值滤波，高斯滤波
u011863319的博客
03-29 247
学习浅墨大佬：教程 函数调用： #include "ep_19.h" using namespace std; using namespace cv; void ep_19() { /*方框滤波 *第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。 第二个参数，OutputArray类型的dst
Intel IPP图像库手册函数概述
Lce的专栏
11-02 3461
ippiYCbCr420ToBGR_709CSC_8u_P3C3R: 将图像从YCbCr420空间转换BGR空间,ITU-RBT.709 CSC信号。ippiBGRToYCrCb420_709CSC_8u_AC4P3R: 将图像从YCbCr空间转换BGR空间,ITU-RBT.709 CSC信号。ippiYCbCrToBGR_709CSC_8u_P3C3R: 将图像从YCbCr空间转换BGR空间,ITU-RBT.709 CSC信号。
基于Android的OpenCV图片高斯模糊的实现
02-28
OpenCV是一个基于Apache2.0许可（开源）发行的跨平台计算机视觉和机器学习软件库，网络上一些小伙伴写的一些关于Android版OpenCV的博客，大部分都模糊不清，基本就复制粘贴的，有些甚至没有实践就直接贴上去了，这样...
OpenCV高斯滤波源码
04-17
本篇将详细探讨"OpenCV高斯滤波源码"这一主题，以及如何使用OpenCV来实现图片的高斯滤波，以达到均值滤波降噪的效果。 高斯滤波是一种基于统计学的图像平滑方法，它通过应用一个高斯函数作为权重对图像进行卷积，以...
高斯模糊 opencv实现
02-11
OpenCV是一个强大的开源计算机视觉库，它提供了多种功能来处理图像和视频，包括实现高斯模糊。在这个场景中，我们将深入探讨如何使用OpenCV 2.0来实现高斯模糊，以及其背后的原理和应用。 高斯模糊是基于高斯函数的...
android高斯模糊
06-22
可以使用OpenCV库，它提供了现成的高斯模糊函数，如`cv::GaussianBlur()`，也可以自定义算法。 3. **内存管理**：注意Java与C/C++之间Bitmap数据的传递，通常需要将Bitmap数据复制到native内存空间，然后在C/C++中...
gaosimohu.rar_week8jv_基于opencv的高斯模糊的实现
09-21
在本项目"gaosimohu.rar_week8jv_基于opencv的高斯模糊的实现"中，我们主要探讨的是如何使用OpenCV库在Java环境下实现图像处理中的高斯模糊操作。OpenCV是一个强大的计算机视觉库，广泛应用于图像处理、机器学习以及...
高斯平滑 高斯模糊 高斯滤波器 ( Gaussian Smoothing, Gaussian Blur, Gaussian Filter ) C++ 实现
lphbtm的专栏
03-23 1万+
发展到现在这个平滑算法的时候, 我已经完全不知道如何去命名这篇文章了, 只好罗列出一些关键字来方便搜索了. 在之前我们提到过了均值滤波器, 就是说某像素的颜色, 由以其为中心的九宫格的像素平均值来决定. 在这个基础上又发展成了带权的平均滤波器, 这里的高斯平滑或者说滤波器就是这样一种带权的平均滤波器. 那么这些权重如何分布呢? 我们先来看几个经典的模板例子: 尝试了使用
最小二乘法及OpenCv函数
小伟锅的博客
10-31 1万+
1.最小二乘法    我们以最简单的一元线性模型来解释最小二乘法。什么是一元线性模型呢？ 监督学习中，如果预测的变量是离散的，我们称其为分类（如决策树，支持向量机等），如果预测的变量是连续的，我们称其为回归。回归分析中，如果只包括一个自变量和一个因变量，且二者的关系可用一条直线近似表示，这种回归分析称为一元线性回归分析。如果回归分析中包括两个或两个以上的自变量，且因变量和自变量之间是线性关系
【第二部分-图像处理】第3章 Opencv图像处理进阶-【1 图像处理A-滤波】（imgproc组件、feature2D组件）
不问归期的博客
11-09 1万+
1.1线性滤波 1.1.1理论与概念讲解 关于平滑处理 “平滑处理“（smoothing）也称“模糊处理”（bluring），是一项简单且使用频率很高的图像处理方法。平滑处理的用途有很多，最常见的是用来减少图像上的噪点或者失真。在涉及到降低图像分辨率时，平滑处理是非常好用的方法。 图像滤波与滤波器 首先我们看一下图像滤波的概念。图像滤波，即在尽量保留图像细节特征的条件下对目标图像的
opencv CvSolve函数深度解析
vine_branches的专栏
10-11 1万+
Opencv CvSolve函数主要是用来求解线性系统Ax=b的方程，X的解。solve函数跟它的算法是一样的，也是用来求解线性系统。         设方程Ax = b.根据有效的方程个数和未知数的个数，可以分为以下3种情况： 1）rank（A） 2) rank（A） =  n  方程个数等于未知数的个数， 方程存在唯一的精确解，解法通常有我们熟悉的消元法，LU分解法 3) rank(
opencv学习——solve()
热门推荐
nienelong3319的博客
06-29 2万+
今天在学习最小二乘法的时候遇到了solve函数，用来解线性方程 A*X=B参考官方文档bool cv::solve(InputArray src1,  InputArray src2,  OutputArray dst,  int flags = DECOMP_LU  )src1 线性系统的左侧（相当于上面的A），src2 线性系统的右侧（相当于上面的B），dst 输出的解决方案（相当于要求解的X...
学习 opencv---(7) 线性邻域滤波专场：方框滤波，均值滤波，高斯滤波
daxi0315的博客
12-29 381
本篇文章中，我们一起仔细探讨了OpenCV图像处理技术中比较热门的图像滤波操作。图像滤波系列文章浅墨准备花两次更新的时间来讲，此为上篇，为大家剖析了“方框滤波”，“均值滤波”，“高斯滤波”三种常见的邻域滤波操作。而作为非线性滤波的“中值滤波”和“双边滤波”，我们下次再分析。 因为文章很长，如果详细啃的话，或许会消化不良。在这里给大家一个指引，如果是单单想要掌握这篇文章中讲解的...
CV10 图像模糊（均值、高斯、中值、双边滤波）
yzfzzz的博客
02-16 2629
通过将图像与低通滤波器内核进行2D卷积来实现图像模糊。这对于消除噪音很有用。它实际上从图像中消除了高频部分（例如噪声，边缘）。因此，在此操作中边缘有些模糊。（有一些模糊技术也可以不模糊边缘）。OpenCV主要提供四种类型的模糊技术：均值模糊、高斯模糊、中值模糊和双边滤波模糊。 当我们只想得到感兴趣的物体时，通过图像模糊，可以将那些尺寸和亮度较小的物体过滤掉，较大的物体则易于检测。除了降低噪声，这就是图像平滑（模糊）的另一个重要应用：减少噪点，突出ROI，以便目标提取。 一 均值模糊 理论推导 均值模
opencv高斯模糊
06-01
使用OpenCV实现高斯模糊可以通过调用cv2.GaussianBlur()函数来实现。这个函数具有以下参数： cv2.GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst - src: 输入图像 - ksize: 高斯核的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值