图像处理学习笔记（1）——图像滤波_bitmap 图片添加滤波

参考文章
https://blog.csdn.net/zaishuiyifangxym/article/details/89788020
https://www.cnblogs.com/zbjuke/p/10304863.html
https://www.cnblogs.com/henuliulei/p/10559954.html

图像滤波

图像的频率代表了图像颜色变化的剧烈程度。
低频分量：一幅图中，颜色变化缓慢的部分就叫做低频部分。通常低频是描述图像的主要部分。
高频分量：一幅图中，颜色变化剧烈的部分就叫做高频部分。通常高频是描述图像的边缘、细节或者是噪声。

均值滤波

均值滤波是指任意一点的像素值，都是周围N×M个像素值的均值。例如下图中，红色点的像素值是其周围蓝色背景区域像素值之和除25，25=5×5 是蓝色区域的大小。
并且，5×5的矩阵称为核，针对原始图像内的像素点，采用核进行处理，得到结果图像。
随着核大小逐渐变大，会让图像变得更加模糊。
如果设置为核大小为（1，1），则结果就是原始图像。

中值滤波

中值滤波是非线性的图像处理方法，在去噪的同时可以兼顾到边界信息的保留。选一个含有奇数点的窗口W，将这个窗口在图像上扫描，把窗口中所含的像素点按灰度级的升或降序排列，取位于中间的灰度值来代替该点的灰度值。
随着核大小逐渐变大，会让图像变得更加模糊。
核必须是大于1的奇数，如3、5、7等。

高斯滤波

图像高斯平滑也是邻域平均的思想对图像进行平滑的一种方法，在图像高斯平滑中，对图像进行平均时，不同位置的像素被赋予了不同的权重。高斯平滑与简单平滑不同，它在对邻域内像素进行平均时，给予不同位置的像素不同的权值。
随着核大小逐渐变大，会让图像变得更加模糊。
核大小（N, N）必须是大于1的奇数，如3、5、7等。

效果图

均值滤波效果图，核为（5,5）：

中值滤波效果图，核为（5,5）：

高斯滤波效果图，核为（5，5）：

滤波算法

高斯滤波（高斯模糊，高斯平滑）

作用 ——通过高斯平滑使整个图片过渡均匀平滑，去除细节，过滤掉噪声。
二维高斯分布公式

高斯平滑滤波器用来模糊图像，和均值滤波器差不多，但是和均值滤波器不一样的地方就是核不同。均值滤波器的核每一个值都是相等，而高斯平滑滤波器的核内的数却是呈现高斯分布的。

在网上找到了一个高斯模糊的算法，经试验可以用，记录一下方便之后使用。
算法基于二维高斯分布公式：

//主函数
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;

