FAST(Features fromaccelerated segment test)源码分析

FAST(Features fromaccelerated segment test)是一种角点检测方法,它可以用于特征点的提取,并完成跟踪和映射物体。FAST角点检测算法最初是由Edward Rosten和Tom Drummond提出,该算法最突出的优点是它的计算效率。正如它的缩写名字,它很快而且事实上它比其他著名的特征点提取方法(如SIFT,SUSAN,Harris)都要快。而且如果应用机器学习方法的话,该算法能够取得更佳的效果。正因为它的快速特点,FAST角点检测方法非常适用于实时视频处理的领域。

该算法的基本原理是使用圆周长为16个像素点(半径为3的Bresenham圆)来判定其圆心像素P是否为角点。在圆周上按顺时针方向从1到16的顺序对圆周像素点进行编号。如果在圆周上有N个连续的像素的亮度都比圆心像素的亮度Ip加上阈值t还要亮,或者比圆心像素的亮度减去阈值还要暗,则圆心像素被称为角点。因此要想成为角点,必须满足下列两个条件之一:

条件1:集合S由圆周上N个连续的像素x组成,IIt

条件2:集合S由圆周上N个连续的像素x组成,IIp - t

N一般选择为12。

在一幅图像中,非角点往往是占多数,而且非角点检测要比角点检测容易得多,因此首先剔除掉非角点将大大提高角点检测速度。由于N为12,所以编号为1,5,9,13的这4个圆周像素点中应该至少有三个像素点满足角点条件,圆心才有可能是角点。因此首先检查1和9像素点,如果I1I9在[Ip – t It]之间,则圆心肯定不是角点,否则再检查5和13像素点。如果这4个像素中至少有三个像素满足亮度高于Ip+t或低于Ip – t,则进一步检查圆周上其余像素点。

以上方法还是有不够鲁棒的地方,但可以通过机器学习和非极大值抑制的方法来增强鲁棒性。由于opencv中相关的函数没有使用机器学习,因此我们这里只介绍非极大值抑制的方法。由于分割测试并没有计算角点响应函数,因此常规的非极大值抑制方法并不适用于FAST算法。下面是FAST的非极大值抑制方法:

1、计算得分函数,它的值V是特征点与其圆周上16个像素点的绝对差值中的最小值;

2、在3×3的特征点邻域内(而不是图像邻域),比较V;

3、剔除掉非极大值的特征点。

FAST角点检测方法的具体步骤为:

1、在圆周上的部分像素点上,进行非角点的检测;

2、如果初步判断是角点,则在圆周上的全部像素点上进行角点检测;

3、对角点进行非极大值抑制,得到角点输出。

 

在opencv中,实现FAST算法的核心函数有两个,它们的原型为:

[cpp]  view plain copy
  1. void FAST(InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSuppression=true )  
  2. void FASTX(InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSuppression, int type)  

image为输入图像,要求是灰度图像

keypoints为检测到的特征点向量

threshold为阈值t

nonmaxSuppression为是否进行非极大值抑制,true表示进行非极大值抑制

type为选取圆周像素点的个数,是8(FastFeatureDetector::TYPE_5_8)、12(FastFeatureDetector::TYPE_7_12)还是16(FastFeatureDetector::TYPE_9_16)。该参数是FAST函数和FASTX函数的区别,事实上,FAST函数是调用FASTX函数,而传入的type值为FastFeatureDetector::TYPE_9_16。

FAST角点检测方法是在sources/modules/features2d/src/fast.cpp文件内定义的:

[cpp]  view plain copy
  1. void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression)  
  2. {  
  3.     //调用FASTX函数  
  4.     FASTX(_img, keypoints, threshold, nonmax_suppression, FastFeatureDetector::TYPE_9_16);  
  5. }  
FASTX函数的作用是调用一个函数模板,模板的参数值是根据参数type的不同而定义的所使用的圆周像素的个数:

