CUDA卷积操作—使用constant memory实现高斯滤波

最新推荐文章于 2024-06-18 07:56:19 发布
最新推荐文章于 2024-06-18 07:56:19 发布
阅读量6.6k 收藏 23
点赞数 1
分类专栏： CUDA编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i_chaoren/article/details/70665270
版权

高斯滤波就是使用高斯模板和图片进行卷积运算，高斯函数及模板如下图所示：


卷积前后的效果图如下：


constant memory的使用及CUDA编程的相关内容，在代码注释中有详细介绍。
GPU代码如下所示： 
#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include "Windows.h"
#include <math.h>
#include<iostream>
using namespace std;

#define BLOCKDIM_X		16
#define BLOCKDIM_Y		16

#define GRIDDIM_X		256
#define GRIDDIM_Y		256
#define MASK_WIDTH		5

__constant__ int d_const_Gaussian[MASK_WIDTH*MASK_WIDTH]; //分配常数存储器

unsigned char *readBmp(char *bmpName, int *width, int *height, int *byteCount);
bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int byteCount);
static __global__ void kernel_GaussianFilt(int width,int height,int byteCount,unsigned char *d_src_imgbuf,unsigned char *d_guassian_imgbuf);

void main()
{
	//查看显卡配置
	struct cudaDeviceProp pror;
	cudaGetDeviceProperties(&pror,0);
	cout<<"maxThreadsPerBlock="<<pror.maxThreadsPerBlock<<endl;

	long start, end;
	long time = 0; 

	//CUDA计时函数
	start = GetTickCount();
	cudaEvent_t startt,stop; //CUDA计时机制
	cudaEventCreate(&startt);
	cudaEventCreate(&stop);
	cudaEventRecord(startt,0);

	unsigned char *h_src_imgbuf;  //图像指针
	int width, height, byteCount;
	char rootPath1[]="C:\\Users\\a404\\Desktop\\测试图片\\";
	char readPath[1024];
	int frame=1;
	for (int k=1;k<=frame;k++)
	{
		sprintf(readPath, "%s%d.bmp", rootPath1, k);
		h_src_imgbuf=readBmp(readPath, &width, &height, &byteCount);
	
		int size1=width*height *byteCount*sizeof(unsigned char);
		int size2=width*height *sizeof(unsigned char);
		
		//输出图像内存-host端	
		unsigned char *h_guassian_imgbuf=new unsigned char[width*height*byteCount];
		
		//分配显存空间
		unsigned char *d_src_imgbuf;
		unsigned char *d_guassian_imgbuf;

		cudaMalloc((void**)&d_src_imgbuf, size1);
		cudaMalloc((void**)&d_guassian_imgbuf, size1);

		//把数据从Host传到Device
		cudaMemcpy(d_src_imgbuf, h_src_imgbuf, size1, cudaMemcpyHostToDevice);

		//将高斯模板传入constant memory
		int Gaussian[25] = {1,4,7,4,1,
							4,16,26,16,4,
							7,26,41,26,7,
							4,16,26,16,4,
							1,4,7,4,1};//总和为273
		cudaMemcpyToSymbol(d_const_Gaussian, Gaussian, 25 * sizeof(int));

		int bx = ceil((double)width/BLOCKDIM_X); //网格和块的分配
		int by = ceil((double)height/BLOCKDIM_Y);

		if(bx > GRIDDIM_X) bx = GRIDDIM_X;
		if(by > GRIDDIM_Y) by = GRIDDIM_Y;

		dim3 grid(bx, by);//网格的结构
		dim3 block(BLOCKDIM_X, BLOCKDIM_Y);//块的结构

		//kernel--高斯滤波
		kernel_GaussianFilt<<<grid, block>>>(width,height,byteCount,d_src_imgbuf,d_guassian_imgbuf);
		cudaMemcpy(h_guassian_imgbuf, d_guassian_imgbuf,size1, cudaMemcpyDeviceToHost);//数据传回主机端

		char rootPath2[]="C:\\Users\\a404\\Desktop\\测试结果\\";
		char writePath[1024];
		sprintf(writePath, "%s%d.bmp", rootPath2, k);
		saveBmp(writePath, h_guassian_imgbuf, width, height, byteCount);
		
		//输出进度展示
		cout<<k<<"  "<<((float)k/frame)*100<<"%"<<endl;
	
		//释放内存
		cudaFree(d_src_imgbuf); 
		cudaFree(d_guassian_imgbuf);
		
		delete []h_src_imgbuf;
		delete []h_guassian_imgbuf;
	}
	end = GetTickCount();
	InterlockedExchangeAdd(&time, end - start);
	cout << "Total time GPU:";
	cout << time << endl;
	int x;
	cin>>x;
}

