图像处理之基础---滤波器之高斯低通滤波器3c代码实现yuv，rgb

（）高斯理论简介

（）

（）代码实现

四 使用高斯滤波器进行图像的平滑

（）高斯简介

http://www.zwbk.org/MyLemmaShow.aspx?lid=126233  中文百科独特解释

http://academic.mu.edu/phys/matthysd/web226/Lab02.htm

http://www.360doc.com/content/12/0921/17/10724725_237428926.shtml 有历程

http://blog.csdn.net/l_inyi/article/details/8915116 实现opencv

http://www.cnblogs.com/JohnShao/archive/2011/06/02/2067800.html 工业级应用

http://blog.csdn.net/zddblog/article/details/7450033  高斯模糊小结

生成高斯核

/*************************************************************************
*
* \函数名称：
*   MakeGauss()
*
* \输入参数:
*   double sigma                                            - 高斯函数的标准差
*   double **pdKernel                                        - 指向高斯数据数组的指针
*   int *pnWindowSize                                        - 数据的长度
*
* \返回值:
*   无
*
* \说明:
*   这个函数可以生成一个一维的高斯函数的数字数据，理论上高斯数据的长度应
*   该是无限长的，但是为了计算的简单和速度，实际的高斯数据只能是有限长的
*   pnWindowSize就是数据长度
*  
*************************************************************************
*/
void MakeGauss(double sigma, double **pdKernel, int *pnWindowSize)
{
    // 循环控制变量
    int i   ;
    // 数组的中心点
    int nCenter;

// 数组的某一点到中心点的距离
    double  dDis  ;

double PI = 3.14159;
    // 中间变量
    double  dValue;
    double  dSum  ;
    dSum = 0 ;
    // 数组长度，根据概率论的知识，选取[-3*sigma, 3*sigma]以内的数据。
    // 这些数据会覆盖绝大部分的滤波系数
    *pnWindowSize = 1 + 2 * ceil(3 * sigma);
    // 中心
    nCenter = (*pnWindowSize) / 2;
    // 分配内存
    *pdKernel = new double[*pnWindowSize] ;
    for(i=0; i< (*pnWindowSize); i++)
    {
        dDis = (double)(i - nCenter);
        dValue = exp(-(1/2)*dDis*dDis/(sigma*sigma)) / (sqrt(2 * PI) * sigma );
        (*pdKernel)[i] = dValue ;
        dSum += dValue;
    }
    // 归一化
    for(i=0; i<(*pnWindowSize) ; i++)
    {
        (*pdKernel)[i] /= dSum;
    }
}

高斯滤波

/*************************************************************************
*
* \函数名称：
*   GaussianSmooth()
*
* \输入参数:
*   unsigned char * pUnchImg                - 指向图象数据的指针
*   int nWidth                                            - 图象数据宽度
*   int nHeight                                        - 图象数据高度
*   double dSigma                                    - 高斯函数的标准差
*   unsigned char * pUnchSmthdImg    - 指向经过平滑之后的图象数据
*
* \返回值:
*   无
*
* \说明:
*   为了抑止噪声，采用高斯滤波对图象进行滤波，滤波先对x方向进行，然后对
*   y方向进行。
*  
*************************************************************************
*/
void GaussianSmooth(unsigned char *pUnchImg, int nWidth, int nHeight,
                                        double sigma, unsigned char * pUnchSmthdImg)
{
    // 循环控制变量
  int y;
    int x;
    int i;
    // 高斯滤波器的数组长度
    int nWindowSize;
    //  窗口长度的1/2
    int    nHalfLen;  
    // 一维高斯数据滤波器
    double *pdKernel ;
    // 高斯系数与图象数据的点乘
    double  dDotMul     ;
    // 高斯滤波系数的总和
    double  dWeightSum     ;         
    // 中间变量
    double * pdTmp ;
    // 分配内存
    pdTmp = new double[nWidth*nHeight];
    // 产生一维高斯数据滤波器
    // MakeGauss(sigma, &dKernel, &nWindowSize);
    MakeGauss(sigma, &pdKernel, &nWindowSize) ;
    // MakeGauss返回窗口的长度，利用此变量计算窗口的半长
    nHalfLen = nWindowSize / 2;
  // x方向进行滤波
    for(y=0; y<nHeight; y++)
    {
        for(x=0; x<nWidth; x++)
        {
            dDotMul        = 0;
            dWeightSum = 0;
            for(i=(-nHalfLen); i<=nHalfLen; i++)
            {
                // 判断是否在图象内部
                if( (i+x) >= 0  && (i+x) < nWidth )
                {
                    dDotMul += (double)pUnchImg[y*nWidth + (i+x)] * pdKernel[nHalfLen+i];
                    dWeightSum += pdKernel[nHalfLen+i];
                }
            }
            pdTmp[y*nWidth + x] = dDotMul/dWeightSum ;
        }
    }
    // y方向进行滤波
    for(x=0; x<nWidth; x++)
    {
        for(y=0; y<nHeight; y++)
        {
            dDotMul        = 0;
            dWeightSum = 0;
            for(i=(-nHalfLen); i<=nHalfLen; i++)
            {
                // 判断是否在图象内部
                if( (i+y) >= 0  && (i+y) < nHeight )
                {
                    dDotMul += (double)pdTmp[(y+i)*nWidth + x] * pdKernel[nHalfLen+i];
                    dWeightSum += pdKernel[nHalfLen+i];
                }
            }
            pUnchSmthdImg[y*nWidth + x] = (unsigned char)(int)dDotMul/dWeightSum ;
        }
    }

// 释放内存
    delete []pdKernel;
    pdKernel = NULL ;
    delete []pdTmp;
    pdTmp = NULL;
}

