图像处理——角点检测（Harris、Shi-Tomasi、亚像素检测）

首先感谢以下两位的博文帮助我的理解。

（1）lwzkiller            http://blog.csdn.net/lwzkiller/article/details/54633670

（2）青雲-吾道乐途   http://blog.csdn.net/qq_37059483/article/details/77852187

1. 何为角点？

下面有两幅不同视角的图像，通过找出对应的角点进行匹配。

再看下图所示，放大图像的两处角点区域：

我们可以直观的概括下角点所具有的特征：

>轮廓之间的交点；

>对于同一场景，即使视角发生变化，通常具备稳定性质的特征；

>该点附近区域的像素点无论在梯度方向上还是其梯度幅值上有着较大变化；

2. 角点检测算法基本思想是什么？

算法基本思想是使用一个固定窗口在图像上进行任意方向上的滑动，比较滑动前与滑动后两种情况，窗口中的像素灰度变化程度，如果存在任意方向上的滑动，都有着较大灰度变化，那么我们可以认为该窗口中存在角点。

3.如何用数学方法去刻画角点特征？

当窗口发生[u,v]移动时，那么滑动前与滑动后对应的窗口中的像素点灰度变化描述如下：

公式解释：

>[u,v]是窗口的偏移量

>(x,y)是窗口内所对应的像素坐标位置，窗口有多大，就有多少个位置

>w(x,y)是窗口函数，最简单情形就是窗口内的所有像素所对应的w权重系数均为1。但有时候，我们会将w(x,y)函数设定为以窗口中心为原点的二元正态分布。如果窗口中心点是角点时，移动前与移动后，该点的灰度变化应该最为剧烈，所以该点权重系数可以设定大些，表示窗口移动时，该点在灰度变化贡献较大；而离窗口中心(角点)较远的点，这些点的灰度变化几近平缓，这些点的权重系数，可以设定小点，以示该点对灰度变化贡献较小，那么我们自然想到使用二元高斯函数来表示窗口函数，这里仅是个人理解，大家可以参考下。

所以通常窗口函数有如下两种形式：

根据上述表达式，当窗口处在平坦区域上滑动，可以想象的到，灰度不会发生变化，那么E(u,v) = 0；如果窗口处在比纹理比较丰富的区域上滑动，那么灰度变化会很大。算法最终思想就是计算灰度发生较大变化时所对应的位置，当然这个较大是指针任意方向上的滑动，并非单指某个方向。

4.E(u,v)表达式进一步演化

首先需要了解泰勒公式，任何一个函数表达式，均可有泰勒公式进行展开，以逼近原函数，我们可以对下面函数进行一阶展开(如果对泰勒公式忘记了，可以翻翻本科所学的高等数学)

那么，

所以E(u,v)表达式可以更新为：

这里矩阵M为，

5.矩阵M的关键性

难道我们是直接求上述的E(u,v)值来判断角点吗？Harris角点检测并没有这样做，而是通过对窗口内的每个像素的x方向上的梯度与y方向上的梯度进行统计分析。这里以Ix和Iy为坐标轴，因此每个像素的梯度坐标可以表示成(Ix,Iy)。针对平坦区域，边缘区域以及角点区域三种情形进行分析：

下图是对这三种情况窗口中的对应像素的梯度分布进行绘制：

如果使用椭圆进行数据集表示，则绘制图示如下：

不知道大家有没有注意到这三种区域的特点，平坦区域上的每个像素点所对应的(IX,IY)坐标分布在原点附近，其实也很好理解，针对平坦区域的像素点，他们的梯度方向虽然各异，但是其幅值都不是很大，所以均聚集在原点附近；边缘区域有一坐标轴分布较散，至于是哪一个坐标上的数据分布较散不能一概而论，这要视边缘在图像上的具体位置而定，如果边缘是水平或者垂直方向，那么Iy轴方向或者Ix方向上的数据分布就比较散；角点区域的x、y方向上的梯度分布都比较散。我们是不是可以根据这些特征来判断哪些区域存在角点呢？

