图像像素点赋值_C++ 图像高斯滤波

最新推荐文章于 2023-08-08 20:22:20 发布
最新推荐文章于 2023-08-08 20:22:20 发布
阅读量318 收藏 1
点赞数 1
文章标签： 图像像素点赋值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39566882/article/details/112721683
版权

f905725e77c18d5877b5d1856fb12f57.png

高斯滤波是图像四大滤波之一，四大滤波包括均值滤波，中值滤波，高斯滤波，双边滤波。均值滤波的原理简单直接，就是遍历图像像素点，以当前像素点为中心，将卷积模板内的所有像素点取平均值并设置到当前像素点，虽然也起到了平滑作用，但由于引入了噪声成分，去噪效果不理想，但速度快。高斯滤波的原理是假设像素灰度值成正态分布，以当前像素为中心，离当前像素越远，则占的权重越低。高斯滤波其实也引入了噪声成分。均值滤波和高斯滤波时间复杂度相同。中值滤波则是取卷积模板范围内像素点的中间值，由于每次都需要对卷积模板内的像素值进行排序，所以时间复杂度高，由于中间值基本能排除了噪点，因为噪点的灰度值一般比较突兀，中值滤波去燥效果好，但出来的图像平滑度不高，锯齿现象严重。

二维高斯函数公式：

7cb6e1d9ec5f1e6c80188b261ae43dd2.png

用代码实现该公式：

PI 的计算方式：const double PI = 4.0*std::atan(1.0);

e的x次方我们用std::exp函数进行计算。

算法中我们需要设置sigma的值，即上述公式中的参数,根据sigma值的不同，每个卷积模板的权重也会不同，权重可以用下图形象表示：

96357980c94f03072bda5349144379d6.png

我们先贴一下权重的计算函数：