http://www.cnblogs.com/IamEasy_Man/archive/2010/08/17/1801477.html 纯c实现

void gaussianFilter(uchar* data, int width, int height)
02 {
03     int i, j, index, sum;
04     int templates[9] = { 1, 2, 1,
05                          2, 4, 2,
06                          1, 2, 1 };
07     sum = height * width * sizeof(uchar);
08     uchar *tmpdata = (uchar*)malloc(sum);
09     memcpy((char*)tmpdata,(char*)data, sum);
10     for(i = 1;i < height - 1;i++)
11     {
12         for(j = 1;j < width - 1;j++)
13         {
14             index = sum = 0;
15             for(int m = i - 1;m < i + 2;m++)
16             {
17                 for(int n = j - 1; n < j + 2;n++)
18                 {
19                     sum +=
20                         tmpdata[m * width + n] *
21                         templates[index++];
22                 }
23             }
24             data[i * width + j] = sum / 16;
25         }
26     }
27     free(tmpdata);
28 }

一个模板

http://www.360doc.com/content/12/0921/16/10724725_237423041.shtml

//**********************************************************************
//模板操作
//图像信息头
//图像数据
//模板大小       以0开始
//模板中心元素   以0开始
//模板数据
//模板系数
//**********************************************************************
BOOL ImgTemplate(BITMAPINFO* pbmpinfo,BYTE* pbmpdata,CSize TemplateSize,CSize TemplateCertel ,int *template_box,float coef)
{

LONG imagewidth=pbmpinfo->bmiHeader.biWidth;
    LONG imageheigth=pbmpinfo->bmiHeader.biHeight;

LONG i=0,j=0,k=0,heigth=0,width=0;

//data is not null
    if (pbmpdata == NULL)
    {
        return FALSE;
    }
    //image size
    if (imageheigth <= TemplateSize.cy || imagewidth <= TemplateSize.cx)
    {
        return FALSE;
    }
    if (TemplateCertel.cx < 0 ||  TemplateCertel.cy < 0 || TemplateCertel.cx > TemplateSize.cx || TemplateCertel.cy > TemplateSize.cy)
    {
       return FALSE;
    }
    //color must be gray
    if (pbmpinfo->bmiHeader.biBitCount != 8)
    {
            AfxMessageBox("只对灰度图像进行操作!");
        return FALSE;
    }
    //image size
    LONG  Linebyte =( pbmpinfo->bmiHeader.biBitCount * imagewidth +31)/32*4;
    LONG  ImageSize=Linebyte * imageheigth;
   
    //分配空间
    BYTE *pNewbmpdata=(BYTE*)malloc(ImageSize);
   
    //copy data
    if (pNewbmpdata == NULL)
    {
   
        return FALSE;
    }
   
    memcpy(pNewbmpdata,pbmpdata,ImageSize);

BYTE *psrc=NULL;
    BYTE *pdest=NULL;
       
    LONG result=0;

for (heigth = TemplateCertel.cy ; heigth < imageheigth - TemplateSize.cy + TemplateCertel.cy + 1  ;heigth++  )
    {
               
        for ( width = TemplateCertel.cx ; width < imagewidth - TemplateSize.cx + TemplateCertel.cx + 1 ; width++)
        {
            psrc  = (unsigned char *)pbmpdata+(ImageSize-Linebyte-
                heigth*Linebyte)+width;
           
            pdest = (unsigned char *)pNewbmpdata+(ImageSize-Linebyte-
                heigth*Linebyte)+width;

j=0;
            result=0;

for ( i =  - TemplateCertel.cy ; i <  TemplateSize.cy - TemplateCertel.cy   ;i++)
            {
                for (k =  - TemplateCertel.cx ; k <  TemplateSize.cx -TemplateCertel.cy  ;k++)
                {
                            result += (LONG)(*(psrc + i * Linebyte + k)) * template_box[j++];
                }
            }

result = (LONG)(result  *  coef);

if (result>255)
            {
                result=255;
            }
            if (result<0)
            {
                result=0;
            }
            *pdest=(unsigned char)result;
           
        }
    }   
    memcpy(pbmpdata,pNewbmpdata,ImageSize);
    free(pNewbmpdata);
    return TRUE;
}

