Opencv中goodFeaturesToTrack函数(Harris角点、Shi-Tomasi角点检测)算子速度的进一步优化（1920*1080测试图11ms处理完成）。

void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
                              int maxCorners, double qualityLevel, double minDistance,
                              InputArray _mask, int blockSize,
                              bool useHarrisDetector, double harrisK )
{
    Mat image = _image.getMat(), eig, tmp;
    if( useHarrisDetector )
        cornerHarris( image, eig, blockSize, 3, harrisK );
    else
        cornerMinEigenVal( image, eig, blockSize, 3 );
    double maxVal = 0;
    minMaxLoc( eig, 0, &maxVal, 0, 0, _mask );
    threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO );
    dilate( eig, tmp, Mat());
    Size imgsize = image.size();
    std::vector<const float*> tmpCorners;
    // 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);
        }
    }
    std::sort( tmpCorners.begin(), tmpCorners.end(), greaterThanPtr() );
    std::vector<Point2f> corners;
    size_t i, j, total = tmpCorners.size(), ncorners = 0;
    if (minDistance >= 1)
    {
         // Partition the image into larger grids
    }
    else
    {
       
    }
    Mat(corners).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);
}

　　minMaxLoc这个函数找到最大值没有办法，必须进行，threshold、dilate（三成三的最大值）以及后续的候选点选择，我们仔细分析下，完全是可以写到一个函数里的。在候选点选择里，它使用了判断语句：

if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) )

　　抛开后续的mask的判断部分，前面的 val != 0 的判断依据是前面进行threshold后，所有小于maxVal*qualityLevel的部分都已经等于零0，那也就是等价于判断 val >= maxVal*qualityLevel是否成立。

　　判断val == tmp_data[x]两者是否相等，是判断当前值是否是3*3领域内的最大值的意思，程序里先求出3*3领域的最大值，然后在判断是否相等，这里其实是有所浪费资源的。

　　我们知道，每次加载内存和保存数据到内存在某种程度上来说都是有着较大的消耗的，但是在CPU内核里进行一些计算速度是相当快的，因此，既然上述这是几个功能其实可以集中到一起实现，我们就没有必然分散到各个函数中，而是可以全部集中到一个代码中，
下面是我使用C语言初步整理的一个过程：

            __m128i DxDy_L = _mm_mullo_epi32(_mm_cvtepi16_epi32(Dx), _mm_cvtepi16_epi32(Dy));
            __m128i DxDy_H = _mm_mullo_epi32(_mm_cvtepi16_epi32(_mm_srli_si128(Dx, 8)), _mm_cvtepi16_epi32(_mm_srli_si128(Dy, 8)));

            __m128i L = _mm_mullo_epi16(Dx, Dy);
            __m128i H = _mm_mulhi_epi16(Dx, Dy);
            __m128i DxDy_L = _mm_unpacklo_epi16(L, H);
            __m128i DxDy_H = _mm_unpackhi_epi16(L, H);

int IM_FastestBoxBlur3X3_I16(short *Src, short *Dest, int Width, int Height)
{
    if ((Src == NULL) || (Dest == NULL))                    return IM_STATUS_NULLREFRENCE;
    if ((Width <= 0) || (Height <= 0))                        return IM_STATUS_INVALIDPARAMETER;

    short *RowCopy = (short *)malloc((Width + 2) * 3 * sizeof(short));
    if (RowCopy == NULL)    return IM_STATUS_OUTOFMEMORY;

    short *First = RowCopy;
    short *Second = RowCopy + (Width + 2);
    short *Third = RowCopy + (Width + 2) * 2;

    memcpy(Second, Src, sizeof(short));
    memcpy(Second + 1, Src, Width * sizeof(short));                                                        //    拷贝数据到中间位置
    memcpy(Second + (Width + 1), Src + (Width - 1), sizeof(short));

    memcpy(First, Second, (Width + 2) * sizeof(short));                                                    //    第一行和第二行一样

    memcpy(Third, Src + Width, sizeof(short));                                                            //    拷贝第二行数据
    memcpy(Third + 1, Src + Width, Width * sizeof(short));
    memcpy(Third + (Width + 1), Src + Width + (Width - 1), sizeof(short));

    int BlockSize = 8, Block = Width / BlockSize;            //    测试表面一次性处理4个像素处理8个要快一些

    for (int Y = 0; Y < Height; Y++)
    {
        short *LinePS = Src + Y * Width;
        short *LinePD = Dest + Y * Width;
        if (Y != 0)
        {
            short *Temp = First; First = Second; Second = Third; Third = Temp;
        }
        if (Y == Height - 1)
        {
            memcpy(Third, Second, (Width + 2) * sizeof(short));
        }
        else
        {
            memcpy(Third, Src + (Y + 1) * Width, sizeof(short));
            memcpy(Third + 1, Src + (Y + 1) * Width, Width * sizeof(short));                            //    由于备份了前面一行的数据，这里即使Src和Dest相同也是没有问题的
            memcpy(Third + (Width + 1), Src + (Y + 1) * Width + (Width - 1), sizeof(short));
        }
        for (int X = 0; X < Block * BlockSize; X += BlockSize)
        {
            __m128i P0 = _mm_loadu_si128((__m128i *)(First + X));
            __m128i P1 = _mm_loadu_si128((__m128i *)(First + X + 1));
            __m128i P2 = _mm_loadu_si128((__m128i *)(First + X + 2));

            __m128i P3 = _mm_loadu_si128((__m128i *)(Second + X));
            __m128i P4 = _mm_loadu_si128((__m128i *)(Second + X + 1));
            __m128i P5 = _mm_loadu_si128((__m128i *)(Second + X + 2));

            __m128i P6 = _mm_loadu_si128((__m128i *)(Third + X));
            __m128i P7 = _mm_loadu_si128((__m128i *)(Third + X + 1));
            __m128i P8 = _mm_loadu_si128((__m128i *)(Third + X + 2));

            __m128i Sum0123 = _mm_adds_epi16(_mm_adds_epi16(P0, P1), _mm_adds_epi16(P2, P3));
            __m128i Sum5678 = _mm_adds_epi16(_mm_adds_epi16(P5, P6), _mm_adds_epi16(P7, P8));
            __m128i Sum = _mm_adds_epi16(_mm_adds_epi16(Sum0123, Sum5678), P4);

            _mm_storeu_si128((__m128i *)(LinePD + X), Sum);
        }
        for (int X = Block * BlockSize; X < Width; X++)
        {
            int P0 = First[X], P1 = First[X + 1], P2 = First[X + 2];
            int P3 = Second[X], P4 = Second[X + 1], P5 = Second[X + 2];
            int P6 = Third[X], P7 = Third[X + 1], P8 = Third[X + 2];
            LinePD[X] = P0 + P1 + P2 + P3 + P4 + P5 + P6 + P7 + P8;
        }
    }
    free(RowCopy);
    return IM_STATUS_OK;
}