[cpp]  view plain copy
  1. void FASTX(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, int type)  
  2. {  
  3.   switch(type) {  
  4.     case FastFeatureDetector::TYPE_5_8:  
  5.       FAST_t<8>(_img, keypoints, threshold, nonmax_suppression);  
  6.       break;  
  7.     case FastFeatureDetector::TYPE_7_12:  
  8.       FAST_t<12>(_img, keypoints, threshold, nonmax_suppression);  
  9.       break;  
  10.     case FastFeatureDetector::TYPE_9_16:  
  11. #ifdef HAVE_TEGRA_OPTIMIZATION  
  12.       if(tegra::FAST(_img, keypoints, threshold, nonmax_suppression))  
  13.         break;  
  14. #endif  
  15.       FAST_t<16>(_img, keypoints, threshold, nonmax_suppression);  
  16.       break;  
  17.   }  
  18. }  
下面是函数模板FAST_t,在这里我们以patternSize=16为例进行讲解:

[cpp]  view plain copy
  1. template<int patternSize>  
  2. void FAST_t(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression)  
  3. {  
  4.     Mat img = _img.getMat();    //提取出输入图像矩阵  
  5.     //K为圆周连续像素的个数  
  6.     //N用于循环圆周的像素点,因为要首尾连接,所以N要比实际圆周像素数量多K+1个  
  7.     const int K = patternSize/2, N = patternSize + K + 1;  
  8. #if CV_SSE2  
  9.     const int quarterPatternSize = patternSize/4;  
  10.     (void)quarterPatternSize;  
  11. #endif  
  12.     int i, j, k, pixel[25];  
  13.     //找到圆周像素点相对于圆心的偏移量  
  14.     makeOffsets(pixel, (int)img.step, patternSize);  
  15.     //特征点向量清零  
  16.     keypoints.clear();  
  17.     //保证阈值不大于255,不小于0  
  18.     threshold = std::min(std::max(threshold, 0), 255);  
  19.   
  20. #if CV_SSE2  
  21.     __m128i delta = _mm_set1_epi8(-128), t = _mm_set1_epi8((char)threshold), K16 = _mm_set1_epi8((char)K);  
  22.     (void)K16;  
  23.     (void)delta;  
  24.     (void)t;  
  25. #endif  
  26.     // threshold_tab为阈值列表,在进行阈值比较的时候,只需查该表即可  
  27.     uchar threshold_tab[512];  
  28.     /*为阈值列表赋值,该表分为三段:第一段从threshold_tab[0]至threshold_tab[255 - threshold],值为1,落在该区域的值表示满足角点判断条件2;第二段从threshold_tab[255 – threshold]至threshold_tab[255 + threshold],值为0,落在该区域的值表示不是角点;第三段从threshold_tab[255 + threshold]至threshold_tab[511],值为2,落在该区域的值表示满足角点判断条件1*/  
  29.     for( i = -255; i <= 255; i++ )  
  30.         threshold_tab[i+255] = (uchar)(i < -threshold ? 1 : i > threshold ? 2 : 0);  
  31.     //开辟一段内存空间  
  32.     AutoBuffer<uchar> _buf((img.cols+16)*3*(sizeof(int) + sizeof(uchar)) + 128);  
  33.     uchar* buf[3];  
  34.     /*buf[0、buf[1]和buf[2]分别表示图像的前一行、当前行和后一行。因为在非极大值抑制的步骤2中,是要在3×3的角点邻域内进行比较,因此需要三行的图像数据。因为只有得到了当前行的数据,所以对于上一行来说,才凑够了连续三行的数据,因此输出的非极大值抑制的结果是上一行数据的处理结果*/  
  35.     buf[0] = _buf; buf[1] = buf[0] + img.cols; buf[2] = buf[1] + img.cols;  
  36.     //cpbuf存储角点的坐标位置,也是需要连续三行的数据  
  37.     int* cpbuf[3];  
  38.     cpbuf[0] = (int*)alignPtr(buf[2] + img.cols, sizeof(int)) + 1;  
  39.     cpbuf[1] = cpbuf[0] + img.cols + 1;  
  40.     cpbuf[2] = cpbuf[1] + img.cols + 1;  
  41.     memset(buf[0], 0, img.cols*3);    //buf数组内存清零  
  42.     //遍历整幅图像像素,寻找角点  
  43.     //由于圆的半径为3个像素,因此图像的四周边界都留出3个像素的宽度  
  44.     for(i = 3; i < img.rows-2; i++)  
  45.     {  
  46.         //得到图像行的首地址指针  
  47.         const uchar* ptr = img.ptr<uchar>(i) + 3;  
  48.         //得到buf的某个数组,用于存储当前行的得分函数的值V  
  49.         uchar* curr = buf[(i - 3)%3];  
  50.         //得到cpbuf的某个数组,用于存储当前行的角点坐标位置  
  51.         int* cornerpos = cpbuf[(i - 3)%3];  
  52.         memset(curr, 0, img.cols);    //清零  
  53.         int ncorners = 0;    //检测到的角点数量  
  54.   
  55.         if( i < img.rows - 3 )  
  56.         {  
  57.             //每一行都留出3个像素的宽度  
  58.             j = 3;  
  59.     #if CV_SSE2  
  60.             if( patternSize == 16 )  
  61.             {  
  62.             for(; j < img.cols - 16 - 3; j += 16, ptr += 16)  
  63.             {  
  64.                 __m128i m0, m1;  
  65.                 __m128i v0 = _mm_loadu_si128((const __m128i*)ptr);  
  66.                 __m128i v1 = _mm_xor_si128(_mm_subs_epu8(v0, t), delta);  
  67.                 v0 = _mm_xor_si128(_mm_adds_epu8(v0, t), delta);  
  68.   
  69.                 __m128i x0 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[0])), delta);  
  70.                 __m128i x1 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[quarterPatternSize])), delta);  
  71.                 __m128i x2 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[2*quarterPatternSize])), delta);  
  72.                 __m128i x3 = _mm_sub_epi8(_mm_loadu_si128((const __m128i*)(ptr + pixel[3*quarterPatternSize])), delta);  
  73.                 m0 = _mm_and_si128(_mm_cmpgt_epi8(x0, v0), _mm_cmpgt_epi8(x1, v0));  
  74.                 m1 = _mm_and_si128(_mm_cmpgt_epi8(v1, x0), _mm_cmpgt_epi8(v1, x1));  
  75.                 m0 = _mm_or_si128(m0, _mm_and_si128(_mm_cmpgt_epi8(x1, v0), _mm_cmpgt_epi8(x2, v0)));  
  76.                 m1 = _mm_or_si128(m1, _mm_and_si128(_mm_cmpgt_epi8(v1, x1), _mm_cmpgt_epi8(v1, x2)));  
  77.                 m0 = _mm_or_si128(m0, _mm_and_si128(_mm_cmpgt_epi8(x2, v0), _mm_cmpgt_epi8(x3, v0)));  
  78.                 m1 = _mm_or_si128(m1, _mm_and_si128(_mm_cmpgt_epi8(v1, x2), _mm_cmpgt_epi8(v1, x3)));  
  79.                 m0 = _mm_or_si128(m0, _mm_and_si128(_mm_cmpgt_epi8(x3, v0), _mm_cmpgt_epi8(x0, v0)));  
  80.                 m1 = _mm_or_si128(m1, _mm_and_si128(_mm_cmpgt_epi8(v1, x3), _mm_cmpgt_epi8(v1, x0)));  
  81.                 m0 = _mm_or_si128(m0, m1);  
  82.                 int mask = _mm_movemask_epi8(m0);  
  83.                 if( mask == 0 )  
  84.                     continue;  
  85.                 if( (mask & 255) == 0 )  
  86.                 {  
  87.                     j -= 8;  
  88.                     ptr -= 8;  
  89.                     continue;  
  90.                 }  
  91.   
  92.                 __m128i c0 = _mm_setzero_si128(), c1 = c0, max0 = c0, max1 = c0;  
  93.                 for( k = 0; k < N; k++ )  
  94.                 {  
  95.                     __m128i x = _mm_xor_si128(_mm_loadu_si128((const __m128i*)(ptr + pixel[k])), delta);  
  96.                     m0 = _mm_cmpgt_epi8(x, v0);  
  97.                     m1 = _mm_cmpgt_epi8(v1, x);  
  98.   
  99.                     c0 = _mm_and_si128(_mm_sub_epi8(c0, m0), m0);  
  100.                     c1 = _mm_and_si128(_mm_sub_epi8(c1, m1), m1);  
  101.   
  102.                     max0 = _mm_max_epu8(max0, c0);  
  103.                     max1 = _mm_max_epu8(max1, c1);  
  104.                 }  
  105.   
  106.                 max0 = _mm_max_epu8(max0, max1);  
  107.                 int m = _mm_movemask_epi8(_mm_cmpgt_epi8(max0, K16));  
  108.   
  109.                 for( k = 0; m > 0 && k < 16; k++, m >>= 1 )  
  110.                     if(m & 1)  
  111.                     {  
  112.                         cornerpos[ncorners++] = j+k;  
  113.                         if(nonmax_suppression)  
  114.                             curr[j+k] = (uchar)cornerScore<patternSize>(ptr+k, pixel, threshold);  
  115.                     }  
  116.             }  
  117.             }  
  118.     #endif  
  119.             for( ; j < img.cols - 3; j++, ptr++ )  
  120.             {  
  121.                 //当前像素的灰度值  
  122.                 int v = ptr[0];  
  123.                 //由当前像素的灰度值,确定其在阈值列表中的位置  
  124.                 const uchar* tab = &threshold_tab[0] - v + 255;  
  125.                 //pixel[0]表示圆周上编号为0的像素相对于圆心坐标的偏移量  
  126.                 //ptr[pixel[0]表示圆周上编号为0的像素值  
  127.                 //tab[ptr[pixel[0]]]表示相对于当前像素(即圆心)圆周上编号为0的像素值在阈值列表threshold_tab中所查询得到的值,如果为1,说明I0 < Ip - t,如果为2,说明I0 > Ip + t,如果为0,说明 Ip – t < I0 < Ip + t。因此通过tab,就可以得到当前像素是否满足角点条件。  
  128.                 //编号为0和8(即直径在圆周上的两个像素点)在列表中的值相或后得到d。d=0说明编号为0和8的值都是0;d=1说明编号为0和8的值至少有一个为1,而另一个不能为2;d=2说明编号为0和8的值至少有一个为2,而另一个不能为1;d=3说明编号为0和8的值有一个为1,另一个为2。只可能有这四种情况。  
  129.                 int d = tab[ptr[pixel[0]]] | tab[ptr[pixel[8]]];  
  130.                 //d=0说明圆周上不可能有连续12个像素满足角点条件,因此当前值一定不是角点,所以退出此次循环,进入下一次循环  
  131.                 if( d == 0 )  
  132.                     continue;  
  133.                 //继续进行其他直径上两个像素点的判断  
  134.                 d &= tab[ptr[pixel[2]]] | tab[ptr[pixel[10]]];  
  135.                 d &= tab[ptr[pixel[4]]] | tab[ptr[pixel[12]]];  
  136.                 d &= tab[ptr[pixel[6]]] | tab[ptr[pixel[14]]];  
  137.                 //d=0说明上述d中至少有一个d为0,所以肯定不是角点;另一种情况是一个d为2,而另一个d为1,相与后也为0,这说明一个是满足角点条件1,而另一个满足角点条件2,所以肯定也不会有连续12个像素满足同一个角点条件的,因此也一定不是角点。  
  138.                 if( d == 0 )  
  139.                     continue;  
  140.                 //继续判断圆周上剩余的像素点  
  141.                 d &= tab[ptr[pixel[1]]] | tab[ptr[pixel[9]]];  
  142.                 d &= tab[ptr[pixel[3]]] | tab[ptr[pixel[11]]];  
  143.                 d &= tab[ptr[pixel[5]]] | tab[ptr[pixel[13]]];  
  144.                 d &= tab[ptr[pixel[7]]] | tab[ptr[pixel[15]]];  
  145.                 //如果满足if条件,则说明有可能满足角点条件2  
  146.                 if( d & 1 )  
  147.                 {  
  148.                     //vt为真正的角点条件,即Ip – t,count为连续像素的计数值  
  149.                     int vt = v - threshold, count = 0;  
  150.                     //遍历整个圆周  
  151.                     for( k = 0; k < N; k++ )  
  152.                     {  
  153.                         int x = ptr[pixel[k]];    //提取出圆周上的像素值  
  154.                         if(x < vt)    //如果满足条件2  
  155.                         {  
  156.                             //连续计数,并判断是否大于K(K为圆周像素的一半)  
  157.                             if( ++count > K )  
  158.                             {  
  159.                                 //进入该if语句,说明已经得到一个角点  
  160.                                 //保存该点的位置,并把当前行的角点数加1  
  161.                                 cornerpos[ncorners++] = j;  
  162.                                  //进行非极大值抑制的第一步,计算得分函数  
  163.                                 if(nonmax_suppression)     
  164.                                     curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);  
  165.                                 break;    //退出循环  
  166.                             }  
  167.                         }  
  168.                         else  
  169.                             count = 0;    //连续像素的计数值清零  
  170.                     }  
  171.                 }  
  172.                 //如果满足if条件,则说明有可能满足角点条件1  
  173.                 if( d & 2 )  
  174.                 {  
  175.                     //vt为真正的角点条件,即Ip + t,count为连续像素的计数值  
  176.                     int vt = v + threshold, count = 0;  
  177.                     //遍历整个圆周  
  178.                     for( k = 0; k < N; k++ )  
  179.                     {  
  180.                         int x = ptr[pixel[k]];    //提取出圆周上的像素值  
  181.                         if(x > vt)    //如果满足条件1  
  182.                         {  
  183.                             //连续计数,并判断是否大于K(K为圆周像素的一半)  
  184.                             if( ++count > K )  
  185.                             {  
  186.                                 //进入该if语句,说明已经得到一个角点  
  187.                                 //保存该点的位置,并把当前行的角点数加1  
  188.                                 cornerpos[ncorners++] = j;  
  189.                                  //进行非极大值抑制的第一步,计算得分函数  
  190.                                 if(nonmax_suppression)  
  191.                                     curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);  
  192.                                 break;    //退出循环  
  193.                             }  
  194.                         }  
  195.                         else  
  196.                             count = 0;    //连续像素的计数值清零  
  197.                     }  
  198.                 }  
  199.             }  
  200.         }  
  201.         //保存当前行所检测到的角点数  
  202.         cornerpos[-1] = ncorners;  
  203.         //i=3说明只仅仅计算了一行的数据,还不能进行非极大值抑制的第二步,所以不进行下面代码的操作,直接进入下一次循环  
  204.         if( i == 3 )  
  205.             continue;  
  206.         //以下代码是进行非极大值抑制的第二步,即在3×3的角点邻域内对得分函数的值进行非极大值抑制。因为经过上面代码的计算,已经得到了当前行的数据,所以可以进行上一行的非极大值抑制。因此下面的代码进行的是上一行的非极大值抑制。  
  207.         //提取出上一行和上两行的图像像素  
  208.         const uchar* prev = buf[(i - 4 + 3)%3];  
  209.         const uchar* pprev = buf[(i - 5 + 3)%3];  
  210.         //提取出上一行所检测到的角点位置  
  211.         cornerpos = cpbuf[(i - 4 + 3)%3];  
  212.         //提取出上一行的角点数  
  213.         ncorners = cornerpos[-1];  
  214.         //在上一行内遍历整个检测到的角点  
  215.         for( k = 0; k < ncorners; k++ )  
  216.         {  
  217.             j = cornerpos[k];    //得到角点的位置  
  218.             int score = prev[j];    //得到该角点的得分函数值  
  219.             //在3×3的角点邻域内,计算当前角点是否为最大值,如果是则压入特性值向量中  
  220.             if( !nonmax_suppression ||  
  221.                (score > prev[j+1] && score > prev[j-1] &&  
  222.                 score > pprev[j-1] && score > pprev[j] && score > pprev[j+1] &&  
  223.                 score > curr[j-1] && score > curr[j] && score > curr[j+1]) )  
  224.             {  
  225.                 keypoints.push_back(KeyPoint((float)j, (float)(i-1), 7.f, -1, (float)score));  
  226.             }  
  227.         }  
  228.     }  
  229. }  

