如何理解卷积：信号处理、图像处理中的应用

╰半橙微兮° 2022-07-14 11:24 331阅读 0赞

# 信号与系统中的卷积解释 #

作者：张俊博  
链接： [https://www.zhihu.com/question/22298352/answer/34267457][https_www.zhihu.com_question_22298352_answer_34267457]  
来源：知乎  
著作权归作者所有，转载请联系作者获得授权。  
  
**不推荐用“反转/翻转/反褶/对称”等解释卷积。好好的信号为什么要翻转？**导致学生难以理解卷积的物理意义。  
这个其实非常简单的概念，国内的大多数教材却没有讲透。  
  
直接看图，不信看不懂。以离散信号为例，连续信号同理。  
  
已知 ![x\[0\] = a, x\[1\] = b, x\[2\]=c][x_0_ _ a_ x_1_ _ b_ x_2_c]  
![153fd3e7911d486edaf0475afb1e54b3_b.png][]  
  
已知 ![y\[0\] = i, y\[1\] = j, y\[2\]=k][x_0_ _ a_ x_1_ _ b_ x_2_c]  
![c47d9d7f7a29c491782bf7b1baea3f8e_b.png][]  
  
下面通过演示求 ![x\[n\] \* y\[n\]][x_0_ _ a_ x_1_ _ b_ x_2_c]的过程，揭示卷积的物理意义。  
  
第一步， ![x\[n\]][x_0_ _ a_ x_1_ _ b_ x_2_c]乘以 ![y\[0\]][x_0_ _ a_ x_1_ _ b_ x_2_c]并平移到位置0：  
![91f5eff235013ac729c44e98b3a537d0_b.png][]  
第二步， ![x\[n\]][x_0_ _ a_ x_1_ _ b_ x_2_c]乘以 ![y\[1\]][x_0_ _ a_ x_1_ _ b_ x_2_c]并平移到位置1：  
![67c05239b05f671766b9df9393026f2c_b.png][]  
第三步， ![x\[n\]][x_0_ _ a_ x_1_ _ b_ x_2_c]乘以 ![y\[2\]][x_0_ _ a_ x_1_ _ b_ x_2_c]并平移到位置2：  
  
![preview][]  
最后，把上面三个图叠加，就得到了 ![x\[n\] \* y\[n\]][x_0_ _ a_ x_1_ _ b_ x_2_c]：  
![preview][preview 1]  
简单吧？无非是 **平移（没有反褶！）、叠加。**  
  
  
从这里，可以看到卷积的重要的物理意义是：一个函数（如：单位响应）在另一个函数（如：输入信号）上的 **加权叠加。**  
  
  
重复一遍，这就是卷积的意义： **加权叠加**。  
  
对于线性时不变系统，如果知道该系统的单位响应，那么将单位响应和输入信号求卷积，就相当于把输入信号的各个时间点的单位响应 加权叠加，就直接得到了输出信号。  
  
  
通俗的说：  
**在输入信号的每个位置，叠加一个单位响应，就得到了输出信号。**  
这正是单位响应是如此重要的原因。  
  
**在输入信号的每个位置，叠加一个单位响应，就得到了输出信号。**  
这正是单位响应是如此重要的原因。  
  
**在输入信号的每个位置，叠加一个单位响应，就得到了输出信号。**  
这正是单位响应是如此重要的原因。

总结：在横坐标为2时，卷积值为ci+bj+ak， **类似**于向量的乘积形式。

====================================================

# [关于卷积的一个血腥的讲解][Link 1] #

如果还是不能深层次理解卷积，看看人人网一个牛人的讲解，笑喷了。

比如说你的老板命令你干活，你却到楼下打台球去了，后来被老板发现，他非常气愤，扇了你一巴掌（注意，这就是输入信号，脉冲），于是你的脸上会渐渐地（贱贱地）鼓起来一个包，你的脸就是一个系统，而鼓起来的包就是你的脸对巴掌的响应，好，这样就和信号系统建立起来意义对应的联系。下面还需要一些假设来保证论证的严谨：假定你的脸是线性时不变系统，也就是说，无论什么时候老板打你一巴掌，打在你脸的同一位置（这似乎要求你的脸足够光滑，如果你说你长了很多青春痘，甚至整个脸皮处处连续处处不可导，那难度太大了，我就无话可说了哈哈），你的脸上总是会在相同的时间间隔内鼓起来一个相同高度的包来，并且假定以鼓起来的包的大小作为系统输出。好了，那么，下面可以进入核心内容——卷积了！

如果你每天都到地下去打台球，那么老板每天都要扇你一巴掌，不过当老板打你一巴掌后，你5分钟就消肿了，所以时间长了，你甚至就适应这种生活了……如果有一天，老板忍无可忍，以0.5秒的间隔开始不间断的扇你的过程，这样问题就来了，第一次扇你鼓起来的包还没消肿，第二个巴掌就来了，你脸上的包就可能鼓起来两倍高，老板不断扇你，脉冲不断作用在你脸上，效果不断叠加了，这样这些效果就可以求和了，结果就是你脸上的包的高度随时间变化的一个函数了（注意理解）；如果老板再狠一点，频率越来越高，以至于你都辨别不清时间间隔了，那么，求和就变成积分了。可以这样理解，在这个过程中的某一固定的时刻，你的脸上的包的鼓起程度和什么有关呢？和之前每次打你都有关！但是各次的贡献是不一样的，越早打的巴掌，贡献越小，所以这就是说，某一时刻的输出是之前很多次输入乘以各自的衰减系数之后的叠加而形成某一点的输出，然后再把不同时刻的输出点放在一起，形成一个函数，这就是卷积，卷积之后的函数就是你脸上的包的大小随时间变化的函数。本来你的包几分钟就可以消肿，可是如果连续打，几个小时也消不了肿了，这难道不是一种平滑过程么？反映到剑桥大学的公式上，f(a)就是第a个巴掌，g(x-a)就是第a个巴掌在x时刻的作用程度，乘起来再叠加就ok了，大家说是不是这个道理呢？我想这个例子已经非常形象了，你对卷积有了更加具体深刻的了解了吗？

====================================================

# 图像处理中的卷积运用 #

转载自： [http://blog.csdn.net/zouxy09/article/details/49080029][http_blog.csdn.net_zouxy09_article_details_49080029]

**一、线性滤波与卷积的基本概念**

线性滤波可以说是图像处理最基本的方法，它可以允许我们对图像进行处理，产生很多不同的效果。做法很简单。首先，我们有一个**二维的滤波器矩阵（有个高大上的名字叫卷积核）**和一个要处理的二维图像。然后，对于图像的每一个像素点，计算它的邻域像素和滤波器矩阵的对应元素的乘积，然后加起来，作为该像素位置的值。这样就完成了滤波过程。

![Center][]

对图像和滤波矩阵进行逐个元素相乘再求和的操作就相当于将一个二维的函数移动到另一个二维函数的所有位置，**这个操作就叫卷积或者协相关**。卷积和协相关的差别是，**卷积需要先对滤波矩阵（卷积核）进行180°的翻转**，但如果矩阵是对称的，那么两者就没有什么差别了。(注解：180°的翻转相当于矩阵的顺序变为倒序，感觉对称矩阵也是有影响的)

Correlation 和 Convolution可以说是图像处理最基本的操作，但却非常有用。**这两个操作有两个非常关键的特点：它们是线性的，而且具有平移不变性shift-invariant。**平移不变性指我们在图像的每个位置都执行相同的操作。线性指这个操作是线性的，也就是我们用每个像素的邻域的线性组合来代替这个像素。这两个属性使得这个操作非常简单，因为线性操作是最简单的，然后在所有地方都做同样的操作就更简单了。

实际上，在信号处理领域，卷积有广泛的意义，而且有其严格的数学定义，但在这里不关注这个。

2D卷积需要4个嵌套循环4-double loop，所以它并不快，除非我们使用很小的卷积核。这里一般使用3x3或者5x5。而且，对于滤波器，也有一定的规则要求：

1）滤波器的大小应该是奇数，这样它才有一个中心，例如3x3，5x5或者7x7。有中心了，也有了半径的称呼，例如5x5大小的核的半径就是2。

2）滤波器矩阵所有的元素之和应该要等于1，这是为了保证滤波前后图像的亮度保持不变。当然了，这不是硬性要求了。

3）如果滤波器矩阵所有元素之和大于1，那么滤波后的图像就会比原图像更亮，反之，如果小于1，那么得到的图像就会变暗。如果和为0，图像不会变黑，但也会非常暗。

4）对于滤波后的结构，可能会出现负数或者大于255的数值。对这种情况，我们将他们直接截断到0和255之间即可。对于负数，也可以取绝对值。

**二、神奇的卷积核**

上面说到，对图像的滤波处理就是对图像应用一个小小的卷积核，那这个小小的卷积核到底有哪些魔法，能让一个图像从惨不忍睹变得秀色可餐。下面我们一起来领略下一些简单但不简单的卷积核的魔法。

**2.1、啥也不做**

哈哈，大家可以看到啥了吗？这个滤波器啥也没有做，得到的图像和原图是一样的。因为只有中心点的值是1。邻域点的权值都是0，对滤波后的取值没有任何影响。

![Center 1][]

下面我们动点真格的。

**2.2、图像锐化滤波器Sharpness Filter**

图像的锐化和边缘检测很像，首先找到边缘，然后把边缘加到原来的图像上面，这样就强化了图像的边缘，使图像看起来更加锐利了。这两者操作统一起来就是锐化滤波器了，也就是在边缘检测滤波器的基础上，再在中心的位置加1，这样滤波后的图像就会和原始的图像具有同样的亮度了，但是会更加锐利。

![Center 2][]

我们把核加大，就可以得到更加精细的锐化效果

![Center 3][]

另外，下面的滤波器会更强调边缘：

![Center 4][]

主要是强调图像的细节。最简单的3x3的锐化滤波器如下：

![Center 5][]

**实际上是计算当前点和周围点的差别，然后将这个差别加到原来的位置上。**另外，中间点的权值要比所有的权值和大于1，意味着这个像素要保持原来的值。

**2.3、边缘检测Edge Detection**

我们要找水平的边缘：**需要注意的是，这里矩阵的元素和是0，所以滤波后的图像会很暗**，只有边缘的地方是有亮度的。

![Center 6][]

为什么这个滤波器可以寻找到水平边缘呢？**因为用这个滤波器卷积相当于求导的离散版本**：**你将当前的像素值减去前一个像素值，这样你就可以得到这个函数在这两个位置的差别或者斜率。**下面的滤波器可以找到垂直方向的边缘，这里像素上和下的像素值都使用：

![Center 7][]

再下面这个滤波器可以找到45度的边缘：取-2不为了什么，只是为了让矩阵的元素和为0而已。

![Center 8][]

那下面这个滤波器就可以检测所有方向的边缘:

![Center 9][]

为了检测边缘，我们需要在图像对应的方向计算梯度。用下面的卷积核来卷积图像，就可以了。但在实际中，这种简单的方法会把噪声也放大了。另外，需要注意的是，**矩阵所有的值加起来要是0.**

![Center 10][]

**2.4、浮雕Embossing Filter**

浮雕滤波器可以给图像一种3D阴影的效果。只要将中心一边的像素减去另一边的像素就可以了。这时候，像素值有可能是负数，我们将负数当成阴影，将正数当成光，然后我们对结果图像加上128的偏移。这时候，图像大部分就变成灰色了。

下面是45度的浮雕滤波器

![Center 11][]

我们只要加大滤波器，就可以得到更加夸张的效果了

![Center 12][]

这种效果非常的漂亮，就像是将一副图像雕刻在一块石头上面一样，然后从一个方向照亮它。它和前面的滤波器不同，它是非对称的。另外，它会产生负数值，所以我们需要将结果偏移，以得到图像灰度的范围。

![Center 13][]

![Center 14][]

A：原图像。B：锐化。C：边缘检测。D：浮雕

**2.5、均值模糊Box Filter (Averaging)**

我们可以将当前像素和它的四邻域的像素一起取平均，然后再除以5，或者直接在滤波器的5个地方取0.2的值即可，如下图：

![Center 15][]

可以看到，这个模糊还是比较温柔的，我们可以把滤波器变大，这样就会变得粗暴了：注意要将和再除以13.

![Center 16][]

所以，如果你想要更模糊的效果，加大滤波器的大小即可。或者对图像应用多次模糊也可以。

![Center 17][]

![Center 18][]

**2.6、高斯模糊**

均值模糊很简单，但不是很平滑。**高斯模糊（也叫“高斯平滑”）就有这个优点，所以被广泛用在图像降噪上。特别是在边缘检测之前，都会用来移除细节。高斯滤波器是一个低通滤波器。高斯分布就是正态分布。正态分布是一种钟形曲线，越接近中心，取值越大，越远离中心，取值越小。计算平均值的时候，我们只需要将"中心点"作为原点，其他点按照其在正态曲线上的位置，分配权重，就可以得到一个加权平均值。**

![Center 19][]

![Center 20][]

**2.7、运动模糊Motion Blur**

运动模糊可以通过只在一个方向模糊达到，例如下面9x9的运动模糊滤波器。注意，**求和结果要除以9**。

![Center 21][]

这个效果就好像，摄像机是从左上角移动的右下角。

**三、卷积的计算**

对图像处理而言，存在两大类的方法：空域处理和频域处理！空域处理是指直接对原始的像素空间进行计算，频率处理是指先对图像变换到频域，再做滤波等处理。

**3.1、空域计算-直接2D卷积**

**3.1.1、2D卷积**

直接2D卷积就是一开始说的那样，对于图像的每一个像素点，计算它的邻域像素和滤波器矩阵的对应元素的乘积，然后加起来，作为该像素位置的值。

![Center 22][]

直接的实现也称为暴力实现brute force，因为它严格按照定义来实现，没有任何优化。当然了，在并行实现里面，它也是比较灵活的。另外，也存在一个优化版本，如果我们的kernel是separable可分的，那么就可以得到一个**快5倍左右的卷积方法**。

**2.1.2、边界处理**

那卷积核遇到图像边缘怎么办？例如图像顶部的像素，它的上面已经没有像素了，那么它的值如何计算？目前有四种主流的处理方法，我们用**一维卷积和均值滤波**来说明下。

我们在1D图像中，用每个像素和它的二邻域的平均值来取代它的值。假设我们有个1D的图像I是这样的：

![Center 23][]

对非图像边界的像素的操作比较简单。假设我们对I的第四个像素3做局部平均。也就是我们用2,3和7做平均，来取代这个位置的像素值。也就是，平均会产生一副新的图像J，这个图像在相同位置J (4) = (I(3)+I(4)+I(5))/3 = (2+3+7)/3 = 4。同样，我们可以得到J(3) = (I(2)+I(3)+I(4))/3 =(4+2+3)/3 = 3。需要注意的是，新图像的每个像素都取决于旧的图像，在计算J (4)的时候用J (3)是不对的，而是用I(3)，I(4)和I(5)。所以每个像素都是它和它邻域两个像素的平均。平均是线性的操作，因为每个新的像素都是旧像素的线性组合。

![Center 24][]

对卷积，也有必须要考虑的情况是，在图像边界的时候，怎么办？J(1)的值应该是什么？它取决于I(0)，I(1)和I(2)。但是我们没有I(0)呀！图像左边没有值了。有四种方式来处理这个问题：

1）第一种就是想象I是无限长的图像的一部分，除了我们给定值的部分，其他部分的像素值都是0。在这种情况下，I(0)=0。所以J(1) = (I(0) + I(1) + I(2))/3 = (0 + 5 + 4)/3= 3. 同样，J(10) = (I(9)+I(10)+I(11))/3 = (3+ 6 + 0)/3 = 3.

![Center 25][]

2）第二种方法也是想象I是无限图像的一部分。但没有指定的部分是用图像边界的值进行拓展。在我们的例子中，因为图像I最左边的值I(1)=5，所以它左边的所有值，我们都认为是5 。而图像右边的所有的值，我们都认为和右边界的值I(10)一样，都是6。这时候J(1) = (I(0) + I(1) + I(2))/3 = (5 + 5 + 4)/3= 14/3. 而J(10) = (I(9)+I(10)+I(11))/3 = (3 + 6 + 6)/3 = 5。

![Center 26][]

3）第三种情况就是认为图像是周期性的。也就是I不断的重复。周期就是I的长度。在我们这里，I(0)和I(10)的值就是一样的，I(11)的值和I(1)的值也是一样的。所以J(1) = (I(0) + I(1) + I(2))/3= (I(10) + I(1)+ I(2))/3 = (6 + 5 + 4)/3 = 5 。

![Center 27][]

4）最后一种情况就是不管其他地方了。我们觉得I之外的情况是没有定义的，所以没办法使用这些没有定义的值，所以要使用图像I没有定义的值的像素都没办法计算。在这里，J(1)和J(10)都没办法计算，所以输出J会比原图像I要小。

这四种方法有各自的优缺点。如果我们想象我们使用的图像只是世界的一个小窗口，然后我们需要使用窗口边界外的值，那么一般来说，外面的值和边界上的值是几乎相似的，所以第二种方法可能更说得过去。

**2.2、频域计算-快速傅里叶变换FFT卷积（此处没看懂）**

这个快速实现得益于**卷积定理：时域上的卷积等于频域上的乘积。**所以将我们的图像和滤波器通过[算法][Link 2]变换到频域后，直接将他们相乘，然后再变换回时域（也就是图像的空域）就可以了。

![Center 28][]

o表示矩阵逐元素相乘。那用什么方法将空域的图像和滤波器变换到频域呢？那就是鼎鼎大名的Fast Fourier Transformation**快速傅里叶变换FFT**（其实，在CUDA里面，已经实现了FFT了）。

要在频域中对一副图像进行滤波，**滤波器的大小和图像的大小必须要匹配，这样两者的相乘才容易**。因为一般滤波器的大小比图像要小，所以我们需要拓展我们的kernel，让它和图像的大小一致。

![Center 29][]

因为CUDA中的FFT实现是周期的，所以kernel的值也要安排成这样，以支持这种周期性。

为了保证图像边界的像素也可以得到响应输出，我们也需要拓展我们的输入图像。同时，拓展的方式也要支持周期表达。

![Center 30][]

如果只是使用卷积定理，没有对输入进行任何修改的话，那么我们得到的是周期卷积的结果。但这可能不是我们要的，因为周期卷积会对输入数据进行周期填补，引入一些artifacts。

给定N长度的I和K，为了得到线性卷积，我们需要对I和K进行zero padding。为什么要补0，因为DFT假定了输入是无限和周期的，周期是N。

![Center 31][]

如上图，对于I和K，如果没有padding的话，隐含着会假定I和K是周期的，以他们的长度N为周期。图中本来N长度的I和K都是黑色虚线的部分，然后如果没有padding，隐含着就会在N之外，加上同样的无数个I，如红色虚线部分，加上了一个周期。对K也是这样。如果是zero padding的话，在黑色虚线的其他地方都全是0了，如图中蓝色部分。将I和K卷积，如果没有padding，如黑色虚线，会有红色那部分的artifact。如果有padding，就是蓝色实线。

**四、实验代码**

这是第二部分的Matlab实验代码：

**\[python\]** [view plain][] [copy][view plain]

1.  clear,close all, clc 
2.  
3.  %% readimage 
4.  image =imread('test.jpg'); 
5.  
6.  %% definefilter 
7.  % -----Identity filter ----- 
8.  kernel =\[0, 0, 0
9.  0, 1, 0
10. 0, 0, 0\]; 
11. 
12. % -----Average Blur ----- 
13. kernel =\[0, 1, 0
14. 1, 1, 1
15. 0, 1, 0\] / 5; 
16. 
17. % -----Gaussian Blur ----- 
18. kernel =fspecial('gaussian', 5 , 0.8); 
19. 
20. % -----Motion Blur ----- 
21. kernel =\[1, 0, 0, 0, 0
22. 0, 1, 0, 0, 0
23. 0, 0, 1, 0, 0
24. 0, 0, 0, 1, 0
25. 0, 0, 0, 0, 1\] / 5; 
26. 
27. % -----Edges Detection ----- 
28. kernel =\[-1, -1, -1
29.  \-1, 8, -1
30.  \-1, -1, -1\]; 
31. 
32. % -----Sharpen filter ----- 
33. kernel =\[-1, -1, -1
34.  \-1, 9, -1
35.  \-1, -1, -1\]; 
36. 
37. % -----Emboss filter ----- 
38. kernel =\[-1, -1, 0
39.  \-1, 0,1
40. 0, 1,1\]; 
41. 
42. %% convolethe image with defined kernel **or** filter 
43. result =zeros(size(image)); 
44. result(:,:, 1) = conv2(double(image(:, :, 1)), double(kernel), 'same'); 
45. result(:,:, 2) = conv2(double(image(:, :, 2)), double(kernel), 'same'); 
46. result(:,:, 3) = conv2(double(image(:, :, 3)), double(kernel), 'same'); 
47. 
48. %% showthe result 
49. imshow(image); 
50. figure 
51. imshow(uint8(result))

**五、参考文献**

\[1\] Correlation and Convolution.pdf

\[2\] [Lode's Computer GraphicsTutorial Image Filtering][Lode_s Computer GraphicsTutorial Image Filtering]

[https_www.zhihu.com_question_22298352_answer_34267457]: https://www.zhihu.com/question/22298352/answer/34267457
[x_0_ _ a_ x_1_ _ b_ x_2_c]: 
[153fd3e7911d486edaf0475afb1e54b3_b.png]: /images/20220714/0e0085709676434e83670f066e9efe5f.png
[c47d9d7f7a29c491782bf7b1baea3f8e_b.png]: /images/20220714/d34c3d5cd1f0411c85ceb1df7f8092f7.png
[91f5eff235013ac729c44e98b3a537d0_b.png]: /images/20220714/4e5d547d673346a6b33ab5c0ca560a20.png
[67c05239b05f671766b9df9393026f2c_b.png]: /images/20220714/aec28033f27b4988abe7d286a5512e41.png
[preview]: /images/20220714/b2d919e9aebf4a67835b063890b43517.png
[preview 1]: /images/20220714/68c677edaee7425e8fbc5a7f099fe1c0.png
[Link 1]: http://blog.csdn.net/u011447369/article/details/49151843
[http_blog.csdn.net_zouxy09_article_details_49080029]: http://blog.csdn.net/zouxy09/article/details/49080029
[Center]: /images/20220714/62794c1d15da4985b6f3fe94abf9ad1b.png
[Center 1]: /images/20220714/58945dc1fd6f44f598d70988689388c5.png
[Center 2]: /images/20220714/2893f316aed542308c468f23e375c3e6.png
[Center 3]: /images/20220714/87e3b107a4c540dd9964536ebc0545ed.png
[Center 4]: /images/20220714/03650349861043f882c0252b38d49ff8.png
[Center 5]: /images/20220714/7f7db56aebf44ef5993019d15d98dd60.png
[Center 6]: /images/20220714/ba4f4eabdf6042ee9f0d8987739e9fa8.png
[Center 7]: /images/20220714/e6a3799c55d84091a29fe264eb464698.png
[Center 8]: /images/20220714/381c810747ff42119e6c746e6ce5473e.png
[Center 9]: /images/20220714/c486939708864777969f518635837920.png
[Center 10]: /images/20220714/5de21dc888b547799d7aa4dc36def2cb.png
[Center 11]: /images/20220714/e1a0031b0f9249a9bcad6aa4efdbd308.png
[Center 12]: /images/20220714/f52dba45686f4410ba6457fe68112e80.png
[Center 13]: /images/20220714/72de79e9d7884ab0a64ed86d14cdf802.png
[Center 14]: /images/20220714/2e2d93d10f564bf899022a335ed400cb.png
[Center 15]: /images/20220714/a19ed791d0724bb6a67dc711bd735f3f.png
[Center 16]: /images/20220714/bfbe1445e8b4484492dba2cf1f845821.png
[Center 17]: /images/20220714/83db1f84551a49f59d52c6af3f940ae0.png
[Center 18]: /images/20220714/379c2b1db7f04e4287649dc2286b8800.png
[Center 19]: /images/20220714/78e8f2ecd4cf4860b0e0120e35a344e9.png
[Center 20]: /images/20220714/c403afa889d3495c8fc09006c87537cc.png
[Center 21]: /images/20220714/ad2d7f62472349cb9883b712e954b2c5.png
[Center 22]: /images/20220714/ce070eae7ee140ce8a4253f9187eadf9.png
[Center 23]: /images/20220714/14a050b0488042fa98d345ce7698a361.png
[Center 24]: /images/20220714/44927864f6ca4af4a64b14d971df6ce4.png
[Center 25]: /images/20220714/7483144a71644873bf5ff642f66c6cce.png
[Center 26]: /images/20220714/84a8dedb529940349cb64213443ca172.png
[Center 27]: /images/20220714/b1620ee4836a4993bb13620cfbeb2349.png
[Link 2]: http://lib.csdn.net/base/datastructure
[Center 28]: /images/20220714/4a67f19e9d234201b24c735310477449.png
[Center 29]: /images/20220714/d77ee4cf50ab457da54b571db9a93109.png
[Center 30]: /images/20220714/19a232706cd649e2821aee3b6601c754.png
[Center 31]: /images/20220714/cd49746ee1f346a28d30538998b30f03.png
[view plain]: http://blog.csdn.net/zouxy09/article/details/49080029#
[Lode_s Computer GraphicsTutorial Image Filtering]: http://lodev.org/cgtutor/filtering.html