图像处理（八）图像滤波

最新推荐文章于 2023-03-26 13:42:22 发布
最新推荐文章于 2023-03-26 13:42:22 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： 图像处理 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoyk1990/article/details/8146618
版权
本文介绍了图像处理中的均值滤波和中值滤波，均值滤波通过邻域平均值减少噪声但可能导致图像模糊，而中值滤波则能有效消除椒盐噪声，保护图像边缘。3*3和5*5的滤波窗口被用于算法实现。
摘要由CSDN通过智能技术生成

均值滤波属于线性滤波方法，中值滤波属于非线性方法。他们都属于空间域内平滑方法。对于给定的图像f(x, y)中的每个像素点(x, y)，取其邻域S­xy，设Sxy含有M个像素，取其平均值做为处理后所得图像像素点(x, y)处的灰度值，该方法称为均值滤波，而取其中值做为处理后所得图像像素带点(x, y)处的灰度，称为中值滤波。

均值滤波方法能有效地抑制噪声，但同时也由于平均而引起了模糊现象，模糊程度与邻域半径成正比，中值滤波方法主要功能是让周围像素灰度值差别比较大的像素改为选取与周围的像素值接近的值，从而可以消除孤立的噪声点，所以中值滤波对于滤除图像昂的椒盐噪声非常有效，中值滤波可以做到既去除噪声又能保护图像的边缘，从而获得较满意的复原效果。