在该函数内,对阈值列表理解起来可能有一定的难度,下面我们举一个具体的例子来进行讲解。设我们选取的阈值threshold为30,则根据

for( i = -255; i <= 255; i++ )

       threshold_tab[i+255] = (uchar)(i < -threshold ? 1 : i > threshold? 2 : 0);

我们可以从-255到255一共分为3段:-255~-30,-30~30,30~255。由于数组的序号不能小于0,因此在给threshold_tab数组赋值上,序号要加上255,这样区间就变为:0~225,225~285,285~510,而这三个区间对应的值分别为1,0和2。设我们当前像素值为40,则根据

const uchar* tab = &threshold_tab[0] -v + 255;

tab的指针指向threshold_tab[215]处,因为255-40=215。这样在圆周像素与当前像素进行比较时,使用的是threshold_tab[215]以后的值。例如圆周上编号为0的像素值为5,则该值在阈值列表中的位置是threshold_tab[215 + 5],是threshold_tab[220]。它在阈值列表中的第一段,即threshold_tab[220] = 1,说明编号为0的像素满足角点条件2。我们来验证一下:5 < 40 – 30,确实满足条件2;如果圆周上编号为1的像素值为80,则该值在阈值列表中的位置是threshold_tab[295](即215 + 80 = 295),而它在阈值列表中的第三段,即threshold_tab[295] = 2,因此它满足角点条件1,即80 > 40 + 30;而如果圆周上编号为2的像素值为45,则threshold_tab[260] = 0,它不满足角点条件,即40 – 30 < 45 < 40 + 30。