http://www.2cto.com/kf/201306/220419.html 对美女图像的缩小 图像处理之高斯金字塔java

http://bbs.csdn.net/topics/360109272

http://blog.csdn.net/fanner01/article/details/6525270 Gaussian Smoothing Filter高斯平滑滤波器

http://blog.csdn.net/zhengtu009/article/details/21862353 滤波器设计，包括相关高斯建模，跟踪！

http://wenku.baidu.com/link?url=Z9F4EUkVxkYIAlbi7cueVEyu-rStz-4tgDvri1MM83F2RPW2vLk-xSQX7pN0lfrZ0ADsMuo6OkEEbBq2Sy4sKYUTntvOhv7r15K8gBUi_-G 基于dm6437的 canny 边缘检测

http://www.google.co.uk/patents/US6046654 高斯专利

http://d.wanfangdata.com.cn/Periodical_gxjs200703024.aspx  一种尺度自适应调整的高斯滤波器设计方法

http://www.cvchina.info/2010/05/07/diving-into-gaussian-filter-implementation/  高斯函数计算中sigma的确定！！！

http://www.cnblogs.com/JohnShao/archive/2011/06/02/2067800.html 高斯二维转一维

http://www.cnblogs.com/JohnShao/archive/2011/08/24/2151463.html

http://blog.csdn.net/hhygcy/article/details/4329056 c++实现

http://blog.csdn.net/l_inyi/article/details/8915116 opencv  实现

http://www.verydemo.com/demo_c113_i8816.html matlab 实现

http://blog.csdn.net/pyramide/article/details/5588880  高斯卷积4种实现方法

http://www.tudou.com/programs/view/NsvOZtjS1Zo/#http://www.tudou.com/programs/view/BxfgcVCnzk8/ 高斯滤波游戏中的应用魔兽

http://www.geeks3d.com/20100909/shader-library-gaussian-blur-post-processing-filter-in-glsl/  美女图片3d 效果

http://prideout.net/archive/bloom/ pengl

http://blog.csdn.net/pyramide/article/details/5588979 高斯简介

时间： 2024-12-27 23:07:02

图像处理之基础---滤波器之高斯低通滤波器3c代码实现yuv，rgb的相关文章

图像处理之基础---滤波器之高斯低通滤波器的高斯模板生成c实现

()代码实现 对原图进行高斯平滑,去除图像中的计算噪声void Bmp::MakeGauss(double sigma,double **pdKernel,int *pnWindowSize){ //循环控制变量 int i; //数组的中心点 int nCenter; //数组的某一点到中心点的距离 double dDis; //中间变量 double dValue; double dSum; dSum = 0; //数组长度,根据概率论的知识,选取[-3*sigma,3*sigma]以内的数

图像处理之基础---滤波器 高斯滤波

引用 keendawn 的 高斯(核)函数简介 1函数的基本概念 所谓径向基函数 (Radial Basis Function 简称 RBF), 就是某种沿径向对称的标量函数. 通常定义为空间中任一点x到某一中心xc之间欧氏距离的单调函数 , 可记作 k(||x-xc||), 其作用往往是局部的 , 即当x远离xc时函数取值很小.最常用的径向基函数是高斯核函数 ,形式为 k(||x-xc||)=exp{- ||x-xc||^2/(2*σ)^2) } 其中xc为核函数中心,σ为函数的宽度参数 ,

图像处理之基础---卷积，滤波，平滑