static __global__ void kernel_GaussianFilt(int width,int height,int byteCount,unsigned char *d_src_imgbuf,unsigned char *d_dst_imgbuf)
{
	const int tix = blockDim.x * blockIdx.x + threadIdx.x;
	const int tiy = blockDim.y * blockIdx.y + threadIdx.y;

	const int threadTotalX = blockDim.x * gridDim.x;
	const int threadTotalY = blockDim.y * gridDim.y;

	for(int ix = tix; ix < height; ix += threadTotalX)
		for(int iy = tiy; iy < width; iy += threadTotalY)
		{ 
			for(int k=0;k<byteCount;k++)
			{
				int sum=0;//临时值
				int tempPixelValue=0;
				for (int m=-2;m<=2;m++)
				{
					for (int n=-2;n<=2;n++)
					{
						//边界处理，幽灵元素赋值为零
						if (ix+m<0||iy+n<0||ix+m>=height||iy+n>=width)						
							tempPixelValue=0;						 
						else						
							tempPixelValue=*(d_src_imgbuf+(ix+m)*width*byteCount+(iy+n)*byteCount+k);							
						sum+=tempPixelValue*d_const_Gaussian[(m+2)*5+n+2];
					}
				}

				if (sum/273<0) 
					*(d_dst_imgbuf+(ix)*width*byteCount+(iy)*byteCount+k)=0;
				else if(sum/273>255)  
					*(d_dst_imgbuf+(ix)*width*byteCount+(iy)*byteCount+k)=255;
				else  
					*(d_dst_imgbuf+(ix)*width*byteCount+(iy)*byteCount+k)=sum/273;		
			}
	    }
}

unsigned char *readBmp(char *bmpName, int *width, int *height, int *byteCount)
{
	//打开文件
	FILE *fp=fopen(bmpName,"rb");
	if(fp==0) return 0;
	//跳过文件头
	fseek(fp, sizeof(BITMAPFILEHEADER),0);

	//读入信息头
	int w, h, b;
	BITMAPINFOHEADER head;
	fread(&head, sizeof(BITMAPINFOHEADER), 1,fp); 
	w = head.biWidth;
	h = head.biHeight;
	b = head.biBitCount/8;
	int lineByte=(w * b+3)/4*4; //每行的字节数为4的倍数

	//跳过颜色表 （颜色表的大小为1024）（彩色图像并没有颜色表，不需要这一步）
	if(b==1)
		fseek(fp, 1024,1);

	//图像数据
	unsigned char *imgBuf=new unsigned char[w * h * b];
	for(int i=0;i<h;i++)
	{
		fread(imgBuf+i*w*b,w*b, 1,fp);
		fseek(fp, lineByte-w*b, 1);
	}
	fclose(fp);

	*width=w,  *height=h, *byteCount=b;

	return imgBuf;
}


bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int byteCount)
{
	if(!imgBuf)
		return 0;

	//灰度图像颜色表空间1024，彩色图像没有颜色表
	int palettesize=0;
	if(byteCount==1) palettesize=1024;

	//一行象素字节数为4的倍数
	int lineByte=(width * byteCount+3)/4*4;

	FILE *fp=fopen(bmpName,"wb");
	if(fp==0) return 0;

	//填写文件头
	BITMAPFILEHEADER fileHead;
	fileHead.bfType = 0x4D42;
	fileHead.bfSize= 
		sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+ palettesize + lineByte*height;
	fileHead.bfReserved1 = 0;
	fileHead.bfReserved2 = 0;
	fileHead.bfOffBits=54+palettesize;
	fwrite(&fileHead, sizeof(BITMAPFILEHEADER),1, fp);

	// 填写信息头
	BITMAPINFOHEADER head; 
	head.biBitCount=byteCount*8;
	head.biClrImportant=0;
	head.biClrUsed=0;
	head.biCompression=0;
	head.biHeight=height;
	head.biPlanes=1;
	head.biSize=40;
	head.biSizeImage=lineByte*height;
	head.biWidth=width;
	head.biXPelsPerMeter=0;
	head.biYPelsPerMeter=0;
	fwrite(&head, sizeof(BITMAPINFOHEADER),1, fp);

	//颜色表拷贝  
	if(palettesize==1024)
	{
		unsigned char palette[1024];
		for(int i=0;i<256;i++)
		{
			*(palette+i*4+0)=i;
			*(palette+i*4+1)=i;
			*(palette+i*4+2)=i;
			*(palette+i*4+3)=0;     
		}
		fwrite(palette, 1024,1, fp);
	}

	//准备数据并写文件
	unsigned char *buf=new unsigned char[height*lineByte];
	for(int i=0;i<height;i++)
	{
		for(int j=0;j<width*byteCount; j++)
			*(buf+i*lineByte+j)=*(imgBuf+i*width*byteCount+j);
	}
	fwrite(buf, height*lineByte, 1, fp);

	delete []buf;

	fclose(fp);

	return 1;
}
附录：高斯滤波CPU代码 
#include "stdio.h"
#include "Windows.h"
#include <iostream>
using namespace std;

unsigned char *readBmp(char *bmpName, int *width, int *height, int *byteCount); //读入图像
bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int byteCount); //保存图像
void GaussianFilt(int width,int height,int byteCount,int Gaussian[][5],unsigned char *gray_imgbuf,unsigned char *guassian_imgbuf); //高斯滤波

void main()
{
	//计时函数
	long start, end;
	long time = 0; 
	start = GetTickCount();

	unsigned char *src_imgbuf; //图像指针
	int width, height, byteCount;
	char rootPath1[]="C:\\Users\\a404\\Desktop\\测试图片\\";
	char readPath[1024];
	int frame=300;  //读入图像副数
	for (int i=1;i<=frame;i++)
	{
		sprintf(readPath, "%s%d.bmp", rootPath1, i);
		src_imgbuf=readBmp(readPath, &width, &height, &byteCount);
		//printf("宽=%d，高=%d，字节=%d\n",width, height, byteCount);

		//读入高斯模糊模板
		int Gaussian_mask[5][5]={{1,4,7,4,1},{4,16,26,16,4},{7,26,41,26,7},{4,16,26,16,4},{1,4,7,4,1}};//总和为273

		//输出图像内存分配	
		unsigned char *guassian_imgbuf=new unsigned char[width*height*byteCount];

		//对原图高斯模糊
		GaussianFilt(width,height,byteCount,Gaussian_mask,src_imgbuf,guassian_imgbuf);
	
		char rootPath2[]="C:\\Users\\a404\\Desktop\\";
		char writePath[1024];
		sprintf(writePath, "%s%d.bmp", rootPath2, i);
		
		saveBmp(writePath, guassian_imgbuf, width, height, byteCount);

		cout<<i<<"  "<<((float)i/frame)*100<<"%"<<endl;
		delete []src_imgbuf;
		delete []guassian_imgbuf;
	}
	end = GetTickCount();
	InterlockedExchangeAdd(&time, end - start);
	cout << "Total time CPU:";
	cout << time << endl;
	int x;
	cin>>x;
}