在函数模板FAST_t中还用到了两个重要的函数——makeOffsets和cornerScore,一个是用于计算圆周像素的偏移量,另一个用于非极大值抑制的第一步,计算得分函数。这两个函数都在sources/modules/features2d/src/fast_score.cpp文件内定义,而且代码编写得都很有特点,下面就来讲解一下。

计算圆周像素的偏移量:
[cpp]  view plain copy
  1. void makeOffsets(int pixel[25], int rowStride, int patternSize)  
  2. {  
  3.     //分别定义三个数组,用于表示patternSize为16,12和8时,圆周像素对于圆心的相对坐标位置  
  4.     static const int offsets16[][2] =  
  5.     {  
  6.         {0,  3}, { 1,  3}, { 2,  2}, { 3,  1}, { 3, 0}, { 3, -1}, { 2, -2}, { 1, -3},  
  7.         {0, -3}, {-1, -3}, {-2, -2}, {-3, -1}, {-3, 0}, {-3,  1}, {-2,  2}, {-1,  3}  
  8.     };  
  9.   
  10.     static const int offsets12[][2] =  
  11.     {  
  12.         {0,  2}, { 1,  2}, { 2,  1}, { 2, 0}, { 2, -1}, { 1, -2},  
  13.         {0, -2}, {-1, -2}, {-2, -1}, {-2, 0}, {-2,  1}, {-1,  2}  
  14.     };  
  15.   
  16.     static const int offsets8[][2] =  
  17.     {  
  18.         {0,  1}, { 1,  1}, { 1, 0}, { 1, -1},  
  19.         {0, -1}, {-1, -1}, {-1, 0}, {-1,  1}  
  20.     };  
  21.     //根据patternSize值,得到具体应用上面定义的哪个数组  
  22.     const int (*offsets)[2] = patternSize == 16 ? offsets16 :  
  23.                               patternSize == 12 ? offsets12 :  
  24.                               patternSize == 8  ? offsets8  : 0;  
  25.   
  26.     CV_Assert(pixel && offsets);  
  27.   
  28.     int k = 0;  
  29.     //代入输入图像每行的像素个数,得到圆周像素的绝对坐标位置  
  30.     for( ; k < patternSize; k++ )  
  31.         pixel[k] = offsets[k][0] + offsets[k][1] * rowStride;  
  32.     //由于要计算连续的像素,因此要循环的多列出一些值  
  33.     for( ; k < 25; k++ )  
  34.         pixel[k] = pixel[k - patternSize];  
  35. }  