/**
* @brief 简单概述
* @brief 计算高斯核卷积
* @brief gaus：高斯核卷积(出参)
* @brief k：卷积模板尺寸，3*3，5*5，7*7等
* @brief sigma：权重控制参数
*/
void  CaclGaussianKernel(double *gaus, Kernel k, const double sigma)
{
	//圆周率π赋值
	const double PI = 4.0*std::atan(1.0);
	int center = k /2;
	double param = 1/(2*sigma*sigma);
	double sum = 0;
	int count = 0;
	for (int i = 0; i<k; i++)
	{
		for (int j = 0; j<k; j++)
		{
			gaus[count] = (1/PI*param)*std::exp(-((i-center)*(i-center)+
                                       (j-center)*(j-center))*param);
			sum += gaus[count];
			count++;
		}
	}
	count = 0;
	for (int i = 0; i<k; i++)
	{
		for (int j = 0; j<k; j++)
		{
			gaus[count] /= sum;
			count++;
		}
	}
｝

sigma取值对高斯卷积模板的影响：

对于3*3的卷积矩阵，当sigma=0.1时，卷积模板为：
0.000000,0.000000,0.000000,
0.000000,1.000000,0.000000,
0.000000,0.000000,0.000000,

对于3*3的卷积矩阵，当sigma=0.5时，卷积模板为：
0.011344,0.083820,0.011344,
0.083820,0.619347,0.083820,
0.011344,0.083820,0.011344,

对于3*3的卷积矩阵，当sigma=1.0时，卷积模板为：
0.075114,0.123841,0.075114,
0.123841,0.204180,0.123841,
0.075114,0.123841,0.075114,

对于3*3的卷积矩阵，当sigma=5.0时，卷积模板为：
0.109630,0.111844,0.109630,
0.111844,0.114104,0.111844,
0.109630,0.111844,0.109630,

对于3*3的卷积矩阵，当sigma=10.0时，卷积模板为：
0.110741,0.111296,0.110741,
0.111296,0.111854,0.111296,
0.110741,0.111296,0.110741,

对于9*9的卷积矩阵，当sigma=5.0时，卷积模板为：
0.008386,0.009646,0.010661,0.011320,0.011549,0.011320,0.010661,0.009646,0.008386,
0.009646,0.011096,0.012263,0.013021,0.013284,0.013021,0.012263,0.011096,0.009646,
0.010661,0.012263,0.013553,0.014391,0.014681,0.014391,0.013553,0.012263,0.010661,
0.011320,0.013021,0.014391,0.015281,0.015589,0.015281,0.014391,0.013021,0.011320,
0.011549,0.013284,0.014681,0.015589,0.015904,0.015589,0.014681,0.013284,0.011549,
0.011320,0.013021,0.014391,0.015281,0.015589,0.015281,0.014391,0.013021,0.011320,
0.010661,0.012263,0.013553,0.014391,0.014681,0.014391,0.013553,0.012263,0.010661,
0.009646,0.011096,0.012263,0.013021,0.013284,0.013021,0.012263,0.011096,0.009646,
0.008386,0.009646,0.010661,0.011320,0.011549,0.011320,0.010661,0.009646,0.008386,

由此可见，模板较小时当sigma值大于1时，各个像素的权重值近似，所以对于小卷积核sigma值取值范围
应该设置在0-1之间，对于较大的模板，sigma取值可以大于1。

数据结构定义：

/**
* @brief 简单概述
* @brief 图像格式
*/
enum ImageFormat
{
	IMAGE_BINARY	= 0x0001,	// 二值图像
	IMAGE_GREY	= 0x0008,	// 灰度图像
	IMAGE_RGB	= 0x0018,	// 彩色RGB图像
	IMAGE_BGR	= 0x0019,	// 彩色BGR图像
	IMAGE_RGBA	= 0x0020,	// 彩色RGBA图像
	IMAGE_BGRA	= 0x0021	// 彩色BGRA图像
};

/**
* @brief 简单概述
* @brief 图像数据结构
*/
typedef struct
{
	ImageFormat format;		// 图像格式
	int width;			// 图像宽度
	int height;			// 图像高度
	unsigned long iBufSize;		// 像素数据缓冲区大小
	unsigned char* pBuffer = NULL;	// 像素数据
}Image;

算法声明：

/*****************************************************************************
*  C++ 图像算法
*  Copyright (C) 2020 1158292387@qq.com
*
*  @file
*  @brief    对文件的简单概述
*  Details.
*
*  @author   Leeme
*  @email    1158292387@qq.com
*  @version  1.0.0.1(版本)
*  @date     2020.11.21
*  @license  GNU General Public License (GPL)
*
*----------------------------------------------------------------------------
*  Remark         : Description
*----------------------------------------------------------------------------
*  Change History :
*  <Date>     | <Version> | <Author>       | <Description>
*----------------------------------------------------------------------------
*  2020/10/30 | 1.0.0.1   | Leeme          | Create file
*----------------------------------------------------------------------------
*
*****************************************************************************/
#ifndef ALGORITHM_H
#define ALGORITHM_H

#include "algdef.h"
#include <vector>

/**
* @brief 简单概述
* @brief 单幅图像作为输入的算法基类
*/
class algorithm
{
public:
	algorithm(){}
	~algorithm()
	{
		delete m_Image.pBuffer;
		m_Image.pBuffer = NULL;
	}

	/**
	* @brief 简单概述
	* @brief 设置图像
	*/
	bool SetInputData(const Image& src)
	{
		if (src.pBuffer == NULL || src.width == 0 || src.height == 0)
			return false;

		m_Image.width = src.width;
		m_Image.height = src.height;
		m_Image.format = src.format;
		m_Image.iBufSize = src.iBufSize;
		if (m_Image.pBuffer != NULL)
		{
			delete[]m_Image.pBuffer;
			m_Image.pBuffer = NULL;
		}
		m_Image.pBuffer = new unsigned char[m_Image.iBufSize];
		memcpy(m_Image.pBuffer, src.pBuffer, m_Image.iBufSize);
		return true;
	}

	/**
	* @brief 简单概述
	* @brief 获取图像计算结果
	*/
	bool GetOutputData(Image* src)
	{
		if (m_Image.pBuffer == NULL)
			return false;
		src->width = m_Image.width;
		src->height = m_Image.height;
		src->format = m_Image.format;
		src->iBufSize = m_Image.iBufSize;
		if (src->pBuffer != NULL)
		{
			delete[] src->pBuffer;
			src->pBuffer = NULL;
		}
		src->pBuffer = new unsigned char[m_Image.iBufSize];
		memcpy(src->pBuffer, m_Image.pBuffer, m_Image.iBufSize);
		return true;
	}

	/**
	* @brief 简单概述
	* @brief 设置算法类型
	*/
	virtual bool SetAlgType(int) = 0;
	/**
	* @brief 简单概述
	* @brief 图像算法实现接口
	*/
	virtual bool UpdateData() = 0;

protected:
	Image	m_Image;
};

class IMAGECORE_EXPORT GussianFilter : public algorithm
{
public:
	GussianFilter()
	{
		m_Sigma = 0.0; 
		m_Kernel = K_3X3;
	}
	~GussianFilter(){}

	enum Kernel
	{
		K_3X3 = 0x0003,
		K_5X5 = 0x0005,
		K_7X7 = 0x0007,
		K_9X9 = 0x0009
	};

	/**
	* @brief 简单概述
	* @brief 设置算法类型
	*/
	bool SetAlgType(int type)
	{
		if (type < K_3X3 || type > K_9X9)
			return false;
		m_Kernel = (Kernel)type;
		return true;
	}

	void SetSigma(double s) { m_Sigma = s; }

	/**
	* @brief 简单概述
	* @brief 图像算法实现接口
	*/
	bool UpdateData();

private:
	/**
	* @brief 简单概述
	* @brief 计算高斯卷积核模板
	*/
	void CaclGaussianKernel(double *gaus, Kernel k, const double sigma);

	Kernel m_Kernel;
	double m_Sigma;
};

#endif

算法实现：

/**
* @brief 简单概述
* @brief 图像算法实现接口
*/
bool GussianFilter::UpdateData()
{
	if (m_Image.pBuffer == NULL || m_Image.width == 0 || m_Image.height == 0 || 
                    (m_Sigma-0.0)<0.0001)
		return false;

	short channel = 0;
	if (m_Image.format == IMAGE_RGB || m_Image.format == IMAGE_BGR)
		channel = 3;
	else if (m_Image.format == IMAGE_RGBA || m_Image.format == IMAGE_BGRA)
		channel = 4;
	else
		return false;

	// 计算高斯卷积模板
	double* pK = new double[m_Kernel*m_Kernel];
	this->CaclGaussianKernel(pK, m_Kernel, m_Sigma);

	unsigned char* pData = m_Image.pBuffer;
	unsigned char* pTemp = m_Image.pBuffer;
	short k = m_Kernel / 2;
	for (unsigned long i = 0; i < m_Image.iBufSize; i += channel)
	{
		int x = (i + 1) % (m_Image.width*channel) / channel;
		int y = i / (m_Image.width*channel);
		int total_r = 0;
		int total_g = 0;
		int total_b = 0;
		short count = 0;
		short weight_index = 0;
		for (short m = 0; m < m_Kernel; m++)
		{
			int temp_y = y - k + m;
			if (temp_y >= 0 && temp_y < m_Image.height)
			{
				for (short n = 0; n < m_Kernel; n++)
				{
					int temp_x = x - k + n;
					if (temp_x >= 0 && temp_x < m_Image.width)
					{
						unsigned long fix = temp_y*m_Image.width*
                                                            channel + temp_x*channel;
						pTemp += fix;
						double weight = pK[weight_index];
						short r = ((short)pTemp[0])*weight;
						short g = ((short)pTemp[1])*weight;
						short b = ((short)pTemp[2])*weight;

						total_r += r;
						total_g += g;
						total_b += b;
						count += 1;
						pTemp -= fix;
						weight_index++;
					}
					else
					{
						weight_index++;
					}
				}
			}
			else
			{
				weight_index += m_Kernel;
			}
		}
		pData[0] = (unsigned short)total_r;
		pData[1] = (unsigned short)total_g;
		pData[2] = (unsigned short)total_b;
		pData += channel;
	}
	delete[] pK;
	return true;
}

/**
* @brief 简单概述
* @brief 计算高斯核卷积
* @brief gaus：高斯核卷积(出参)
* @brief k：卷积模板尺寸，3*3，5*5，7*7等
* @brief sigma：权重控制参数
*/
void GussianFilter::CaclGaussianKernel(double *gaus, Kernel k, const double sigma)
{
	//圆周率π赋值
	const double PI = 4.0*std::atan(1.0);
	int center = k /2;
	double param = 1/(2*sigma*sigma);
	double sum = 0;
	int count = 0;
	for (int i = 0; i<k; i++)
	{
		for (int j = 0; j<k; j++)
		{
			gaus[count] = (1/PI*param)*std::exp(-((i-center)*(i-center)+
                                          (j-center)*(j-center))*param);
			sum += gaus[count];
			count++;
		}
	}
	count = 0;
	for (int i = 0; i<k; i++)
	{
		for (int j = 0; j<k; j++)
		{
			gaus[count] /= sum;
			count++;
		}
	}
}

测试代码：

	GussianFilter* mFilter = new GussianFilter();
	mFilter->SetInputData(m_Image);
	mFilter->SetAlgType(GussianFilter::K_3X3);
	mFilter->SetSigma(0.5);
	mFilter->UpdateData();
	mFilter->GetOutputData(&m_Image);

529a68fa1de907253fdc9559440b7320.png

测试代码：

	GussianFilter* mFilter = new GussianFilter();
	mFilter->SetInputData(m_Image);
	mFilter->SetAlgType(GussianFilter::K_5X5);
	mFilter->SetSigma(0.5);
	mFilter->UpdateData();
	mFilter->GetOutputData(&m_Image);

2cb974f8faf17d3181ac08d44a066484.png

测试代码：

	GussianFilter* mFilter = new GussianFilter();
	mFilter->SetInputData(m_Image);
	mFilter->SetAlgType(GussianFilter::K_7X7);
	mFilter->SetSigma(0.5);
	mFilter->UpdateData();
	mFilter->GetOutputData(&m_Image);

ac13720f0caf936b14bf4ad257cdfecf.png

测试代码：

	GussianFilter* mFilter = new GussianFilter();
	mFilter->SetInputData(m_Image);
	mFilter->SetAlgType(GussianFilter::K_9X9);
	mFilter->SetSigma(0.5);
	mFilter->UpdateData();
	mFilter->GetOutputData(&m_Image);

b4c6a0152972a86377d5945242fef3bc.png

测试代码：

	GussianFilter* mFilter = new GussianFilter();
	mFilter->SetInputData(m_Image);
	mFilter->SetAlgType(GussianFilter::K_9X9);
	mFilter->SetSigma(0.8);
	mFilter->UpdateData();
	mFilter->GetOutputData(&m_Image);

58b2ec53ddc6b2f7acc5398b0b00a380.png

测试代码：

	GussianFilter* mFilter = new GussianFilter();
	mFilter->SetInputData(m_Image);
	mFilter->SetAlgType(GussianFilter::K_9X9);
	mFilter->SetSigma(5.0);
	mFilter->UpdateData();
	mFilter->GetOutputData(&m_Image);

6680bf5ec445110f87462ec71a43e47c.png

图像大小：1000*667 卷积模板大小9*9 耗时：0.551秒。

weixin_39566882
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图像处理--高斯滤波
L-inYi的专栏
05-11 3万+
部分内容整理自： http://blog.csdn.net/jianxiong8814/article/details/1562728 http://www.cnblogs.com/pegasus/archive/2011/05/20/2052031.html http://blog.sina.com.cn/s/blog_640577ed0100yz8v.html http://blog.
OpenCV——几种图像滤波总结（python实现和c++实现）
qq_44957388的博客
04-27 9574
图像滤波总结 4.1 简介 图像的实质是一种二维信号，滤波是信号处理中的一个重要概念。在图像处理中，滤波是一种非常常见的技术，它们的原理非常简单，但是其思想却十分值得借鉴，滤波是很多图像算法的前置步骤或基础，掌握图像滤波对理解卷积神经网络也有一定帮助。 4.2 学习目标 了解图像滤波的分类和基本概念 理解均值滤波/方框滤波、高斯滤波的原理 掌握OpenCV框架下滤波API的使用 4...
阈值处理
weixin_43327191的博客
10-06 1983
文章目录一.threshold函数1.将灰度图转化为二值图像：2.对图像进行反二值变换：3.对图像进行截断阈值处理：4.对图像进行超阈值置零处理5.对图像进行低阈值置零处理：二.自适应阈值处理三.Otsu处理 阈值处理类似于分段函数处理，设定一个阈值，若图像中的像素点灰度值大于阈值，对其做一定处理；对低于阈值的像素点做另一类处理。如对于一幅灰度图，我们设定阈值为125，大于125的像素点灰度值设为255，小于255的像素点设为0，这样我们就可以得到一副二值图像。 在OpenCV中提供了cv2.thres.
图像的高斯滤波
jsf921942722的博客
05-28 537
MakeGaussianData.h MakeGaussianData.c 是产生高斯滤波的数据的头文件、函数 MakeGaussianData.h #ifndef _MAKEGAUSSIANDATA_H_ #define _MAKEGAUSSIANDATA_H_#ifdef __cplusplus extern "C" { #endif int makeGaussianData(
图像中高斯滤波
tongfy0000的专栏
11-16 1362
图像高斯滤波 高斯函数：　　    其中 a、b 与 c 为实数常数 ，且a > 0.        c^2 = 2 的高斯函数是傅立叶变换的特征函数。这就意味着高斯函数的傅立叶变换不仅仅是另一个高斯函数，而且是进行傅立叶变换的函数的标量倍。   高斯分布： 正态分布（Normal distribution）又名高斯分布（Gaussian distribution），是一个在数学
对图像进行高斯滤波
Caramel_biscuit的博客
10-15 255
高斯滤波：采用高斯模板的空间卷积。
数字图像高斯滤波C++源代码
06-15
### 数字图像高斯滤波C++源代码分析与知识点详解 #### 一、高斯滤波基础概念 高斯滤波是一种线性平滑滤波器，常用于图像处理中去除噪声，同时也能保留边缘细节。其核心是高斯函数，该函数具有良好的空间局部性和...
C++ openCV图像的卷积与滤波
花语月的喵喵
07-05 1693
图像的滤波均值滤波高斯滤波中值滤波双边滤波图像的卷积插入链接与图片图像的滤波
详解图像滤波原理及实现！
Datawhale
06-28 2442
↑↑↑关注后"星标"Datawhale每日干货 &每月组队学习，不错过Datawhale干货作者：姚童，Datawhale优秀学习者图像的实质是一种二维信号...
使用C++实现三维高斯滤波
04-05
4. 将加权平均后的像素值赋值给原像素点。 5. 对边界进行修剪，得到滤波后的图像。 参考资料： 1. 《数字图像处理(第三版)》 2. https://blog.csdn.net/qq_32678763/article/details/52287849 3. ...
对图像进行高斯模糊处理（高斯滤波）
05-04
程序能够针对输入的图像进行高斯模糊处理，对于机器视觉技术的相关学科有比较重要的用途
图像处理之高斯滤波
程序员深度学习
01-28 2760
1. 高斯函数与高斯滤波 一维高斯函数我们都熟悉，形式如下： G(x)=12πσexp⁡(−x22σ2)G(x) = \frac{1}{\sqrt{2\pi}\sigma} \exp(-\frac{x^2}{2\sigma^2})G(x)=2π​σ1​exp(−2σ2x2​) 计算机视觉中，高斯滤波使用的高斯核为x和y两个一维高斯的乘积，两个维度上的标准差σ通常相同，形式如下： G(x,y)=12πσ2exp⁡(−x2+y22σ2)G(x, y) = \frac{1}{2\pi\sigma^2}\exp(.
【图像处理】高斯滤波
deliberate_cha的博客
10-27 5356
高斯滤波 高斯滤波属于线性平滑滤波的一种，可以消除高斯噪声，广泛应用于图像处理的减噪过程。大家常说高斯滤波是最有用的滤波操作，虽然它用起来效率往往不是最高的。 首先，我们先要了解高斯滤波的原理，以及高斯滤波消除的高斯噪声是什么？ 噪声，是图像中表现极为突兀的像素点或者像素块，会给图像带来干扰，让图像变得不清楚，或者说影响观察图像的细节。 而高斯噪声，就是噪声像素的概率密度函数服从高斯分布（正态分布...
图像处理：高斯滤波
qq_52959401的博客
03-02 1万+
高斯滤波 　　高斯滤波（也可以说“高斯模糊”）其实就是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。简单来说就是整个图像某个像素点的值与周围像素点的值挂钩，是原图像某一像素点的值其实是其本省和周围像素点值的加权平均过程。 　　处理结果上：整个图像相较于原图像会看起来较为模糊，原图像上的某些噪声点在经过周围像素点加权求和后会被剔除掉。 下面这个是看到很有意思的两张图： 图1　高斯　　　　　　　　　　　　　　图2 高斯滤波 ...
50.图像的高斯滤波
最新发布
twnkie的博客
08-08 251
然后，定义了一个5x5的滤波核和X方向上的标准差为1.0，用于进行高斯滤波。sigma（space）越小，中心点权重越大，周围点权重越小，对图像的滤波作用越小，趋于零时，输出等同于原图。在高斯滤波中，会将中心点的权重值加大，远离中心点的权重值减小，在此基础上计算邻域内各个像素值不同权重的和。优点： 1-各个方向上平滑程度相同 2-高斯函数是单值函数，高斯卷积核的锚点为极值，在所有方向上单调递减，锚点像素不会受到距离锚点较远的像素影响过大，保证了特征点的特性 3-在频域上，滤波过程中不会被高频信号污染。
图像处理 高斯滤波（带权值的均值滤波）
热门推荐
qq_36511401的博客
11-04 2万+
1、一维高斯滤波。a表示得到曲线的高度，u是指曲线在x轴的中心， σ指width(与半峰全宽有关,即平方差)。2、二维高斯滤波。
图像处理（三）——高斯滤波
南木的博客
11-03 1万+
高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。
图像处理算法-高斯滤波
qq_35498453的博客
11-17 3407
高斯滤波（Gaussian filter）是对图像进行加权平均的过程，每一个像素点的值由其本身和领域内其他像素值经过加权平均后得到，类似于卷积。 高斯滤波器 均值滤波器是取滤波器窗口内的像素均值作为输出，高斯滤波后的图像被平滑的程度取决于标准差，它输出的是领域像素的加权平均，同时离中心越近的像素权重越高。因此，高斯滤波相对于均值滤波的平滑效果更柔和，对边缘的保留也更好。 步骤 1.移动卷积核到每个像素点上 2.将该像素点以及周围像素点的像素值作为权重乘以卷积核 3.加权作为输出 测试 原图 结果图 代码
OpenCV3/C++实现图像滤波：filter2D与像素点操作
总结来说，本资源提供了一个学习OpenCV3中C++图像滤波的起点，通过理解并实践这两个示例，开发者可以进一步掌握图像处理的基本原理和技术，为更复杂的图像分析任务打下基础。同时，了解和比较不同滤波方法的性能和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值