虽然我们利用E(u,v)来描述角点的基本思想，然而最终我们仅仅使用的是矩阵M。让我们看看矩阵M形式，是不是跟协方差矩阵形式很像，像归像，但是还是有些不同，哪儿不同？一般协方差矩阵对应维的随机变量需要减去该维随机变量的均值，但矩阵M中并没有这样做，所以在矩阵M里，我们先进行各维的均值化处理，那么各维所对应的随机变量的均值为0，协方差矩阵就大大简化了，简化的最终结果就是矩阵M，是否明白了？我们的目的是分析数据的主要成分，相信了解PCA原理的，应该都了解均值化的作用。

如果我们对协方差矩阵M进行对角化，很明显，特征值就是主分量上的方差，这点大家应该明白吧？不明白的话可以复习下PCA原理。如果存在两个主分量所对应的特征值都比较大，说明什么？ 像素点的梯度分布比较散，梯度变化程度比较大，符合角点在窗口区域的特点；如果是平坦区域，那么像素点的梯度所构成的点集比较集中在原点附近，因为窗口区域内的像素点的梯度幅值非常小，此时矩阵M的对角化的两个特征值比较小；如果是边缘区域，在计算像素点的x、y方向上的梯度时，边缘上的像素点的某个方向的梯度幅值变化比较明显，另一个方向上的梯度幅值变化较弱，其余部分的点都还是集中原点附近，这样M对角化后的两个特征值理论应该是一个比较大，一个比较小，当然对于边缘这种情况，可能是呈45°的边缘，致使计算出的特征值并不是都特别的大，总之跟含有角点的窗口的分布情况还是不同的。

注：M为协方差矩阵，需要大家自己去理解下，窗口中的像素集构成一个矩阵（2*n，假设这里有n个像素点），使用该矩阵乘以该矩阵的转置，即是协方差矩阵

因此可以得出下列结论：

>特征值都比较大时，即窗口中含有角点

>特征值一个较大，一个较小，窗口中含有边缘

>特征值都比较小，窗口处在平坦区域

6. 如何度量角点响应？

(1)Harris用下面表达式进行度量：

其中k是常量，一般取值为0.04~0.06，这个参数仅仅是这个函数的一个系数，它的存在只是调节函数的形状而已。

但是为什么会使用这样的表达式呢？一下子是不是感觉很难理解？其实也不难理解，函数表达式一旦出来，我们就可以绘制它的图像，而这个函数图形正好满足上面几个区域的特征。 通过绘制函数图像，直观上更能理解。绘制的R函数图像如下：