下面是算法的具体实现，采用的滤波窗口大小为3*3和5*5（附，获取图像颜色类型方法：灰度、二值、24位彩色）

 
    /// <summary>
    /// 图像格式类型
    /// </summary>
    public enum ImageFormats {
        /// <summary>
        /// 二值图
        /// </summary>
        BinaryzationFormat = 1,
        /// <summary>
        /// 灰度图
        /// </summary>
        GrayFormat = 2,
        /// <summary>
        /// 彩色图
        /// </summary>
        ColorFormat = 3,
        /// <summary>
        /// 未知
        /// </summary>
        UnKnown = -1
    }
    /// <summary>
    /// 图像滤波
    /// </summary>
    /// <param name="srcBmp">原始图像</param>
    /// <param name="filteringType">滤波算法类型</param>
    /// <param name="imageFormat">图像颜色格式</param>
    /// <param name="dstBmp">目标图像</param>
    /// <returns>处理成功 true 失败 false</returns>
    public static bool Filtering(Bitmap srcBmp, ScanStruction scanStruction, FilteringType filteringType, ImageFormats imageFormat, out Bitmap dstBmp) {
        if (srcBmp == null) {
            dstBmp = null;
            return false;
        }
        Bitmap grayBmp = null;
        dstBmp = new Bitmap(srcBmp);

        BitmapData bmpDataGray = null;
        if (imageFormat == ImageFormats.ColorFormat) {
            ToGray(srcBmp, out grayBmp);
            bmpDataGray = grayBmp.LockBits(new Rectangle(0, 0, grayBmp.Width, grayBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
        }

        BitmapData bmpDataSrc = srcBmp.LockBits(new Rectangle(0, 0, srcBmp.Width, srcBmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
        BitmapData bmpDataDst = dstBmp.LockBits(new Rectangle(0, 0, dstBmp.Width, dstBmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
        unsafe {
            byte[] grayValueArray = new byte[25];
            long[] index = new long[25];
            for (int i = 0; i < 25; i++) {
                grayValueArray[i] = 255;
            }
            byte* ptrSrc = (byte*)bmpDataSrc.Scan0;
            byte* ptrDst = (byte*)bmpDataDst.Scan0;
            byte* ptrGray = null;
            if (imageFormat == ImageFormats.ColorFormat) {
                ptrGray = (byte*)bmpDataGray.Scan0;
            }
             switch (filteringType) {
                case FilteringType.MedianFiltering://中值滤波
                    switch (scanStruction) {
                        case ScanStruction.Horizontal3Bits:
                            for (int i = 0; i < bmpDataSrc.Height; i++) {
                                for (int j = 0; j < bmpDataSrc.Width; j++) {
                                    if (imageFormat == ImageFormats.ColorFormat) {
                                        grayValueArray[0] = ptrGray[Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[1] = ptrGray[Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + j * 3];
                                        grayValueArray[2] = ptrGray[Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[3] = ptrGray[i * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[4] = ptrGray[i * bmpDataSrc.Stride + j * 3];
                                        grayValueArray[5] = ptrGray[i * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[6] = ptrGray[(i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[7] = ptrGray[(i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + j * 3];
                                        grayValueArray[8] = ptrGray[(i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3];
                                        index[0] = Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3;
                                        index[1] = Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + j * 3;
                                        index[2] = Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3;
                                        index[3] = i * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3;
                                        index[4] = i * bmpDataSrc.Stride + j * 3;
                                        index[5] = i * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3;
                                        index[6] = (i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3;
                                        index[7] = (i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + j * 3;
                                        index[8] = (i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3;
                                        Array.Sort(grayValueArray, index);
                                        ptrDst[i * bmpDataDst.Stride + j * 3] = ptrSrc[index[4]];
                                        ptrDst[i * bmpDataDst.Stride + j * 3 + 1] = ptrSrc[index[4] + 1];
                                        ptrDst[i * bmpDataDst.Stride + j * 3 + 2] = ptrSrc[index[4] + 2];

                                    }
                                    else {
                                        grayValueArray[0] = ptrSrc[Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[1] = ptrSrc[Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + j * 3];
                                        grayValueArray[2] = ptrSrc[Math.Abs(i - 1) % bmpDataSrc.Height * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[3] = ptrSrc[i * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[4] = ptrSrc[i * bmpDataSrc.Stride + j * 3];
                                        grayValueArray[5] = ptrSrc[i * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[6] = ptrSrc[(i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[7] = ptrSrc[(i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + j * 3];
                                        grayValueArray[8] = ptrSrc[(i + 1) % bmpDataSrc.Height * bmpDataSrc.Stride + (j + 1) % bmpDataSrc.Width * 3];
                                        Array.Sort(grayValueArray);
                                        ptrDst[i * bmpDataDst.Stride + j * 3] = (byte)grayValueArray[4];
                                        ptrDst[i * bmpDataDst.Stride + j * 3 + 1] = (byte)grayValueArray[4];
                                        ptrDst[i * bmpDataDst.Stride + j * 3 + 2] = (byte)grayValueArray[4];
                                    }

                                }
                            }
                            break;
                        case ScanStruction.Square5Bits://5*5
                            for (int i = 0; i < bmpDataSrc.Height; i++) {
                                for (int j = 0; j < bmpDataSrc.Width; j++) {
                                    if (imageFormat == ImageFormats.ColorFormat) {
                                        grayValueArray[0] = ptrGray[Math.Abs(i - 2) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 2) % bmpDataSrc.Width * 3];
                                        grayValueArray[1] = ptrGray[Math.Abs(i - 2) % bmpDataSrc.Height * bmpDataSrc.Stride + Math.Abs(j - 1) % bmpDataSrc.Width * 3];
                                        grayValueArray[2] = ptrGray[Math.Abs(i - 2) % bmpDataSrc.Height * bmpDataSrc.Stride +
最低0.47元/天 解锁文章
KUN_Guo
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图像处理中滤波算法——均值滤波—中值滤波—高斯滤波等
AccFPGA的博客
04-02 9164
图像中的噪声 噪声的来源：数字图像的噪声主要产生于获取、传输图像的过程中。在获取图像的过程中，摄像机组件的运行情况受各种客观因素的影响，包括图像拍摄的环境条件和摄像机的传感元器件质量在内都有可能会对图像产生噪声影响。在传输图像的过程中，传输介质所遇到的干扰也会引起图像噪声，如通过无线电网络传输的图像可能因为光或其他大气因素被加入噪声信号。 图像去噪意义：图像去噪是指减少数字图像中噪声的过程，广...
ZYNQ图像处理(6)——均值滤波和中值滤波
qq_40995480的博客
09-13 1万+
FPGA图像处理，均值和中值滤波
【数字图像处理实验三】：均值滤波、中值滤波、高斯滤波及其在椒盐噪声与高斯噪声图像的应用对比
Stick_2
07-07 9708
本篇介绍均值滤波、中值滤波、高斯滤波的代码实现以及它们在椒盐噪声与高斯噪声图像中去噪效果的对比均值滤波指在图像上对目标像素（指具体某一个坐标的像素）给一个模板，该模板包括目标像素本身及其周围的临近像素，再用模板中的全体像素的平均值来代替原来像素值。均值滤波用卷积实现，其卷积核大小常见的有3×3，5×5，7×7等，如下就是3×3的卷积核，因为是用全体像素的平均值来代替原来像素值，所以可以认为模板上每一处权重都一样，又这里是3×3的卷积核，所以都是1/9，具体操作就是两个矩阵点乘之后再相加。 代码如下： 结果如
Opencv图像识别常用的处理算法
Yfw的博客
12-26 3602
image格式转换： # OpenCV图片转换为PIL image def CVImageToPIL(image): return Image.fromarray(cv.cvtColor(img, cv.COLOR_BGR2RGB)) 图片锐化处理 def custom_blur_demo(image): kernel = np.array([[0, -1, 0], [-1, ...
图像处理-图像滤波
xdg15294969271的博客
11-10 7498
文章目录1、图像滤波2、各滤波特点2.1 均值滤波2.1.1原理2.1.2 优点2.1.3 缺点2.2 高斯滤波2.2.1 原理2.3中值滤波2.3.1 原理2.3.2 优点2.3.3缺点3、案例分析3.1 均值滤波3.1.1 代码3.1.2 blur3.2 高斯滤波3.2.1 代码3.2.2 GaussianBlur3.3 中值滤波3.3.1 代码3.3.2 medianBlur3.4 完整代码4、效果展示4.1 均值滤波4.2 高斯滤波4.3 中值滤波 1、图像滤波 所谓滤波，顾名思义，能够起到图像过滤
图像处理——中值滤波
热门推荐
lixiao0314的博客
10-25 6万+
中值滤波 【定义】中值滤波是一种非线性的信号处理方法，所以它是一种非线性滤波器，也是一种统计排序滤波器。它将每一像素点的灰度值设置为该点某邻域窗口内的所有像素点灰度值的中值。 【目的】中值滤波对孤立的噪声像素即椒盐噪声、脉冲噪声具有良好的滤波效果，可以保持图像的边缘特性，不会使图像产生显著的模糊。 【基本原理/思想】中值滤波是把数字图像或数字序列中一点的值用该点的一个邻域中各点值的中值代替，让周围的像素值接近真实值，从而消除孤立的噪声点。举个例子： 【具体操作/流程】 用一个奇数点的移动窗口，并将模板中心
图像处理：双边滤波算法
最新发布
m0_62919535的博客
03-26 1万+
双边滤波（Bilateral filter）是一种非线性的滤波方法，是结合图像的空间邻近度和像素值相似度的一种折中处理，同时考虑空域信息和灰度相似性，达到保边去噪的目的。具有简单、非迭代、局部的特点。双边滤波器的好处是可以做边缘保存（Edge preserving），一般用高斯滤波去降噪，会较明显地模糊边缘，对于高频细节的保护效果并不明显。双边滤波器之所以能够做到在平滑去噪的同时还能够很好的保存边缘（Edge Preserve），是由于其滤波器的核由两个函数生成：空间域核和值域核。
图像处理之高斯滤波
程序员深度学习
01-28 2723
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(.
Python图像处理八：图像频域滤波
小柒的博客
12-05 5219
图像频谱、频谱图、理想低通滤波器、图像频域低通滤、 Butterworth 低通滤波器、高斯低通滤波器、图像频域高通滤波
图像处理——图像滤波
qq_43199575的博客
10-20 1743
记录下图像处理的一些知识点
维纳滤波图像处理MATLAB程序
04-04
MATLAB处理图像，具体包括原图像显示和噪声处理后图像，接着是维纳滤波后的还原图像，根据图像的实验结果，本程序具有较好的处理性能
matlab关于rgb空间的同态滤波图像处理
07-29
此代码可以直接对彩色图像进行同态滤波处理，处理结果良好，图像纹理清晰 代码有备注，简单易懂
图像滤波处理,图像滤波处理matlab,matlab
09-10
图像滤波处理是数字图像处理中的重要环节，主要用于去除噪声、平滑图像或者增强特定特征。在MATLAB中，我们可以方便地实现各种滤波算法，包括频域滤波和空域滤波。本主题主要关注在MATLAB中进行的频域低通滤波以及...
two_图像滤波处理_
10-02
在图像处理领域，滤波是一种常见的技术，用于改善图像质量或提取特定信息。"two_图像滤波处理_"这个主题涵盖了几个重要的滤波方法，包括高通、低通、中值和均值滤波。这些滤波器在不同的场景下各有其独特作用，下面...
官方Caffe-windows 配置与示例运行
K.U.N. Guo的专栏
10-24 5万+
本文主要介绍官方给出的caffe-windows的配置及如何训练mnist数据集，介绍的比较基础，大神请绕道 1、环境：windows 10\CUDA7.5\cuDNN\VS2013 2、GPU计算环境准备（没有GPU的同学可以跳过此步） （1）首先下载并安装CUDA7.5，下载界面如图1： 图 1：CUDA7.5的下载界面 下载cuDNN，注意要下载cuDNN v4版本，下载界
图像处理（六）灰度形态学腐蚀与膨胀
K.U.N. Guo的专栏
10-31 3万+
灰度图像的腐蚀运算的数学定义为： 其中，g(x,y)为腐蚀后的灰度图像，f(x,y)为原灰度图像，B为结构元素。 用自然语言描述即：           腐蚀运算是由结构元素确定的邻域块中选取图像值与结构元素值的差的最小值。 灰度图像的膨胀运算的数学定义为： 用自然语言描述即：           膨胀运算是由结构元素确定的邻域块中选取图像值与结构元素值的和的最
图像处理（三）直方图匹配
K.U.N. Guo的专栏
10-25 2万+
直方图匹配，又称直方图规定化，即变换原图的直方图为规定的某种形式的直方图，从而使两幅图像具有类似的色调和反差。直方图匹配属于非线性点运算。        直方图规定化的原理：对两个直方图都做均衡化，变成相同的归一化的均匀直方图，以此均匀直方图为媒介，再对参考图像做均衡化的逆运算        以下是算法实现（C#） /// /// 直方图匹配 ///
图像处理（七）给图像添加噪声
K.U.N. Guo的专栏
11-01 2万+
图像中的噪声就是图像中的杂点或者干扰成分，噪声主要产生于图像的获取和传输过程中。噪声一般分为分为加性噪声和乘性噪声。                                     其中f(x,y)表示图像，g(x,y)表示没有噪声的图像部分，q表示噪声。这两种噪声可以通过取对数和指数相互转换：                                     常见的几种
MATLAB空域平滑滤波图像处理程序
在MATLAB中，对图像进行处理是图像处理领域中的重要环节，尤其是对于噪声消除和平滑滤波。空域平滑滤波是一种常见的降噪技术，通过在图像的每个像素周围应用一个滤波器（或权重矩阵）来平均邻近像素的值，以降低噪声...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值