void GaussianFilt(int width,int height,int byteCount,int Gaussian[][5],unsigned char *src_imgbuf,unsigned char *guassian_imgbuf)
{
	//高斯模糊处理 5层循环处理
	for(int i=0;i<height;i++)
	{
		for(int j=0;j<width;j++)
		{
			for(int k=0;k<byteCount;k++)
			{
				int sum=0;//临时值
				int tempPixelValue=0;
				for (int m=-2;m<=2;m++)
				{
					for (int n=-2;n<=2;n++)
					{
						//边界处理，幽灵元素赋值为零
						if (i+m<0||j+n<0||i+m>=height||j+n>=width)						
							tempPixelValue=0;						 
						else						
							tempPixelValue=*(src_imgbuf+(i+m)*width*byteCount+(j+n)*byteCount+k);	
						//tempPixelValue=*(gray_imgbuf+(i+m)*width+(j+n)+k);	
						sum+=tempPixelValue*Gaussian[m+2][n+2];
					}
				}
				//tempPixelValue=*(src_imgbuf+(i)*width*byteCount+(j)*byteCount+k);
				if (sum/273<0) 
					*(guassian_imgbuf+i*width*byteCount+j*byteCount+k)=0;
				else if(sum/273>255)  
					*(guassian_imgbuf+i*width*byteCount+j*byteCount+k)=255;
				else  
					*(guassian_imgbuf+i*width*byteCount+j*byteCount+k)=sum/273;		
			}
		}
	}
}

//给定一个图像文件及其路径，读入图像数据。 
unsigned char *readBmp(char *bmpName, int *width, int *height, int *byteCount)
{
	//打开文件，
	FILE *fp=fopen(bmpName,"rb");
	if(fp==0) return 0;
	//跳过文件头
	fseek(fp, sizeof(BITMAPFILEHEADER),0);

	//读入信息头
	int w, h, b;
	BITMAPINFOHEADER head;
	fread(&head, sizeof(BITMAPINFOHEADER), 1,fp); 
	w = head.biWidth;
	h = head.biHeight;
	b = head.biBitCount/8;
	int lineByte=(w * b+3)/4*4; //每行的字节数为4的倍数

	//跳过颜色表 （颜色表的大小为1024）（彩色图像并没有颜色表，不需要这一步）
	if(b==1)
		fseek(fp, 1024,1);

	//图像数据
	unsigned char *imgBuf=new unsigned char[w * h * b];
	for(int i=0;i<h;i++)
	{
		fread(imgBuf+i*w*b,w*b, 1,fp);
		fseek(fp, lineByte-w*b, 1);
	}
	fclose(fp);

	*width=w,  *height=h, *byteCount=b;

	return imgBuf;
}


bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int byteCount)
{
	if(!imgBuf)
		return 0;

	//灰度图像颜色表空间1024，彩色图像没有颜色表
	int palettesize=0;
	if(byteCount==1) palettesize=1024;

	//一行象素字节数为4的倍数
	int lineByte=(width * byteCount+3)/4*4;

	FILE *fp=fopen(bmpName,"wb");
	if(fp==0) return 0;

	//填写文件头
	BITMAPFILEHEADER fileHead;
	fileHead.bfType = 0x4D42;
	fileHead.bfSize= 
		sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+ palettesize + lineByte*height;
	fileHead.bfReserved1 = 0;
	fileHead.bfReserved2 = 0;
	fileHead.bfOffBits=54+palettesize;
	fwrite(&fileHead, sizeof(BITMAPFILEHEADER),1, fp);

	// 填写信息头
	BITMAPINFOHEADER head; 
	head.biBitCount=byteCount*8;
	head.biClrImportant=0;
	head.biClrUsed=0;
	head.biCompression=0;
	head.biHeight=height;
	head.biPlanes=1;
	head.biSize=40;
	head.biSizeImage=lineByte*height;
	head.biWidth=width;
	head.biXPelsPerMeter=0;
	head.biYPelsPerMeter=0;
	fwrite(&head, sizeof(BITMAPINFOHEADER),1, fp);

	//颜色表拷贝  
	if(palettesize==1024)
	{
		unsigned char palette[1024];
		for(int i=0;i<256;i++)
		{
			*(palette+i*4+0)=i;
			*(palette+i*4+1)=i;
			*(palette+i*4+2)=i;
			*(palette+i*4+3)=0;     
		}
		fwrite(palette, 1024,1, fp);
	}

	//准备数据并写文件
	unsigned char *buf=new unsigned char[height*lineByte];
	for(int i=0;i<height;i++)
	{
		for(int j=0;j<width*byteCount; j++)
			*(buf+i*lineByte+j)=*(imgBuf+i*width*byteCount+j);
	}
	fwrite(buf, height*lineByte, 1, fp);

	delete []buf;

	fclose(fp);

	return 1;
}