所以说难点不在于理解这个函数表达式，而在于如何创造出这个函数表达式。Harris对很多函数模型非常了解，对于创造出这样的一个函数表达式，易如反掌。最后设定R的阈值，进行角点判断。当然其中还有些后处理步骤，比如说角点的极大值抑制(dilate）。

（2）Shi-Tomasi用下面表达式进行度量：

如果打分超过阈值，我们就认为它是一个角点。我们可以把它绘制到 λ1 ～λ2 空间中，就会得到下图：

从这幅图中，我们可以看出来只有当 λ1 和 λ2 都大于最小值时，才被认为是角点（绿色区域）。 
  OpenCV 提供了函数： goodFeaturesToTrack()。这个函数可以帮我们使用 Shi-Tomasi 方法获取图像中 N 个最好的角点（也可以通过改变参数来使用 Harris 角点检测算法）。通常情况下，输入的应该是灰度图像。然后确定你想要检测到的角点数目。再设置角点的质量水平， 0到 1 之间。它代表了角点的最低质量，低于这个数的所有角点都会被忽略（阈值为maxEigVal*qualityLevel）。最后在设置两个角点之间的最短欧式距离。根据这些信息，函数就能在图像上找到角点。所有低于质量水平的角点都会被忽略,然后再把合格角点按角点质量进行降序排列。函数会采用角点质量最高的那个角点（排序后的第一个），然后将它附近（最小距离之内）的角点删掉。按着这样的方式最后返回 N 个最佳角点。

1. //goodFeaturesToTrack有比cornerHarries更多的控制参数,函数原型:  
2.   
3. void goodFeaturesToTrack( InputArray image, OutputArray corners,  
4.                                     int maxCorners, double qualityLevel, double minDistance,  
5.                                     InputArray mask=noArray(), int blockSize=3,  
6.                                     bool useHarrisDetector=false, double k=0.04);  
7.   
8. /*第一个参数image：8位或32位单通道灰度图像; 
9.   第二个参数corners: 位置点向量,保存的是检测到角点的坐标; 
10.   第三个参数maxCorners: 定义可以检测到的角点的数量的最大值; 
11.   第四个参数qualityLevel: 检测到的角点的质量等级,角点特征值小于qualityLevel*最大特征 
12.   值的点将被舍弃; 
13.   第五个参数minDistance: 两个角点间最小间距,以像素为单位; 
14.   第六个参数mask: 指定检测区域,若检测整幅图像,mask置为空Mat(); 
15.   第七个参数blockSize: 计算协方差矩阵时窗口大小; 
16.   第八个参数useHarrisDector: 是否使用Harris角点检测,为false,则使用Shi-Tomasi算子; 
17.   第九个参数K: 留给Harris角点检测算子用的中间参数,一般取经验值0.04~0.06.第8个参数为false时,改参数不起作用; 
18. */  
19. 
    

goodFeaturesToTrack函数的定义在imgproc文件的featureselect.cpp中，下面给出了goodFeaturesToTrack函数的详细注释。

1. void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,  
2.                                 int maxCorners, double qualityLevel, double minDistance,  
3.                                 InputArray _mask, int blockSize,  
4.                                 bool useHarrisDetector, double harrisK )  
5. {  
6.     //如果需要对_image全图操作,则给_mask传入cv::Mat(),否则传入感兴趣区域  
7.     Mat image = _image.getMat(), mask = _mask.getMat();  
8.   
9.     CV_Assert( qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0 ); //对参数有一些基本要求  
10.   
11.     CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()) );  
12.   
13.     Mat eig, tmp;  //eig存储每个像素协方差矩阵的最小特征值,tmp用来保存经膨胀后的eig  
14.     if( useHarrisDetector )  
15.         cornerHarris( image, eig, blockSize, 3 ,harrisk ); //blockSize是计算2*2协方差矩阵的窗口大小,sobel算子窗口为3,harrisk是计算Harris角点时需要的值  
16.     else  
17.         cornerMinEigenVal( image, eig, blockSize, 3);   //计算每个像素对应的协方差矩阵的最小特征值,保存在eig中  
18.   
19.     double maxVal = 0;  
20.     minMaxLoc( eig, 0, &maxVal, 0, 0, mask );   //maxVal保存了eig的最大值  
21.     threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO);  //阈值设置为maxVal乘以qualityLevel,大于此阈值的保持不变,小于此阈值的都设为0  
22.   
23.     //默认用3*3的核膨胀,膨胀之后,除了局部最大值点和原来相同,其他非局部最大值点被  
24.     //3*3邻域内的最大值点取代,如不理解,可看一下灰度图像的膨胀原理  
25.     //为什么膨胀操作：膨胀的本质是用当前像素周围的最大值替代当前像素值，  
26.     //因此，通过膨胀前后比较能取得局部角点响应最大的点。  
27. 
    