计算得分函数,cornerScore函数是以圆周像素为16点为例而编写的:
[cpp]  view plain copy
  1. template<>  
  2. int cornerScore<16>(const uchar* ptr, const int pixel[], int threshold)  
  3. {  
  4.     const int K = 8, N = K*3 + 1;  
  5.     //v为当前像素值  
  6.     int k, v = ptr[0];  
  7.     short d[N];  
  8.     //计算当前像素值与其圆周像素值之间的差值  
  9.     for( k = 0; k < N; k++ )  
  10.         d[k] = (short)(v - ptr[pixel[k]]);  
  11.   
  12. #if CV_SSE2  
  13.     __m128i q0 = _mm_set1_epi16(-1000), q1 = _mm_set1_epi16(1000);  
  14.     for( k = 0; k < 16; k += 8 )  
  15.     {  
  16.         __m128i v0 = _mm_loadu_si128((__m128i*)(d+k+1));  
  17.         __m128i v1 = _mm_loadu_si128((__m128i*)(d+k+2));  
  18.         __m128i a = _mm_min_epi16(v0, v1);  
  19.         __m128i b = _mm_max_epi16(v0, v1);  
  20.         v0 = _mm_loadu_si128((__m128i*)(d+k+3));  
  21.         a = _mm_min_epi16(a, v0);  
  22.         b = _mm_max_epi16(b, v0);  
  23.         v0 = _mm_loadu_si128((__m128i*)(d+k+4));  
  24.         a = _mm_min_epi16(a, v0);  
  25.         b = _mm_max_epi16(b, v0);  
  26.         v0 = _mm_loadu_si128((__m128i*)(d+k+5));  
  27.         a = _mm_min_epi16(a, v0);  
  28.         b = _mm_max_epi16(b, v0);  
  29.         v0 = _mm_loadu_si128((__m128i*)(d+k+6));  
  30.         a = _mm_min_epi16(a, v0);  
  31.         b = _mm_max_epi16(b, v0);  
  32.         v0 = _mm_loadu_si128((__m128i*)(d+k+7));  
  33.         a = _mm_min_epi16(a, v0);  
  34.         b = _mm_max_epi16(b, v0);  
  35.         v0 = _mm_loadu_si128((__m128i*)(d+k+8));  
  36.         a = _mm_min_epi16(a, v0);  
  37.         b = _mm_max_epi16(b, v0);  
  38.         v0 = _mm_loadu_si128((__m128i*)(d+k));  
  39.         q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));  
  40.         q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));  
  41.         v0 = _mm_loadu_si128((__m128i*)(d+k+9));  
  42.         q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));  
  43.         q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));  
  44.     }  
  45.     q0 = _mm_max_epi16(q0, _mm_sub_epi16(_mm_setzero_si128(), q1));  
  46.     q0 = _mm_max_epi16(q0, _mm_unpackhi_epi64(q0, q0));  
  47.     q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 4));  
  48.     q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 2));  
  49.     threshold = (short)_mm_cvtsi128_si32(q0) - 1;  
  50. #else  
  51.     //a0为阈值  
  52.     int a0 = threshold;  
  53.     //满足角点条件1时,更新阈值  
  54.     for( k = 0; k < 16; k += 2 )  
  55.     {  
  56.         //a为d[k+1],d[k+2]和d[k+3]中的最小值  
  57.         int a = std::min((int)d[k+1], (int)d[k+2]);  
  58.         a = std::min(a, (int)d[k+3]);  
  59.         //如果a小于阈值,则进行下一次循环  
  60.         if( a <= a0 )  
  61.             continue;  
  62.         //更新阈值  
  63.         //a为从d[k+1]到d[k+8]中的最小值  
  64.         a = std::min(a, (int)d[k+4]);  
  65.         a = std::min(a, (int)d[k+5]);  
  66.         a = std::min(a, (int)d[k+6]);  
  67.         a = std::min(a, (int)d[k+7]);  
  68.         a = std::min(a, (int)d[k+8]);  
  69.         //从d[k]到d[k+9]中的最小值与a0比较,哪个大,哪个作为新的阈值  
  70.         a0 = std::max(a0, std::min(a, (int)d[k]));  
  71.         a0 = std::max(a0, std::min(a, (int)d[k+9]));  
  72.     }  
  73.     //满足角点条件2时,更新阈值  
  74.     int b0 = -a0;  
  75.     for( k = 0; k < 16; k += 2 )  
  76.     {  
  77.         int b = std::max((int)d[k+1], (int)d[k+2]);  
  78.         b = std::max(b, (int)d[k+3]);  
  79.         b = std::max(b, (int)d[k+4]);  
  80.         b = std::max(b, (int)d[k+5]);  
  81.         if( b >= b0 )  
  82.             continue;  
  83.         b = std::max(b, (int)d[k+6]);  
  84.         b = std::max(b, (int)d[k+7]);  
  85.         b = std::max(b, (int)d[k+8]);  
  86.   
  87.         b0 = std::min(b0, std::max(b, (int)d[k]));  
  88.         b0 = std::min(b0, std::max(b, (int)d[k+9]));  
  89.     }  
  90.   
  91.     threshold = -b0-1;  
  92. #endif  
  93.   
  94. #if VERIFY_CORNERS  
  95.     testCorner(ptr, pixel, K, N, threshold);  
  96. #endif  
  97.     //更新后的阈值作为输出  
  98.     return threshold;  
  99. }  

