1、一维信号的卷积 

　　卷积是一种是数学运算，对于一维连续信号f(x)来说，f(x)和g(x)的卷积是一种积分运算，如下 

　　

　　它的几何意义是这样的：第一步，先把g(x)关于原点对称，得到g(-x)；第二步，把g(-x)向右平移a个单位得到g(a-x)的图像，如果两个图像有交叉部分，那么交叉部分的面积就是卷积。 

　　上面说的是一维连续信号，如果是一维离散信号呢，因为积分是求和的极限，那么对于离散信号的卷积就是一种求和运算。对于离散信号x(n)和h(n)来说，他们的卷积如下 

　　

　　几何过程也是类似的。先关于远点对称，在平移，只不过只能平移整数个单位，因为是离散信号，再相乘再相加。 

2、一维信号的卷积有什么用 

　　对于信号处理来说，基本的模型是输入信号，处理信号，输出信号这个过程，不管什么信号，总得有输出，从输入到输出的过程都叫信号处理过程，其中包含的噪声、滤波等等都是这个过程中发生的事情。可以证明（谁证明的就不知道了），假设输入信号叫x，处理信号对应的系统函数叫h，那么输入信号等于x和h的卷积。（具体的证明见信号和系统这本书）。 

　　但是卷积是积分运算，计算起来比较麻烦，所以能不能不通过卷积运算就能把输出信号算出来呢？能！就是通过变换域的方法，什么叫变换域，在正常处理中我们的信号都是关于时间t的信号，也就是说是自变量是t，我们叫时间域（就类似于定义域）。通过一种可逆的变换把时间域变换到别的域（比如傅里叶变换，拉普拉斯变换），从别的域进行处理，再反变换（因为我们需要的是时间域的东西，所以必须得可逆）回来。傅里叶变换和拉普拉斯变换分别是把时间域（简称时域）变换到频率域和s域（就是指变换之后的自变量是频率和s），可以证明（证明过程见信号和系统书吧）：时域的卷积相当于频域（s域）的相乘。 

　　所以，对于信号的处理可以在时域处理，也可以在变换域处理。 

3、数字图像的卷积 

　　数字图像在实质上就是一个二维数组，在信号的角度上来说是二维离散信号，只不过自变量不是时间，而是空间像素点了，所以正常需要处理的是空间域，类比二维信号也有变换域（频域，小波域等等），对于二维信号的处理也有如下结论：处理后的图像g(x,y)等于输入图像f(x,y)和处理过程h(x,y)的卷积。其中A矩阵和B矩阵的卷积如下。 

　　

　　数字图像进行卷积干吗用？主要用来图像增强和去噪。 

4、几个常用术语 

　　模板：模板就是一个矩阵（其实就是下面说的卷积核），也就是处理图像这个过程对应的函数，对应卷积运算。 

　　卷积运算：可以看做加权求和的过程，为了图像增强和减少噪声，用该像素点的邻域像素点进行加权，得到处理完之后这个点的像素点（会把噪声减弱，当然也会有别的问题）。 

　　卷积核：上面不是说了卷积运算了嘛，这个点的邻域和哪个矩阵进行加权啊？换句话说，这个点的邻域那么多像素点，这些像素点所占的权重是多少啊？这些权重构成一个矩阵，这个矩阵就叫卷积核，卷积核的行数和列数都是奇数。 

　　比如要对R5这个像素点进行卷积运算，有下面的式子成立，这个卷积核的数组直接决定卷积的结果。 

　　

　　使用卷积核的时候回出现一个问题——边界问题：当处理图像边界像素时，卷积核与图像使用区域不能匹配，卷积核的中心与边界像素点对应， 卷积运算将出现问题。 

　　处理办法： 

              A． 忽略边界像素，即处理后的图像将丢掉这些像素。 

              B． 保留原边界像素，即copy边界像素到处理后的图像。

5、常用的模板 

介绍一下卷积：就是一种算子 
直接上例子：

[ 1 2 3 4 5 4 3 2 1] （《==原始向量）卷积 [ 2 0 -2] （《=卷积模板 ）
过程：