i_chaoren
关注
  • 1
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
CUDA：递归高斯滤波器实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-22 304
CUDA：递归高斯滤波器实例
用C语言实现高斯滤波
11-27
本篇文章将详细介绍如何使用C语言来实现高斯滤波，并探讨其相关知识点。 一、高斯滤波原理 高斯滤波器的核心是高斯核（Gaussian kernel），它是一个二维的、对称的、正态分布的权重矩阵。这个矩阵中的每个元素都...
CUDA实现图像的高斯滤波（opencv实现）
tangbenjun的博客
09-18 8114
高斯滤波简介：        高斯滤波是通过对输入数组的每个点与输入的高斯滤波模板执行卷积计算然后将这些结果一块组成了滤波后的输出数组，通俗的讲就是高斯滤波是对整幅图像进行加权平均的过程，每一个像素点的值都由其本身和邻域内的其他像素值经过加权平均后得到。        高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板
利用CUDA加速卷积计算：原理、实践与示例代码
最新发布
专注于人工智能领域的小何尚
06-18 882
引言在深度学习领域，卷积神经网络（Convolutional Neural Networks，CNN）是目前最流行和有效的模型之一。然而，随着模型复杂度的增加，卷积计算的计算量也随之增加，这使得在CPU上进行卷积计算变得非常耗时。因此，利用CUDA加速卷积计算成为了一个热门话题。在本文中，我们将详细介绍如何利用CUDA加速卷积计算，包括原理、实践和示例代码，帮助您更好地理解和应用CUDA加速技术。
CUDA中的常量内存__constant__
热门推荐
牧野的博客
02-06 1万+
GPU包含数百个数学计算单元，具有强大的处理运算能力，可以强大到计算速率高于输入数据的速率，即充分利用带宽，满负荷向GPU传输数据还不够它计算的。CUDA C除全局内存和共享内存外，还支持常量内存，常量内存用于保存在核函数执行期间不会发生变化的数据，使用常量内存在一些情况下，能有效减少内存带宽，降低GPU运算单元的空闲等待。 使用常量内存提升性能 使用常量内存可以提升运算性能的
CUDA中的存储空间修饰符
专注于人工智能领域的小何尚
06-30 618
变量内存空间说明符表示变量在设备上的内存位置。在设备代码中声明的没有本节中描述的任何 、 和 内存空间说明符的自动变量通常驻留在寄存器中。 但是，在某些情况下，编译器可能会选择将其放置在本地内存中，这可能会产生不利的性能后果，如设备内存访问中所述。 内存空间说明符声明了一个驻留在设备上的变量。在接下来的三个部分中定义的其他内存空间说明符中最多有一个可以与 一起使用，以进一步表示变量属于哪个内存空间。 如果它们都不存在，则变量： 内存空间说明符，可选择与 一起使用，声明一个变量： 内存空间说明符，可选择
cuda 学习之内存层次结构
xukang95的博客
03-23 2908
文章目录Cuda 内存层次结构registers：寄存器local memory：局部存储器shared memory：共享存储器共享内存-Bank Conflictconstant memory：常数存储器texture memory：纹理存储器global memory：全局存储器全局内存-对齐与合并host memory :主机端内存总结 Cuda 内存层次结构 要想编写高效的程序，那么一...
高斯滤波的FPGA实现 fpga开发.pdf
04-22
高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中的中心像素点的值。 高斯滤波（Gauss filter）实质上是一种信号的滤波器，其用途...
图像处理中的中值滤波、均值滤波以及高斯滤波的实现与对比（基于MATLAB）
03-31
高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。 2. 代码功能： 实现中值滤波、均值滤波以及高斯滤波，并对图像...
高斯滤波 C语言代码.rar
08-20
在图像处理中，高斯滤波器通过卷积操作来实现。卷积是一个将滤波器（也称为核或掩模）与图像像素值相乘然后求和的过程，对每个像素执行该操作，形成新的图像。 ### C语言实现关键步骤 1. **创建高斯核**：首先，你...
对图像进行高斯滤波_对图像进行高斯滤波_
10-01
在MATLAB中，可以使用高斯滤波器先对图像进行卷积，然后减去高斯滤波后的图像，得到的结果就是高通滤波的效果。然而，描述中提到的是"高斯滤波"，而不是"高通滤波"，所以"Untitled4.m"脚本很可能是实现了高斯滤波的...
基于CUDA的高速并行高斯滤波算法
12-19
基于CUDA的高速并行高斯滤波算法 快速高效地实现高斯滤波
CUDA、GPU实现图像的sobel、prewitt、均值、中值滤波
06-27
CUDA、GPU实现图像的sobel、prewitt、均值、中值滤波
基于CUDA的高速并行高斯滤波算法 (2011年)
05-06
为加快表面三维形貌分析中高斯滤波算法的执行速度,提出了一种基于计算统一设备构架(CUDA)的高斯滤波算法来实现高速并行处理.分析高斯滤波算法原理和CUDA并行计算体系,将CUDA并行计算技术引入到表面分析领域.针对高斯滤波数据间依赖性弱和CUDA采用单指令多线程(SIMT)执行模型的特点,总结出适合于CUDA的并行高斯滤波算法流程.实验证明:该方法与CPU串行处理方法相比,其加速比达到40倍以上,可以有效提高数据处理能力.
基于CUDA的并行计算技术+opencv完成图像高斯滤波和双边滤波
05-22
基于CUDA的并行计算技术+opencv完成图像高斯滤波和双边滤波，开发版本为VS2019+openCV3.4
CUDA中的常量内存__constant__和cudaMemcpyToSymbol
JustForYouForDL的博客
05-27 2331
__constant__声明内存为常量内存 使用常量内存可以提升运算性能的原因如下： 对常量内存的单次读操作可以广播到其他的“邻近(nearby)”线程，这将节约15次读取操作； 高速缓存。常量内存的数据将缓存起来，因此对于相同地址的连续操作将不会产生额外的内存通信量； 在CUDA架构中，线程束是指一个包含32个线程的集合，这个线程集合被“编织在一起”并且以“步调一致(Lockstep)”的形式执行。 当处理常量内存时，NVIDIA硬件将把单次内存读取操作广播到每个半线程束(Half-Warp).
CUDA总结：opencv cuda模块高斯滤波函数分析
Kelvin_Yan的专栏
12-22 4964
基于opencv 3.1相关接口cv::Ptr<cv::cuda::Filter> // 滤波器对象指针，位于opencv2\cudafilters.hpp cv::cuda::createGaussianFilter // 创建高斯滤波器对象，位于opencv2\cudafilters.hpp cv::cuda::Filter::apply // 滤波器实现，位于
关于CUDA中__constant__的随笔
qq_58000995的博客
12-14 396
注意 cudaMemcpyFromSymbol(&h_NX, NX, sizeof(int));中的第二个参数不要写&NX，否则会把NX的地址传递给 h_NX, 而不是 NX 的值。__constant__和__device__ __constant__ 应该没什么区别。示例代码如下：（很多库不需要调用的）
图像均值滤波cuda_图像增强（平滑）之“均值滤波”和“高斯滤波”
weixin_39661881的博客
01-27 1163
知识结构接下来几天的任务是图像增强，图像增强并没有严格数学上的定义，也就是没有说明处理后达到什么样的指标后算是完成，同样，增强是针对人的，如果你觉得处理后观察结果更显然了，那就是达到了增强的目的，增强分好多方法，大方向可以分为，灰度拉伸和空间滤波，灰度拉伸是简单的像素灰度到像素灰度的变换:比如灰度值 经过 后得到了 ，这样处理整幅图后看起来更能满足目的了，这也就算是增强了。空间滤波利...
信号卷积高斯滤波得到什么，高斯滤波有什么作用
05-13
信号卷积高斯滤波可以得到一个经过高斯滤波平滑后的信号。高斯滤波是一种线性平滑滤波器，它可以将图像中的高频噪声成分去除，同时保留图像中的较低频成分，从而实现图像平滑处理的目的。这种平滑处理可以去除图像中的噪声，使得图像更加清晰，可以用于图像增强、边缘检测等方面。在图像处理、计算机视觉、模式识别等领域中，高斯滤波是一种常用的图像处理方法。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值