可以有两种方法实现FAST角点检测,即直接调用FAST函数,和使用特征点检测类的方式。这两种方法我们都给出实例。

首先是直接调用FAST函数的应用程序:

[cpp]  view plain copy
  1. #include "opencv2/core/core.hpp"  
  2. #include "opencv2/highgui/highgui.hpp"  
  3. #include "opencv2/imgproc/imgproc.hpp"  
  4. #include "opencv2/features2d/features2d.hpp"    //需要添加该头文件  
  5. #include <iostream>  
  6. using namespace cv;  
  7. using namespace std;  
  8.   
  9. int main( int argc, char** argv )  
  10. {  
  11.     Mat src, gray;  
  12.     src=imread("building.jpg");  
  13.     if( !src.data )    
  14.         return -1;    
  15.     //彩色图像转换为灰度图像  
  16.     cvtColor( src, gray, CV_BGR2GRAY );  
  17.     //定义特征点KeyPoint向量  
  18.     std::vector<KeyPoint> keyPoints;    
  19.     //调用FAST函数,阈值选为55  
  20.     FAST(gray, keyPoints, 55);  
  21.   
  22.     int total = keyPoints.size();  
  23.     //在原图上画出特征点  
  24.     for(int i = 0; I < total; i++)  
  25.     {  
  26.             circle( src, Point( (int)keyPoints[i].pt.x, (int)keyPoints[i].pt.y ), 5, Scalar(0,0,255), -1, 8, 0 );  
  27.     }  
  28.   
  29.   namedWindow( "Corners", CV_WINDOW_AUTOSIZE );  
  30.   imshow( "Corners", src );  
  31.    
  32.   waitKey(0);  
  33.   return 0;  
  34. }  