28.       
29.     dilate( eig, tmp, Mat() );   //tmp中保存了膨胀之后的eig  
30.   
31.     Size imgsize = image.size();  
32.   
33.     vector<const float*> tmpCorners;  //存放粗选出的角点地址  
34.   
35.     // collect list of pointers to features - put them into temporary image  
36.     for( int y = 1; y < imgsize.height -1; y++)  
37.     {  
38.         const float* eig_data = (const float*)eig.ptr(y);  //获得eig第y行的首地址  
39.         const float* tmp_data = (const float*)tmp.ptr(y);  //获得tmp第y行的首地址  
40.         const uchar* mask_data = mask.data ? mask.ptr(y) : 0;  
41.   
42.         for( int x =1; x < imgsize.width - 1; x++)  
43.         {  
44.             float val = eig_data[x];  
45.             if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) ) //val == tmp_data[x], 说明这是局部极大值  
46.                 tmpCorners.push_back(eig_data + x);  //保存其位置  
47.         }  
48.     }  
49.   
50.     //--------------此分割线以上是根据特征值粗选出的角点,我们称之为弱角点-----------//  
51.     //--------------此分割线以下还要根据minDistance进一步筛选角点,仍然能存活下来的我们称之为强角点------------//  
52.       
53.     sort( tmpCorners, greaterThanPtr<float>() ); //按特征值降序排列,注意这一步很重要,后面的很多编程思路都是建立在这给降序排列的基础上  
54.     vector<Point2f> corners;  
55.     size_t i, j, total = tmpCorners.size(), ncorners = 0;  
56.   
57.     //下面的程序有点稍微理解，需要自己想想  
58.     if(minDistance >= 1)  
59.     {  
60.         //Partition the image into larger grids  
61.         int w = image.cols;  
62.         int h = image.rows;  
63.   
64.         const int cell_size = cvRound(minDistance);  //向最近的整数取整  
65.   
66.         //这里根据cell_size构建了一个矩形窗口grid(虽然下卖弄的grid定义的是vector<vector>,而并不是我们这里说的矩形窗口,但是为了便于理解,还是将grid想象成一个grid_width*grid_width的矩形窗口比较好),除以cell_size说明grid窗口里相差一个像素相当于_image里相差minDistance个像素,至于为什么加上cell_size - 1,后面会讲  
67.           
68.         const int grid_width = (w + cell_size - 1) / cell_size;  
69.         const int grid_width = (h + cell_size - 1) / cell_size;  
70.   
71.         std::vector<std::vector<Point2f> > grid(grid_width*grid_width); //vector里面是vector,grid用来保存获得的强角点坐标  
72.   
73.         minDistance *= minDistance;  //平方,方便后面计算,省的开根号  
74.   
75.         for( i = 0; i < total; i++)  
76.          {  
77.             int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);  //tmpCorners中保存了角点的地址,eig.data返回了内存块的地址  
78.             int y = (int)(ofs / eig.step);  //角点在原图像中的行  
79.             int x = (int)((ofs - y*eig.step)/sizeof(float)); //在原图像中的列  
80.   
81.             bool good = true;  //先认为当前角点能接收考验,即能被保留下来  
82.   
83.             int x_cell = x / cell_size;  //x_cell, y_cell是角点（y,x）在grid中的坐标  
84.             int y_cell = y_cell - 1;     //现在知道为什么前面grid_width定义时要加上cell_size - 1了吧,这是为了使得(y,x)在grid中的4邻域像素都存在,也就是说(y_cell, x_cell)不会成为边界像素  
85.             int x2 = x_cell + 1;  
86.             int y2 = y_cell + 1;  
87.   
88.             // boundary check,再次确认x1,y1,x2,或y2不会超出grid边界  
89.             x1 = std::max(0, x1);   //比较0和x1的大小  
90.             y1 = std::max(0, y1);  
91.             x2 = std::min(grid_width-1, x2);  
92.             y2 = std::min(grid_height-1, y2);  
93.   
94.             //记住grid相差一个像素,相当于_image相差了minDistance个像素  
95.             for( int yy = y1; yy <= y2; yy++)  //行  
96.             {  
97.                 for( int xx = x1; xx <= x2; xx++)  
98.                 {  
99.                     vector <Point2f> &m = grid[yy*grid_width + xx]; //引用  
100.                     if( m.size() )  //如果(y_cell,x_cell的4邻域像素,也就是(y,x)的minDistance邻域像素中已有被保留的强角点)  
101.                     {  
102.                         for(j = 0; j < m.size(); j++)  //当前角点周围的强角点都拉出来跟当前角点比一比  
103.                         {  
104.                             float dx = x - m[j].x;  
105.                             float dy = y - m[j].y;  
106.                             //注意如果(y,x)的minDistance邻域像素中已有被保留的强角点,则说明该强角点是在(y,x)之前就被测试过的,又因为tmpCorners中已按照特征值降序排列(特征值越大说明角点越好),这说明先测试的一定是更好的角点,也就是已保存的角点一定好于当前角点,所以这里只要比较距离,如果距离满足条件,可以立马扔掉当前测试的角点  
107.                             if( dx*dx + dy*dy < minDistance )  
108.                             {  
109.                                 good = false;  
110.                                 goto break_out;  
111.                             }  
112.                         }  
113.                     }  
114.                 } //列  
115.             } //行  
116.             break_out;  
117.             if(good)  
118.             {  
119.                 //printf("%d: %d%d ->%d %d, %d, %d -- %d %d %d %d, %d %d, c=%d\n",  
120.                 //  i,x, y, x_cell, y_cell, (int)minDistance, cell_size,x1,y1,x2,y2,grid_width,grid_height,c);  
121.                 grid[y_cell*grid_width + x_cell].push_back(Point2f((float)x,(float)y));  
122.   
123.                 corners.push_back(Point2f((float)x, (float)y));  
124.                 ++ncorners;  
125.   
126.                 if(maxCorners > 0 && (int)ncorners == maxCorners ) //用于前面已按降序排列,当ncorners超过maxCorners的时候跳出循环直接忽略tmpCorners中剩下的角点,反正剩下的角点越来越弱  
127.                     break;  
128.             }  
129.          }     
130.     }  
131.     else    //除了像素本身,没有哪个邻域像素能与当前像素满足minDistance < 1,因此直接保存粗选的角点  
132.     {  
133.         for( i = 0; i < total; i++)  
134.         {  
135.             int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);  
136.             int y = (int)(ofs / eig.step);  //粗选的角点在原图像中的行  
137.             int x = (int)((ofs - y*eig.step)/sizeof(float));  //在图像中的列  
138.   
139.             corner.push_back(Point2f((float)x, (float)y));  
140.             ++ncorners;  
141.             if( maxCorners > 0 && (int)ncorners == maxCorners )  
142.                 break;  
143.         }      
144.     }  
145.   
146.     Mat(corners).convertTo(_corners, _corners.fixedType() ? _corners.type : CV_32F);  
147.     /* 
148.     for( i = 0; i < total; i++ )  
149.     {  
150.         int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);  
151.         int y = (int)(ofs / eig.step);  
152.         int x = (int)((ofs - y*eig.step)/sizeof(float));  
153.   
154.         if( minDistance > 0 )  
155.         {  
156.             for( j = 0; j < ncorners; j++ )  
157.             {  
158.                 float dx = x - corners[j].x;  
159.                 float dy = y - corners[j].y;  
160.                 if( dx*dx + dy*dy < minDistance )  
161.                     break;  
162.             }  
163.             if( j < ncorners )  
164.                 continue;  
165.         }  
166.   
167.         corners.push_back(Point2f((float)x, (float)y));  
168.         ++ncorners;  
169.         if( maxCorners > 0 && (int)ncorners == maxCorners )  
170.             break;  
171.     }  
172.      */  
173. }  

7. 亚像素检测

根据输入的阈值T大于该阈值的R对应像素点即为图像中角点位置坐标。此刻坐标往往都是整数出现，而在真实的世界中坐标多数时候都不是整数，假设我们计算出来的角点位置P(34, 189)而实际上准确角点位置是P(34.278, 189.706)这样带小数的位置，而这样的准确位置寻找过程就叫做子像素定位或者亚像素定位。这一步在SURF与SIFT算法中都有应用而且非常重要。常见的亚像素级别精准定位方法有三类：

1. 基于插值方法

2. 基于几何矩寻找方法

3. 拟合方法 - 比较常用

拟合方法中根据使用的公式不同可以分为高斯曲面拟合与多项式拟合等等。以高斯拟合为例

这样就求出了亚像素的位置。使用亚像素位置进行计算得到结果将更加准确，对图像特征提取、匹配结果效果显著。