namespace NetShadow
{
    class Program
    {
        static void Main(string[] args)
        {
            //导入图片
            Image img = Image.FromFile(@"E:/Desktop/66n.jpg");
            //设置模糊半径
            GaussianBlur gBlur = new GaussianBlur(3);
            //设置需要模糊的图片
            gBlur.SetSourceImage(img);
            //获得模糊后的图片
            Bitmap newImage = gBlur.GetBlurImage();
            //输出图片
            if (newImage != null)
                newImage.Save(@"E:\Desktop\66ns.jpg");
            else
                Console.WriteLine("高斯模糊失败！");

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

//新建一个类
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;

namespace NetShadow
{
    /// <summary>
    /// 高斯模糊
    /// </summary>
    public class GaussianBlur
    {
        /// <summary>
        /// 模糊半径
        /// </summary>
        public int BlurRadius { get; private set; }
        private Bitmap SourceImage { get; set; }
        private List<double> BlurArray { get; set; }
        private int MaxWidth { get; set; }
        private int MaxHeight { get; set; }
        //设置模糊半径
        public GaussianBlur(int blurRadius)
        {
            //初始化泛型List<T>,创建指定类型的集合
            BlurArray = new List<double>();
            this.BlurRadius = blurRadius;
            //计算模糊半径范围内所有值的权重
            this.SetBlurArray();
        }
        /// <summary>
        /// 设置需要模糊的图片
        /// </summary>
        /// <param name="img"></param>
        public void SetSourceImage(Image img)
        {
            //得到图片
            this.SourceImage = (Bitmap)img;
            //获得图片的宽度和高度
            this.MaxWidth = this.SourceImage.Width - 1;
            this.MaxHeight = this.SourceImage.Height - 1;
        }
        /// <summary>
        /// 获取模糊之后的图片
        /// </summary>
        /// <returns></returns>
        public Bitmap GetBlurImage()
        {
            //如果图片为空，则返回空值
            if (this.SourceImage == null) return null;
            //否则初始化Bitmap新实例
            Bitmap newImage = new Bitmap(SourceImage.Width, SourceImage.Height);
            //计算模糊后的图片的每个像素值
            for (int y = 0; y < this.SourceImage.Height; y++)
            {
                for (int x = 0; x < this.SourceImage.Width; x++)
                {
                    //获得高斯模糊的颜色值
                    var nC = GetBlurColor(x, y);
                    //return null;
                    //获取此位图中指定像素的颜色
                    newImage.SetPixel(x, y, nC);
                }
            }
            return newImage;
        }

        /// <summary>
        /// 获取高斯模糊的颜色值
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        private Color GetBlurColor(int x, int y)
        {
            double r = 0, g = 0 , b = 0;
            int index = 0;
            for (var t = y - this.BlurRadius; t <= y + this.BlurRadius; t++)
            {
                for (var l = x - this.BlurRadius; l <= x + this.BlurRadius; l++)
                {
                    //得到原图像像素的颜色值
                    var color = GetDefautColor(l, t);
                    //得到计算的权重值
                    var weighValue = BlurArray[index];
                    //RGB原值分别乘权重值得到模糊后的值
                    r += color.R * weighValue;
                    g += color.G * weighValue;
                    b += color.B * weighValue;
                    index++;
                }
            }
            //从指定的颜色值中创建Color结构
            return Color.FromArgb((byte)r, (byte)g, (byte)b);
        }
        //得到原图像像素的颜色值
        private Color GetDefautColor(int x, int y)
        {
            if (x < 0 && y < 0)
                return this.SourceImage.GetPixel(0, 0);
            else if (x < 0)
                return this.SourceImage.GetPixel(0, Math.Min(MaxHeight, y));
            else if (y < 0)
                return this.SourceImage.GetPixel(Math.Min(MaxWidth, x), 0);
            else
                return this.SourceImage.GetPixel(Math.Min(MaxWidth, x), Math.Min(MaxHeight, y));
        }
        //计算模糊半径范围内值的权重值
        private void SetBlurArray()
        {
            int blur = this.BlurRadius;
            double sum = 0;
            for (var y = blur; y >= blur * -1; y--)
            {
                for (var x = blur * -1; x <= blur; x++)
                { 
                    //计算各坐标的权重值                   
                    var d = GetWeighing(x, y);
                    //将权重值加到List<T>的结尾处
                    this.BlurArray.Add(d);
                    //计算所有值的总和，这里和应该小于1
                    sum += d;
                }
            }
            //将模糊半径范围内的所有值分别除以所有值总和sum，使得他们的和为1
            for (var i = 0; i < this.BlurArray.Count; i++)
                this.BlurArray[i] = this.BlurArray[i] / sum;
        }
        /// <summary>
        /// 获取权重
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        //计算各坐标的权重值
        private double GetWeighing(int x, int y)
        {
            //根据二维公式计算的
            double q = (this.BlurRadius * 2 + 1) / 2; 
            return 1 / (2 * Math.PI * Math.Pow(q, 2)) * Math.Exp(-(x * x + y * y) / (2 * q * q));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

效果图（模糊半径分别为1和2）


可以看到，模糊半径越大，去噪效果越好。但是图片也会变得越模糊，所以应该根据需求选择合适的模糊半径。