下面是应用FeatureDetector类进行的FAST角点检测,使用的类为FastFeatureDetector,它继承于FeatureDetector,即:

class FastFeatureDetector : publicFeatureDetector

{

public:

FastFeatureDetector( int threshold=1, boolnonmaxSuppression=true, type=FastFeatureDetector::TYPE_9_16 );

virtual void read( const FileNode& fn);

virtual void write( FileStorage& fs )const;

protected:

...

};

从上面的定义可以看出,FastFeatureDetector的构造函数默认的阈值为1,进行非极大值抑制,以及圆周像素为16个。下面是具体的应用程序:
[cpp]  view plain copy
  1. #include "opencv2/core/core.hpp"  
  2. #include "opencv2/highgui/highgui.hpp"  
  3. #include "opencv2/imgproc/imgproc.hpp"  
  4. #include "opencv2/features2d/features2d.hpp"  
  5. #include <iostream>  
  6. using namespace cv;  
  7. using namespace std;  
  8.   
  9. int main( int argc, char** argv )  
  10. {  
  11.     Mat src, gray,color_edge;  
  12.     src=imread("building.jpg");  
  13.     if( !src.data )    
  14.         return -1;    
  15.   
  16.      std::vector<KeyPoint> keyPoints;    
  17.     //创建对象,阈值设为55  
  18.     FastFeatureDetector fast(55);       
  19.     //特征点检测  
  20.     fast.detect(src,keyPoints);    
  21.     //在原图上画出特征点  
  22.     drawKeypoints(src, keyPoints, src, Scalar(0, 0, 255), DrawMatchesFlags::DRAW_OVER_OUTIMG);    
  23.     imshow("FAST feature", src);    
  24.     waitKey(0);    
  25.     return 0;  
  26. }  

你可能感兴趣的:(FAST(Features fromaccelerated segment test)源码分析)