[ 0 0 1 2 3 4 5 4 3 2 1 0 0] （零填充）
[-2 0 2]《----[ 2 0 -2]     （翻转180度）
↓  (开始)
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
[-2 0 2]
↓ （结果 [0 2 1 2 3 4 5 4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
   [-2 0 2]
↓ （结果 [0 2 4 2 3 4 5 4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
      [-2 0 2]
↓ （结果 [0 2 4 4 3 4 5 4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
         [-2 0 2]
↓ （结果 [0 2 4 4 4 4 5 4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
            [-2 0 2]
↓ （结果 [0 2 4 4 4 4 5 4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
               [-2 0 2]
↓ （结果 [0 2 4 4 4 4 0 4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
                  [-2 0 2]
↓ （结果 [0 2 4 4 4 4 0 -4 3 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
                     [-2 0 2]
↓ （结果 [0 2 4 4 4 4 0 -4 -4 2 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
                        [-2 0 2]
↓ （结果 [0 2 4 4 4 4 0 -4 -4 -4 1 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
                           [-2 0 2]
↓ （结果 [0 2 4 4 4 4 0 -4 -4 -4 -4 0 0] ）
[ 0 0 1 2 3 4 5 4 3 2 1 0 0] 
                              [-2 0 2]
↓ （结果 [0 2 4 4 4 4 0 -4 -4 -4 -4 -2 0] ）
[0 2 4 4 4 4 0 -4 -4 -4 -4 -2 0] 《===（全部卷积结果）
[4 4 4 4 0 -4 -4 -4 -4] 《===（裁截后的卷积结果）
下面来个图片的卷积：

A卷积G


原始图片像素阵A如下：

               
1 3 2 0 4                    
1 0 3 2 3 
0 4 1 0 5 
 2 3 2 1 4
 3 1 0 4 2 
卷积模板 G

-1 0 1
-2 0 2
-1 0 1


原始图做零填充结果 9*9        
 0 0 0 0 0 0 0 0 0                   
 0 0 0 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                    
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
 
模板做180度翻转结果3*3
1 0 -1
2 0 -2
1 0 -1
 
开始做卷积 
第1次蓝色为模板作用区域
 0 0 0 0 0 0 0 0 0                
 0 0 0 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
 
 
 
 
 
 
 
 
 第1次卷积结果
 0 0 0 0 0 0 0 0 0                
 0 -1 0 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
 
第2次蓝色为模板作用区域
 0 0 0 0 0 0 0 0 0                
 0 0 0 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
第2次卷积结果
 0 0 0 0 0 0 0 0 0                
 0 -1 -3 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
 
第3次蓝色为模板作用区域
 0 0 0 0 0 0 0 0 0                
 0 0 0 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
 
 
第3次卷积结果
 0 0 0 0 0 0 0 0 0                
 0 -1 -3 -1 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
 
。。。。。。。。经过漫长的模板移动。。。。。。。。。。
 
第49次蓝色为模板作用区域
 0 0 0 0 0 0 0 0 0                
 0 0 0 0 0 0 0 0 0                
 0 0 1 3 2 0 4 0 0                
 0 0 1 0 3 2 3 0 0
 0 0 0 4 1 0 5 0 0
 0 0 2 3 2 1 4 0 0
 0 0 3 1 0 4 2 0 0
 0 0 0 0 0 0 0 0 0 
 0 0 0 0 0 0 0 0 0
第49次卷积结果
 0 0  0  0  0  0  0  0  0                
 0 -1  -3 -1 -3  -2  0  4  0                
 0 -3  -6  -4  4  -4  2  11  0                
 0 -3  -7  -6  3  -6  2  15  0
 0 -3  -11 -4 8 -10  3  17  0
 0 -7 -11  2  5 -10  6  15  0
 0 -8  -5  6 -4  -6  9  8  0
 0 3  1  3  -3  -2  4  2  0 
 0 0  0  0  0  0  0  0  0
 
裁截后的卷积结果
              
-6  -4  4  -4  2             
-7  -6  3  -6  2 
-11 -4  8 -10  3  
-11  2  5 -10  6  
-5  6 -4  -6  9  

图像卷积概念与操作
图像卷积概念
图像卷积操作
图像边缘像素操作

图像卷积概念


数字信号处理中的卷积： 卷积是两个变量在某范围内相乘后求和的结果。如果卷积的变量是序列x(n)和h(n)，则卷积的结果：



通过“打脸”案例理解卷积：卷积理解




数字图像处理中的卷积：

数字图像是一个二维的离散信号，对数字图像做卷积操作其实就是利用 卷积核（卷积模板）在图像上滑动，将图像点上的像素灰度值与对应的卷积核上的数值相乘，然后将所有相乘后的值相加作为卷积核中间像素对应的图像上像素的灰度值，并最终滑动完所有图像的过程。




卷积核的选择规则：

   A 、卷积核的大小一般是奇数，这样的话它是按照中间的像素点中心对称的，所以卷积核一般都是3x3，5x5或者7x7。有中心了，也有了半径的称呼，例如5x5大小的核的半径就是2；

   B、卷积核所有的元素之和一般要等于1，这是为了原始图像的能量（亮度）守恒。其实也有卷积核元素相加不为1的情况，下面就会说到；

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

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


不同卷积核下的卷积意义：（卷积操作的目的）

利用像素点和其邻域像素之前的空间关系，通过加权求和的操作，实现平滑，去燥，模糊（blurring），锐化（sharpening），边缘检测（edge detection）和 边缘提取 等功能。各种卷积核的意义


图像卷积操作

通过代码实现平滑均值滤波
可以自己通过代码进行卷积操作，也可以使用API : blur

//API
CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
                        Size ksize, Point anchor = Point(-1,-1),
                        int borderType = BORDER_DEFAULT );


Mat src = imread("F:/code/images/test1.png");
	if (src.empty()) {
		printf("fail to read");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	//手工进行图像卷积计算
	//均值滤波
	int width = src.cols;
	int height = src.rows;
	Mat result = src.clone();

	for (int row = 1; row < height - 1; row++) {
		for (int col = 1; col < width - 1; col++) {
			// 3*3 卷积核 
			int sb = result.at<Vec3b>(row, col)[0] + result.at<Vec3b>(row - 1, col - 1)[0] + result.at<Vec3b>(row - 1, col)[0] +
				result.at<Vec3b>(row - 1, col + 1)[0] + result.at<Vec3b>(row, col - 1)[0] + result.at<Vec3b>(row, col + 1)[0] +
				result.at<Vec3b>(row + 1, col - 1)[0] + result.at<Vec3b>(row + 1, col)[0] + result.at<Vec3b>(row + 1, col + 1)[0];

			int sg = result.at<Vec3b>(row, col)[1] + result.at<Vec3b>(row - 1, col - 1)[1] + result.at<Vec3b>(row - 1, col)[1] +
				result.at<Vec3b>(row - 1, col + 1)[1] + result.at<Vec3b>(row, col - 1)[1] + result.at<Vec3b>(row, col + 1)[1] +
				result.at<Vec3b>(row + 1, col - 1)[1] + result.at<Vec3b>(row + 1, col)[1] + result.at<Vec3b>(row + 1, col + 1)[1];

			int sr = result.at<Vec3b>(row, col)[2] + result.at<Vec3b>(row - 1, col - 1)[2] + result.at<Vec3b>(row - 1, col)[2] +
				result.at<Vec3b>(row - 1, col + 1)[2] + result.at<Vec3b>(row, col - 1)[2] + result.at<Vec3b>(row, col + 1)[2] +
				result.at<Vec3b>(row + 1, col - 1)[2] + result.at<Vec3b>(row + 1, col)[2] + result.at<Vec3b>(row + 1, col + 1)[2];

			result.at<Vec3b>(row, col)[0] = sb / 9;
			result.at<Vec3b>(row, col)[1] = sg / 9;
			result.at<Vec3b>(row, col)[2] = sr / 9;
		}
	}
	imshow("mean filter My", result);
	
	//调用API : blur 进行均值滤波
	Mat dst;
	blur(src, dst, Size(3,3), Point(-1,-1), BORDER_DEFAULT);
	imshow("mean filter API", dst);



图像边缘像素操作


边界补充问题： 上面的卷积操作，也反映出一个问题，例如，原始图片尺寸为7x7 ，卷积核的大小为3x3，当卷积核沿着图片滑动后只能滑动出一个的图片出来，这就造成了卷积后的图片和卷积前的图片尺寸不一致，这显然不是我们想要的结果，所以为了避免这种情况，需要先对原始图片做边界填充处理，即，我们需要先把原始图像填充为 9x9 的尺寸。那么填充的方法一般有： 补零、边界复制、镜像、块复制


API 中的参数选择有：

最常用的是 BORDER_REFLECT_101 ，填充示意（粗体为填充的像素）： 尾-----> （头-------尾）<-----------头

CONSTANT为常量值填充；

REPLICATE为镜像填充；

WRAP为块复制填充




边缘填充的方式，锚定点都对卷积结果有影响




利用API : copyMakeBorder 可以进行边缘填充


CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst,
                                 int top, int bottom, int left, int right,
                                 int borderType, const Scalar& value = Scalar() );


	//边缘像素的处理
	//边缘填充
	int border = 8;//填充的像素个数
	Mat border_m;
	copyMakeBorder(src, border_m, border, border, border, border, BORDER_CONSTANT, Scalar(0, 0, 255));//边缘加了个红框
	imshow("border fill demo", border_m);

在执行线性空间滤波时，经常会遇到两个概念相关和卷积
二者基本相似，在进行图像匹配是一个非常重要的方法。
相关是滤波器模板移过图像并计算计算每个位置乘积之和的处理
卷积的机理相似，但滤波器首先要旋转180度
相关的计算步骤：
（1）移动相关核的中心元素，使它位于输入图像待处理像素的正上方
（2）将输入图像的像素值作为权重，乘以相关核
（3）将上面各步得到的结果相加做为输出
卷积的计算步骤：
（1）卷积核绕自己的核心元素顺时针旋转180度
（2）移动卷积核的中心元素，使它位于输入图像待处理像素的正上方
（3）在旋转后的卷积核中，将输入图像的像素值作为权重相乘
（4）第三步各结果的和做为该输入像素对应的输出像素
超出边界时要补充像素，一般是添加0或者添加原始边界像素的值
    可以看出他们的主要区别在于计算卷积的时候，卷积核要先做旋转。
而计算相关过程中不需要旋转相关核。


离散单位冲击：我们将包含单个1而其余全是0的函数成为离散单位冲击。
重要性质：一个函数与离散单位冲击相关，在冲击位置产生这个函数的一
个翻转版本。
f 函数
w 滤波器模板
eg：
f（x，y）
  0 0 0 0 0
  0 0 0 0 0 
  0 0 1 0 0
  0 0 0 0 0
  0 0 0 0 0
w（x，y）
  1 2 3 
  4 5 6 
  7 8 9
相关 f*w = 
     0     0     0     0     0
     0     9     8     7     0
     0     6     5     4     0
     0     3     2     1     0
     0     0     0     0     0
卷积f*w=
     0     0     0     0     0
     0     1     2     3     0
     0     4     5     6     0
     0     7     8     9     0
     0     0     0     0     0
相关的用途：图象的匹配
假如函数f中存在w的一个复制版本，即f：
  0 0 0 0 0
  0 1 2 3 0 
  0 4 5 6 0
  0 7 8 9 0
  0 0 0 0 0
f*w是多少呢？
    9    26    50    38    21
    42    94   154   106    54
    90   186   285   186    90
    54   106   154    94    42
    21    38    50    26     9
是不是会发现w与f中w的复制版本重合时，该点的值最大。最大值为
1^2+2^2+……+9^2 = 285
这就是用相关进行图像匹配的基本原理。当然了，在图像匹配时还要进行
相关函数的归一化等操作。