上面一篇部落格分析了HARRIS和ShiTomasi角點檢測的原始碼。而為了提取更準確的角點，OpenCV中提供了goodFeaturesToTrack（）這個API函式，來獲取更加準確的角點位置。這篇部落格主要分析goodFeaturesToTrack（）的原始碼。

　　函式原型如下：

void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
                              int maxCorners, double qualityLevel, double minDistance,
                              InputArray _mask, 
 
int blockSize, int gradientSize,
                              bool useHarrisDetector, double harrisK )

　　_image為輸入的單通道影象；_corners為輸出提取的角點座標；maxCorners為設定的最大角點個數，程式中會按照角點強度降序排序，超過maxCorners的角點將被捨棄；qualityLevel為角點強度的閾值係數，如果檢測出所有角點中的最大強度為max，則強度值＜max*qualityLevel得角點會被捨棄；minDistance為角點與其鄰域強角點之間的歐式距離，與鄰域強角點距離小於minDistance的角點將被捨棄；_mask為設定的感興趣區域，通常可不設定；blockSize是協方差矩陣濾波的視窗大小；gradientSize為sobel運算元求微分的視窗的大小；useHarrisDetector為是否使用Harris角點檢測；harrisK為Harris角點檢測特徵表示式中的常數k值。

　　接下來看原始碼，首先根據useHarrisDetector這個flg值的設定選取不同的方法提取初始角點：

   //提取初始角點
　　if( useHarrisDetector )
        cornerHarris( image, eig, blockSize, gradientSize, harrisK );
    else
        cornerMinEigenVal( image, eig, blockSize, gradientSize );

　　然後選取出所有角點特徵值的最大值maxVal，並進行閾值化，將小於maxVal*qulityLevel的特徵值捨棄掉（置為0），其餘保持不變。並用3x3的方形膨脹核對特徵值矩陣進行膨脹操作，膨脹的目的是使孤立的區域性最大值擴大化，膨脹過後3x3鄰域的非區域性最大值點被區域性最大值取代。膨脹過後的特徵值影象為tmp，後面會用到。

    //獲取最大角點特徵值
    double maxVal = 0;
    minMaxLoc( eig, 0, &maxVal, 0, 0, _mask );
    threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO );
    dilate( eig, tmp, Mat());

　　取出區域性最大值點，並將其地址儲存到tmpCorners這個容器中。（val==tem_data[x]表示該點未被膨脹操作影響，就是區域性極大值點）

// collect list of pointers to features - put them into temporary image
    Mat mask = _mask.getMat();
    for( int y = 1; y < imgsize.height - 1; y++ )
    {
        const float* eig_data = (const float*)eig.ptr(y);
        const float* tmp_data = (const float*)tmp.ptr(y);
        const uchar* mask_data = mask.data ? mask.ptr(y) : 0;

        for( int x = 1; x < imgsize.width - 1; x++ )
        {
            float val = eig_data[x];
            if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) )
                tmpCorners.push_back(eig_data + x);
        }
    }

　　然後將tmpCorners中指標指向的值進行降序排列，（其實是隻改變指標指向的位置）：

 std::sort( tmpCorners.begin(), tmpCorners.end(), greaterThanPtr() ); 

　　接下來是不太好理解的地方，首先進行minDistance的判斷。如果minDistance<1，也就是不進行minDistance的條件限制，直接儲存前maxCorners個角點並返回；如果minDistance>=1，則執行if{}中的程式碼段。

　　首先弄清楚grid這個是什麼東西，grid容器中元素個數是影象畫素點個數的1/(cell_size*cell_size)倍，但是它是一個vector<vector<Point2f>>，也就是指grid中的每一個元素是一個vetcor<Point2f>（意思就是一個元素對應n個2維座標點）。這個理解起來就是grid中相差一個畫素，相當於原影象中相差minDistance個畫素。原影象中以當前畫素為中心的minDistance範圍內的點在grid中其實視為一個畫素的3x3鄰域（一對多的關係）。

　　接下來的分析見註釋:

if (minDistance >= 1)
    {
         // Partition the image into larger grids
        int w = image.cols;
        int h = image.rows;

        const int cell_size = cvRound(minDistance);
　　　　
　　　　　//grid中元素(vector)個數為grid_width*grid_height個，+cell_size-1的目的是保證能夠覆蓋所有的畫素點
        const int grid_width = (w + cell_size - 1) / cell_size;
        const int grid_height = (h + cell_size - 1) / cell_size;

        std::vector<std::vector<Point2f> > grid(grid_width*grid_height);

        minDistance *= minDistance;

        for( i = 0; i < total; i++ )
        {
            int ofs = (int)((const uchar*)tmpCorners[i] - eig.ptr());
            int y = (int)(ofs / eig.step);
            int x = (int)((ofs - y*eig.step)/sizeof(float));
            //假設開始所有的角點是good
            bool good = true;
            //將原圖中角點座標歸一化到mindistance鄰域
            int x_cell = x / cell_size;
            int y_cell = y / cell_size;
            //取歸一化後點的鄰域4個點座標（不是4鄰域，而是4個角），在grid中的座標
            int x1 = x_cell - 1;
            int y1 = y_cell - 1;
            int x2 = x_cell + 1;
            int y2 = y_cell + 1;

            // boundary check 邊界判斷
            x1 = std::max(0, x1);
            y1 = std::max(0, y1);
            x2 = std::min(grid_width-1, x2);
            y2 = std::min(grid_height-1, y2);
            //遍歷鄰域4個點， grid中的鄰域座標
            for( int yy = y1; yy <= y2; yy++ )
            {
                for( int xx = x1; xx <= x2; xx++ )
                {
                    //取出grid中一個元素對應的所有強角點座標位置
                    std::vector <Point2f> &m = grid[yy*grid_width + xx];
                    //如果某元素對應的原影象角點容器中有已經儲存的強角點，則需要進行距離判斷。否則指定原影象中該角點就是強角點
                    if( m.size() )
                    {
                        //遍歷其對應容器內的其他強角點，並依次判斷原影象中當前角點與其鄰域內其他強角點之間的歐式距離，如果歐式距離小於minDistance，則將當前角點標誌置為good=false（拋棄）,並跳出
                        for(j = 0; j < m.size(); j++)
                        {
                            float dx = x - m[j].x;
                            float dy = y - m[j].y;

                            if( dx*dx + dy*dy < minDistance )
                            {
                                good = false;
                                goto break_out;
                            }
                        }
                    }
                }
            }

            break_out:
　　　　　　　//如果角點為good，則將該角點儲存在當前grid中一個元素對應的容器中，同時儲存在輸出容器corners中，並累加計數器ncorners。由於已經進行過降序排序，前面儲存的都是強角點。
            if (good)
            {
                grid[y_cell*grid_width + x_cell].push_back(Point2f((float)x, (float)y));

                corners.push_back(Point2f((float)x, (float)y));
                ++ncorners;

                if( maxCorners > 0 && (int)ncorners == maxCorners )
                    break;
            }
        }
    }
    else
    {
        for( i = 0; i < total; i++ )
        {
            int ofs = (int)((const uchar*)tmpCorners[i] - eig.ptr());
            int y = (int)(ofs / eig.step);
            int x = (int)((ofs - y*eig.step)/sizeof(float));

            corners.push_back(Point2f((float)x, (float)y));
            ++ncorners;
            if( maxCorners > 0 && (int)ncorners == maxCorners )
                break;
        }
    }

    Mat(corners).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);

　　結束！