/*今天师弟来问我,CV的书里到处都是卷积,滤波,平滑……这些概念到底是什么意思,有什么区别和联系,瞬间晕菜了,学了这么久CV,卷积,滤波,平滑……这些概念每天都念叨好几遍,可是心里也就只明白个大概的意思,赶紧google之~ 发现自己以前了解的真的很不全面,在此做一些总结,以后对这种基本概念要深刻学习了~*/ 1.图像卷积(模板) (1).使用模板处理图像相关概念: 模板:矩阵方块,其数学含义是一种卷积运算. 卷积运算:可看作是加权求和的过程,使用到的图像区域中的每个像素分别于卷积核(权矩阵)

Atitit &#160;&#160;图像处理&#160;平滑&#160;也称&#160;模糊,&#160;归一化块滤波、高斯滤波、中值滤波、双边滤波）

Atitit   图像处理 平滑 也称 模糊, 归一化块滤波.高斯滤波.中值滤波.双边滤波) 是一项简单且使用频率很高的图像处理方法 用途 去噪 去雾 各种线性滤波器对图像进行平滑处理,相关OpenCV函数如下: 归一化块滤波器 (Normalized Box Filter) § 最简单的滤波器, 输出像素值是核窗口内像素值的 均值 ( 所有像素加权系数相等) § 高斯滤波器 (Gaussian Filter) § 最有用的滤波器 (尽管不是最快的). 高斯滤波是将输入数组的每一个像素点与 高斯

学习 opencv---(7) 线性邻域滤波专场：方框滤波，均值滤波，高斯滤波

本篇文章中,我们一起仔细探讨了OpenCV图像处理技术中比较热门的图像滤波操作.图像滤波系列文章浅墨准备花两次更新的时间来讲,此为上篇,为大家剖析了"方框滤波","均值滤波","高斯滤波"三种常见的邻域滤波操作.而作为非线性滤波的"中值滤波"和"双边滤波",我们下次再分析. 因为文章很长,如果详细啃的话,或许会消化不良.在这里给大家一个指引,如果是单单想要掌握这篇文章中讲解的OpenCV线性滤波相关的三个函

图像处理之基础---卷积去噪

讨论如何使用卷积作为数学工具来处理图像,实现图像的滤波,其方法包含以下几种,均值 滤波,中值滤波,最大最小值滤波,关于什么是卷积以及理解卷积在图像处理中作用参见这 里–http://blog.csdn.net/jia20003/article/details/7038938 均值滤波: 均值滤波,是图像处理中最常用的手段,从频率域观点来看均值滤波是一种低通滤波器,高 频信号将会去掉,因此可以帮助消除图像尖锐噪声,实现图像平滑,模糊等功能.理想的均 值滤波是用每个像素和它周围像素计算出来的平均值替

图像处理之基础---卷积模板简介

1.使用模板处理图像相关概念:       模板:矩阵方块,其数学含义是一种卷积运算. 卷积运算:可看作是加权求和的过程,使用到的图像区域中的每个像素分别与卷积核(权矩阵)的每个元素对应相乘,所有乘积之和作为区域中心像素的新值. 卷积核:卷积时使用到的权,用一个矩阵表示,该矩阵与使用的图像区域大小相同,其行.列都是奇数,是一个权矩阵. 卷积示例: 假设3 * 3的像素区域R与卷积核G分别为: 则卷积运算为: R5(中心像素)=R1G1 + R2G2 + R3G3 + R4G4 + R5G5 +

图像处理之基础---频域分析

1.频域值得坐标轴 1.在傅里叶变换中,低频主要决定图像在平滑区域中总体灰度级的现实,而高频决定图像细节部分,如边缘和噪声: 滤波器: 使低频通过而使高频衰减的滤波器称为“低通滤波器” 相反特性的滤波器 称为“高通滤波器” 被低通滤波的图像比原始图像少了一些尖锐的细节部分,因为高频部分已被衰减.同样,被高通滤波的图像在平滑区域 中将减少一些灰度 级的变化,并突出过渡(边缘)灰度级的细节.这样的图像将更为锐化 preference:http://www.cnblogs.com/itchq/p/38

数学之路-python计算实战(18)-机器视觉-滤波去噪(双边滤波与高斯滤波 )

高斯滤波就是对整幅图像进行加权平均的过程,每一个像素点的值,都由其本身和邻域内的其他像素值经过加权平均后得到.高斯滤波的具体操作是:用一个模板(或称卷积.掩模)扫描图像中的每一个像素,用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值. #滤波去噪 lbimg=cv2.GaussianBlur(newimg,(3,3),1.8) cv2.imshow('src',newimg) cv2.imshow('dst',lbimg) cv2.waitKey() cv2.destroyAllW