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

最新推荐文章于 2025-05-10 08:55:57 发布
转载 最新推荐文章于 2025-05-10 08:55:57 发布 · 1k 阅读 · 7
文章标签：

#cuda编程 #高斯滤波

本文介绍了一种利用CUDA进行高斯滤波的方法，并详细展示了如何通过GPU加速卷积运算，对比了GPU与CPU实现的代码差异。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

先转载一篇CUDA卷积的实现，对比一下GPU与CPU中的代码有什么不同：

原文地址：CUDA卷积操作—使用constant memory实现高斯滤波

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

卷积前后的效果图如下：

这里写图片描述

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;  
}
CUDA：递归高斯滤波器实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-22 404
CUDA：递归高斯滤波器实例
CUDA编程07 - 卷积的优化
GPU全栈博主
08-19 1036
在接下来的几篇文章中，我们将讨论一组重要的并行计算模式。这些模式是许多并行算法的基础，这些算法出现在许多并行应用中。我们将从卷积开始，卷积是一种流行的数组操作，广泛应用于信号处理、数字录音、图像处理、视频处理和计算机视觉等领域。在这些应用领域中，卷积通常作为一种滤波器，转化信号和像素为更理想的值。我们的图像模糊核就是这样一种滤波器，它平滑信号值，以便人们能够看到整体趋势。另一个例子是高斯滤波器，这是一种卷积滤波器，可以用来锐化图像中物体的边界和边缘。卷积通常执行大量的算术运算，以生成每个输出元素。
基于CUDA的高速并行高斯滤波算法 (2011年)
05-06
为加快表面三维形貌分析中高斯滤波算法的执行速度,提出了一种基于计算统一设备构架(CUDA)的高斯滤波算法来实现高速并行处理.分析高斯滤波算法原理和CUDA并行计算体系,将CUDA并行计算技术引入到表面分析领域.针对高斯滤波数据间依赖性弱和CUDA采用单指令多线程(SIMT)执行模型的特点,总结出适合于CUDA的并行高斯滤波算法流程.实验证明:该方法与CPU串行处理方法相比,其加速比达到40倍以上,可以有效提高数据处理能力.
CUDA实现图像的高斯滤波（opencv实现）
tangbenjun的博客
09-18 8539
高斯滤波简介：        高斯滤波是通过对输入数组的每个点与输入的高斯滤波模板执行卷积计算然后将这些结果一块组成了滤波后的输出数组，通俗的讲就是高斯滤波是对整幅图像进行加权平均的过程，每一个像素点的值都由其本身和邻域内的其他像素值经过加权平均后得到。        高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板
基于CUDA的并行计算技术+opencv完成图像高斯滤波和双边滤波
05-22
基于CUDA的并行计算技术+opencv完成图像高斯滤波和双边滤波，开发版本为VS2019+openCV3.4
CUDA可视化技术突破：实现高性能图形和视觉应用
![CUDA可视化技术突破：实现高性能图形和视觉应用]...文中还详述了高效CUDA视觉算法的实现策略和CUDA并行算法设计的优化方法，包括核函数设计、数据传输和同步机制。最后，本文展望了CUDA技术的发展趋势和未来研究
【3D 图像分类】基于 Pytorch 的 3D 立体图像分类1（基础篇）
钱多多先森
06-13 8674
深度学习2维到3维分类任务详解，包括数据、网络、训练和评估。通过本文的学习，对3维数据的处理，可视化和模型构建均有较为深入的理解
【CUDA算法加速】：CUDA优化算法，加速你的计算
![【CUDA算法加速】：CUDA优化算法，加速你的计算]...本文首先介绍了CUDA加速的基础知识，然后深入探讨了CUDA编程模型和内存管理的策略，重点讲解了内核优化和性能调优技巧，并通过实践案例分析具体算法的CUDA实现。
QT中的CUDA编程实践：无缝并行计算体验打造秘籍
首先，概述了CUDA的编程模型、内存架构和线程组织，并探讨了CUDA内存操作的优化。随后，详细阐述了如何在QT中集成CUDA环境和实现CUDA与QT界面的交互，包括数据处理和事件驱动技术。接着，探讨了CUDA高级编程技巧，如...
cuda结合opencv实现图像的高斯平滑
10-20
应用CUDA，opencv实现图像的高斯平滑处理， 读取待处理的图像； 定义中间数据传递的指针并分配内存； 将数据从Host端传到Device端； 网格和块的分配； 执行kernel函数； 将数据从Device端传回到Host端； 最后释放内存。
CUDA、GPU实现图像的sobel、prewitt、均值、中值滤波
06-27
CUDA、GPU实现图像的sobel、prewitt、均值、中值滤波
CUDA学习笔记（十三）CONSTANT MEMORY
云中寻雾的博客
07-21 2632
CONSTANT  MEMORY constant Memory对于device来说只读但是对于host是可读可写。constant Memory和global Memory一样都位于DRAM，并且有一个独立的on-chip cache，比直接从global Memory读取要快得多。每个SM上constant Memory大小限制为64KB。 constant Memory的获取方式不同于其...
CUDA 共享内存高斯滤波，CUDA最优版水平垂直高斯滤波
weixin_45258796的博客
03-26 600
水平方向高斯滤波 垂直方向高斯滤波
CUDA学习笔记（十四） Constant Memory
qq_45788429的博客
10-23 465
转载至。
基于CUDA的并行计算技术+opencv完成图像高斯滤波和双边滤波，开发版本为VS2019+openCV3.4
coding的博客
05-22 3117
实验三-基于CUDA的并行计算技术及其应用 CUDA基础知识 GPU并不是一个独立运行的计算平台，而需要与CPU协同工作，可以看成是CPU的协处理器，因此当我们在说GPU并行计算时，其实是指的基于CPU+GPU的异构计算架构。在异构计算架构中，GPU与CPU通过PCIe总线连接在一起来协同工作，CPU所在位置称为为主机端（host），而GPU所在位置称为设备端（device），如下图所示。 CUDA程序中既包含host程序，又包含device程序，它们分别在CPU和GPU上运行。同时，host与devic
Constant Memory in CUDA
wzk6_3_8的专栏
11-06 1514
看过介绍Constant  Memory最好的， 不得不顶一下。 from http://cuda-programming.blogspot.sg/2013/01/what-is-constant-memory-in-cuda.html.  We have talked about the Global memory and shared memory in previous a
c++CUDA编程--图像处理算法练习--图像高斯滤波，ok
最新发布
小硕算法工程师
05-10 290
c++图像算法CUDA加速CUDA练习，仅作参考VS2019--c++CUDA环境配置与编程实例visual studio2019配置opencv（详细教程）
OpenCV3.0基于CUDA的高斯模糊(滤波)实现
fb_help的专栏
04-09 4073
OpenCV3.0基于CUDA的高斯模糊(滤波)实现 前言 需要： OpenCV3.0以上版本 编译时编译CUDA模块，即USE_CUDA 需要注意的是： CUDA版的高斯模糊目前只支持&lt;=siez（31，31）的高斯核。 代码： #include &lt;opencv2/opencv.hpp&gt; #include &lt;opencv2/xfeatures2d...
信号卷积高斯滤波得到什么，高斯滤波有什么作用
05-13
信号卷积高斯滤波可以得到一个经过高斯滤波平滑后的信号。高斯滤波是一种线性平滑滤波器，它可以将图像中的高频噪声成分去除，同时保留图像中的较低频成分，从而实现图像平滑处理的目的。这种平滑处理可以去除图像中的噪声，使得图像更加清晰，可以用于图像增强、边缘检测等方面。在图像处理、计算机视觉、模式识别等领域中，高斯滤波是一种常用的图像处理方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值