modifiedOrbRegistration

最新推荐文章于 2022-07-22 11:36:49 发布
最新推荐文章于 2022-07-22 11:36:49 发布
阅读量502 收藏
点赞数
分类专栏： 数字图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youzi1992/article/details/79784001
版权 
#include <iostream>
#include <opencv2/opencv.hpp>

/*
#include "precomp.hpp"
#include "fast.hpp"
#include "fast_score.hpp"
#include "opencl_kernels_features2d.hpp"
#include "hal_replacement.hpp"
#include "opencv2/core/hal/intrin.hpp"
//#include "opencv2/core/openvx/ovx_defs.hpp"
*/

/*
opencv 所实现的FAST算法与自实现的算法检测结果不同， opencv算法的特征点均匀性更好
自己重写的代码均匀性不好，集中在几个地方，需要好好看看
是不是与opencl, openvx等相关
*/

using namespace cv;
using namespace std;

Mat getHomographyMatrixWithOrb(Mat image1, Mat image2);
vector<KeyPoint> detectFastKeyPoints(Mat image);
template<int patternSize>
void detectFASTKeyPoints(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression);
template<int patternSize>
void detectFASTKeyPoints(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, int windowHeight, int windowWidth);
template<int patternSize>
int cornerScore(const uchar* ptr, const int pixel[], int threshold);
void makeOffsets(int pixel[25], int rowStride, int patternSize);

void main() {
    Mat image1 = imread("C:\\opencv_cpp\\imagecalibration\\imagestobedealed\\waterfalls1\\1.jpg");
    Mat image2 = imread("C:\\opencv_cpp\\imagecalibration\\imagestobedealed\\waterfalls1\\2.jpg");
    //if()
    //getHomographyMatrixWithOrb(image1, image2);
    double t_start_1 = getTickCount();
    vector<KeyPoint> keyPoints1;
    Ptr<FastFeatureDetector> fd = FastFeatureDetector::create(20, true, FastFeatureDetector::TYPE_9_16);
    fd->detect(image1, keyPoints1, Mat());
    cout << "keyPoints1.size: " << keyPoints1.size() << endl;
    double t_stop_1 = getTickCount();
    cout << "time consumed in opencv FAST: " << (t_stop_1 - t_start_1) / getTickFrequency() << "秒" << endl;
    Mat image1WithKeyPoint1;
    drawKeypoints(image1, keyPoints1, image1WithKeyPoint1, Scalar(0, 0, 255));
    imwrite("image1WithKeyPoint1.jpg", image1WithKeyPoint1);

    double t_start_2 = getTickCount();
    vector<KeyPoint> keyPoints2;
    keyPoints2 = detectFastKeyPoints(image1);
    cout << "keyPoints2.size: " << keyPoints2.size() << endl;
    double t_stop_2 = getTickCount();
    cout << "time consumed in self-defined FAST: " << (t_stop_2 - t_start_2) / getTickFrequency() << "秒" << endl;
    Mat image1WithKeyPoint2;
    drawKeypoints(image1, keyPoints2, image1WithKeyPoint2, Scalar(0, 0, 255));
    imwrite("image1WithKeyPoint2.jpg", image1WithKeyPoint2);
    char c;
    cin >> c;
}

Mat getHomographyMatrixWithOrb(Mat image1, Mat image2) {
    Ptr<ORB> orb = ORB::create();
    vector<KeyPoint> keyPoints1, keyPoints2;
    Mat descriptor1, descriptor2;
    orb->detectAndCompute(image1, Mat(), keyPoints1, descriptor1);
    orb->detectAndCompute(image2, Mat(), keyPoints2, descriptor2);
    Mat image1PlusKeyPoints, image2PlusKeyPoints;
    drawKeypoints(image1, keyPoints1, image1PlusKeyPoints, Scalar(255, 0, 0));
    drawKeypoints(image2, keyPoints2, image2PlusKeyPoints, Scalar(255, 0, 0));
    imwrite("image1PlusKeyPoints.jpg", image1PlusKeyPoints);
    imwrite("image2PlusKeyPoints.jpg", image2PlusKeyPoints);

    //求取BF匹配
    BFMatcher bfMatcher;
    std::vector< DMatch > bfMatches;
    bfMatcher.match(descriptor2, descriptor1, bfMatches);
    Mat image2MatchToImage1;
    drawMatches(image2, keyPoints2, image1, keyPoints1, bfMatches, image2MatchToImage1);
    imwrite("image2MatchToImage1.jpg", image2MatchToImage1);

    vector< DMatch > ransacMatches;
    vector<Point2f> points1(bfMatches.size());
    vector<Point2f> points2(bfMatches.size());
    for (size_t i = 0; i < bfMatches.size(); i++)
    {
        points1[i] = keyPoints1[bfMatches[i].trainIdx].pt;
        points2[i] = keyPoints2[bfMatches[i].queryIdx].pt;
    }
    //用RANSAC求取单应矩阵的方式去掉不可靠的BF匹配
    vector<uchar> flag(bfMatches.size(), 0);
    Mat H = findHomography(points2, points1, CV_RANSAC, 3.0, flag);
    for (int i = 0; i < bfMatches.size(); i++) {
        if (flag.at(i) != 0) {
            DMatch dMatch(bfMatches.at(i).queryIdx, bfMatches.at(i).trainIdx, bfMatches.at(i).distance);
            ransacMatches.push_back(dMatch);
        }
    }
    Mat goodImage2MatchToImage1;
    drawMatches(image2, keyPoints2, image1, keyPoints1, ransacMatches, goodImage2MatchToImage1);
    imwrite("goodImage2MatchToImage1.jpg", goodImage2MatchToImage1);
    cout << "ransacMatches.size: " << ransacMatches.size() << endl;
    char a;
    cin >> a;
    return H;
}

//对于1920*1080像素的照片，在这里的处理是将其划分为60*60的区块
//及局部最大值抑制区的大小为32*18
vector<KeyPoint> detectFastKeyPoints(Mat image) {
    vector<KeyPoint> keyPoints;
    //detectFASTKeyPoints<16>(image, keyPoints, 20, true);
    detectFASTKeyPoints<16>(image, keyPoints, 20, true, 32, 18);
    return keyPoints;
}

template<int patternSize>
void detectFASTKeyPoints(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression)
{
    Mat img = _img.getMat();
    const int K = patternSize / 2, N = patternSize + K + 1;
    int i, j, k, pixel[25];
    makeOffsets(pixel, (int)img.step, patternSize);

#if CV_SIMD128
    const int quarterPatternSize = patternSize / 4;
    v_uint8x16 delta = v_setall_u8(0x80), t = v_setall_u8((char)threshold), K16 = v_setall_u8((char)K);
    bool hasSimd = hasSIMD128();
#if CV_TRY_AVX2
    Ptr<opt_AVX2::FAST_t_patternSize16_AVX2> fast_t_impl_avx2;
    if (CV_CPU_HAS_SUPPORT_AVX2)
        fast_t_impl_avx2 = opt_AVX2::FAST_t_patternSize16_AVX2::getImpl(img.cols, threshold, nonmax_suppression, pixel);
#endif

#endif

    keypoints.clear();

    threshold = std::min(std::max(threshold, 0), 255);

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

    AutoBuffer<uchar> _buf((img.cols + 16) * 3 * (sizeof(int) + sizeof(uchar)) + 128);
    uchar* buf[3];
    buf[0] = _buf; buf[1] = buf[0] + img.cols; buf[2] = buf[1] + img.cols;
    int* cpbuf[3];
    cpbuf[0] = (int*)alignPtr(buf[2] + img.cols, sizeof(int)) + 1;
    cpbuf[1] = cpbuf[0] + img.cols + 1;
    cpbuf[2] = cpbuf[1] + img.cols + 1;
    memset(buf[0], 0, img.cols * 3);

    for (i = 3; i < img.rows - 2; i++)
    {
        const uchar* ptr = img.ptr<uchar>(i) + 3;
        uchar* curr = buf[(i - 3) % 3];
        int* cornerpos = cpbuf[(i - 3) % 3];
        memset(curr, 0, img.cols);
        int ncorners = 0;

        if (i < img.rows - 3)
        {
            j = 3;
#if CV_SIMD128
            if (hasSimd)
            {
                if (patternSize == 16)
                {
#if CV_TRY_AVX2
                    if (fast_t_impl_avx2)
                        fast_t_impl_avx2->process(j, ptr, curr, cornerpos, ncorners);
#endif
                    //vz if (j <= (img.cols - 27)) //it doesn't make sense using vectors for less than 8 elements
                    {
                        for (; j < img.cols - 16 - 3; j += 16, ptr += 16)
                        {
                            v_uint8x16 v = v_load(ptr);
                            v_int8x16 v0 = v_reinterpret_as_s8((v + t) ^ delta);
                            v_int8x16 v1 = v_reinterpret_as_s8((v - t) ^ delta);

                            v_int8x16 x0 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[0]), delta));
                            v_int8x16 x1 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[quarterPatternSize]), delta));
                            v_int8x16 x2 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[2 * quarterPatternSize]), delta));
                            v_int8x16 x3 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[3 * quarterPatternSize]), delta));

                            v_int8x16 m0, m1;
                            m0 = (v0 < x0) & (v0 < x1);
                            m1 = (x0 < v1) & (x1 < v1);
                            m0 = m0 | ((v0 < x1) & (v0 < x2));
                            m1 = m1 | ((x1 < v1) & (x2 < v1));
                            m0 = m0 | ((v0 < x2) & (v0 < x3));
                            m1 = m1 | ((x2 < v1) & (x3 < v1));
                            m0 = m0 | ((v0 < x3) & (v0 < x0));
                            m1 = m1 | ((x3 < v1) & (x0 < v1));
                            m0 = m0 | m1;

                            int mask = v_signmask(m0);
                            if (mask == 0)
                                continue;
                            if ((mask & 255) == 0)
                            {
                                j -= 8;
                                ptr -= 8;
                                continue;
                            }

                            v_int8x16 c0 = v_setzero_s8();
                            v_int8x16 c1 = v_setzero_s8();
                            v_uint8x16 max0 = v_setzero_u8();
                            v_uint8x16 max1 = v_setzero_u8();
                            for (k = 0; k < N; k++)
                            {
                                v_int8x16 x = v_reinterpret_as_s8(v_load((ptr + pixel[k])) ^ delta);
                                m0 = v0 < x;
                                m1 = x < v1;

                                c0 = v_sub_wrap(c0, m0) & m0;
                                c1 = v_sub_wrap(c1, m1) & m1;

                                max0 = v_max(max0, v_reinterpret_as_u8(c0));
                                max1 = v_max(max1, v_reinterpret_as_u8(c1));
                            }

                            max0 = v_max(max0, max1);
                            int m = v_signmask(K16 < max0);

                            for (k = 0; m > 0 && k < 16; k++, m >>= 1)
                            {
                                if (m & 1)
                                {
                                    cornerpos[ncorners++] = j + k;
                                    if (nonmax_suppression)
                                        curr[j + k] = (uchar)cornerScore<patternSize>(ptr + k, pixel, threshold);
                                }
                            }
                        }
                    }
                }
            }
#endif
            for (; j < img.cols - 3; j++, ptr++)
            {
                int v = ptr[0];
                const uchar* tab = &threshold_tab[0] - v + 255;
                int d = tab[ptr[pixel[0]]] | tab[ptr[pixel[8]]];

                if (d == 0)
                    continue;

                d &= tab[ptr[pixel[2]]] | tab[ptr[pixel[10]]];
                d &= tab[ptr[pixel[4]]] | tab[ptr[pixel[12]]];
                d &= tab[ptr[pixel[6]]] | tab[ptr[pixel[14]]];

                if (d == 0)
                    continue;

                d &= tab[ptr[pixel[1]]] | tab[ptr[pixel[9]]];
                d &= tab[ptr[pixel[3]]] | tab[ptr[pixel[11]]];
                d &= tab[ptr[pixel[5]]] | tab[ptr[pixel[13]]];
                d &= tab[ptr[pixel[7]]] | tab[ptr[pixel[15]]];

                if (d & 1)
                {
                    int vt = v - threshold, count = 0;

                    for (k = 0; k < N; k++)
                    {
                        int x = ptr[pixel[k]];
                        if (x < vt)
                        {
                            if (++count > K)
                            {
                                cornerpos[ncorners++] = j;
                                if (nonmax_suppression)
                                    curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
                                break;
                            }
                        }
                        else
                            count = 0;
                    }
                }

                if (d & 2)
                {
                    int vt = v + threshold, count = 0;

                    for (k = 0; k < N; k++)
                    {
                        int x = ptr[pixel[k]];
                        if (x > vt)
                        {
                            if (++count > K)
                            {
                                cornerpos[ncorners++] = j;
                                if (nonmax_suppression)
                                    curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
                                break;
                            }
                        }
                        else
                            count = 0;
                    }
                }
            }
        }

        cornerpos[-1] = ncorners;

        if (i == 3)
            continue;

        const uchar* prev = buf[(i - 4 + 3) % 3];
        const uchar* pprev = buf[(i - 5 + 3) % 3];
        cornerpos = cpbuf[(i - 4 + 3) % 3];
        ncorners = cornerpos[-1];

        for (k = 0; k < ncorners; k++)
        {
            j = cornerpos[k];
            int score = prev[j];
            if (!nonmax_suppression ||
                (score > prev[j + 1] && score > prev[j - 1] &&
                    score > pprev[j - 1] && score > pprev[j] && score > pprev[j + 1] &&
                    score > curr[j - 1] && score > curr[j] && score > curr[j + 1]))
            {
                keypoints.push_back(KeyPoint((float)j, (float)(i - 1), 7.f, -1, (float)score));
            }
        }
    }
}

//自己加上窗口，按照上面的假设将图片切割为60*60大小，那么需要窗口设置为32*18
template<int patternSize>
void detectFASTKeyPoints(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, int windowHeight, int windowWidth)
{
    Mat img = _img.getMat();
    const int K = patternSize / 2, N = patternSize + K + 1;
    int i, j, k, pixel[25];
    makeOffsets(pixel, (int)img.step, patternSize);

#if CV_SIMD128
    const int quarterPatternSize = patternSize / 4;
    v_uint8x16 delta = v_setall_u8(0x80), t = v_setall_u8((char)threshold), K16 = v_setall_u8((char)K);
    bool hasSimd = hasSIMD128();
#if CV_TRY_AVX2
    Ptr<opt_AVX2::FAST_t_patternSize16_AVX2> fast_t_impl_avx2;
    if (CV_CPU_HAS_SUPPORT_AVX2)
        fast_t_impl_avx2 = opt_AVX2::FAST_t_patternSize16_AVX2::getImpl(img.cols, threshold, nonmax_suppression, pixel);
#endif

#endif

    keypoints.clear();

    threshold = std::min(std::max(threshold, 0), 255);

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

    AutoBuffer<uchar> _buf((img.cols + 16) * windowHeight * (sizeof(int) + sizeof(uchar)) + 128);
    //change it
    uchar** buf = new uchar*[windowHeight];
    //uchar* buf[windowHeight];
    for (int i = 0; i < windowHeight; i++) {
        buf[i] = _buf + i * img.cols;
    }
    //buf[0] = _buf; buf[1] = buf[0] + img.cols; buf[2] = buf[1] + img.cols;
    //int* cpbuf[windowHeight];
    int** cpbuf = new int*[windowHeight];
    cpbuf[0] = (int*)alignPtr(buf[2] + img.cols, sizeof(int)) + 1;
    for (int i = 0; i < windowHeight; i++) {
        cpbuf[i] = cpbuf[0] + i * (img.cols + 1);
    }
    //change it
    //cpbuf[1] = cpbuf[0] + img.cols + 1;
    //cpbuf[2] = cpbuf[1] + img.cols + 1;
    //memset(buf[0], 0, img.cols * 3);
    memset(buf[0], 0, img.cols * windowHeight);

    for (i = 3; i < img.rows - 2; i++)
    {
        const uchar* ptr = img.ptr<uchar>(i) + 3;
        uchar* curr = buf[(i - 3) % windowHeight];
        int* cornerpos = cpbuf[(i - 3) % windowHeight];
        memset(curr, 0, img.cols);
        int ncorners = 0;

        if (i < img.rows - 3)
        {
            j = 3;
#if CV_SIMD128
            if (hasSimd)
            {
                if (patternSize == 16)
                {
#if CV_TRY_AVX2
                    if (fast_t_impl_avx2)
                        fast_t_impl_avx2->process(j, ptr, curr, cornerpos, ncorners);
#endif
                    //vz if (j <= (img.cols - 27)) //it doesn't make sense using vectors for less than 8 elements
                    {
                        for (; j < img.cols - 16 - 3; j += 16, ptr += 16)
                        {
                            v_uint8x16 v = v_load(ptr);
                            v_int8x16 v0 = v_reinterpret_as_s8((v + t) ^ delta);
                            v_int8x16 v1 = v_reinterpret_as_s8((v - t) ^ delta);

                            v_int8x16 x0 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[0]), delta));
                            v_int8x16 x1 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[quarterPatternSize]), delta));
                            v_int8x16 x2 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[2 * quarterPatternSize]), delta));
                            v_int8x16 x3 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[3 * quarterPatternSize]), delta));

                            v_int8x16 m0, m1;
                            m0 = (v0 < x0) & (v0 < x1);
                            m1 = (x0 < v1) & (x1 < v1);
                            m0 = m0 | ((v0 < x1) & (v0 < x2));
                            m1 = m1 | ((x1 < v1) & (x2 < v1));
                            m0 = m0 | ((v0 < x2) & (v0 < x3));
                            m1 = m1 | ((x2 < v1) & (x3 < v1));
                            m0 = m0 | ((v0 < x3) & (v0 < x0));
                            m1 = m1 | ((x3 < v1) & (x0 < v1));
                            m0 = m0 | m1;

                            int mask = v_signmask(m0);
                            if (mask == 0)
                                continue;
                            if ((mask & 255) == 0)
                            {
                                j -= 8;
                                ptr -= 8;
                                continue;
                            }

                            v_int8x16 c0 = v_setzero_s8();
                            v_int8x16 c1 = v_setzero_s8();
                            v_uint8x16 max0 = v_setzero_u8();
                            v_uint8x16 max1 = v_setzero_u8();
                            for (k = 0; k < N; k++)
                            {
                                v_int8x16 x = v_reinterpret_as_s8(v_load((ptr + pixel[k])) ^ delta);
                                m0 = v0 < x;
                                m1 = x < v1;

                                c0 = v_sub_wrap(c0, m0) & m0;
                                c1 = v_sub_wrap(c1, m1) & m1;

                                max0 = v_max(max0, v_reinterpret_as_u8(c0));
                                max1 = v_max(max1, v_reinterpret_as_u8(c1));
                            }

                            max0 = v_max(max0, max1);
                            int m = v_signmask(K16 < max0);

                            for (k = 0; m > 0 && k < 16; k++, m >>= 1)
                            {
                                if (m & 1)
                                {
                                    cornerpos[ncorners++] = j + k;
                                    if (nonmax_suppression)
                                        curr[j + k] = (uchar)cornerScore<patternSize>(ptr + k, pixel, threshold);
                                }
                            }
                        }
                    }
                }
            }
#endif
            for (; j < img.cols - 3; j++, ptr++)
            {
                int v = ptr[0];
                const uchar* tab = &threshold_tab[0] - v + 255;
                int d = tab[ptr[pixel[0]]] | tab[ptr[pixel[8]]];

                if (d == 0)
                    continue;

                d &= tab[ptr[pixel[2]]] | tab[ptr[pixel[10]]];
                d &= tab[ptr[pixel[4]]] | tab[ptr[pixel[12]]];
                d &= tab[ptr[pixel[6]]] | tab[ptr[pixel[14]]];

                if (d == 0)
                    continue;

                d &= tab[ptr[pixel[1]]] | tab[ptr[pixel[9]]];
                d &= tab[ptr[pixel[3]]] | tab[ptr[pixel[11]]];
                d &= tab[ptr[pixel[5]]] | tab[ptr[pixel[13]]];
                d &= tab[ptr[pixel[7]]] | tab[ptr[pixel[15]]];

                if (d & 1)
                {
                    int vt = v - threshold, count = 0;

                    for (k = 0; k < N; k++)
                    {
                        int x = ptr[pixel[k]];
                        if (x < vt)
                        {
                            if (++count > K)
                            {
                                cornerpos[ncorners++] = j;
                                if (nonmax_suppression)
                                    curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
                                break;
                            }
                        }
                        else
                            count = 0;
                    }
                }

                if (d & 2)
                {
                    int vt = v + threshold, count = 0;

                    for (k = 0; k < N; k++)
                    {
                        int x = ptr[pixel[k]];
                        if (x > vt)
                        {
                            if (++count > K)
                            {
                                cornerpos[ncorners++] = j;
                                if (nonmax_suppression)
                                    curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
                                break;
                            }
                        }
                        else
                            count = 0;
                    }
                }
            }
        }

        cornerpos[-1] = ncorners;
        //change it
        //if (i == 3)
        //  continue;
        if (i < (3 + (windowHeight / 2))) {
            continue;
        }
        uchar** prev = new uchar*[windowHeight - 1];
        for (int m = 0; m < windowHeight - 1; m++) {
            prev[m] = buf[(i - (3 + windowHeight / 2) - m + windowHeight) % windowHeight];
        }
        cornerpos = cpbuf[(i - (3 + windowHeight / 2) + windowHeight) % windowHeight];
        //const uchar* prev = buf[(i - 4 + 3) % 3];
        //const uchar* pprev = buf[(i - 5 + 3) % 3];
        //cornerpos = cpbuf[(i - 4 + 3) % 3];
        ncorners = cornerpos[-1];

        for (k = 0; k < ncorners; k++)
        {
            j = cornerpos[k];
            //change it
            //int score = prev[j];
            int score = prev[windowHeight/2 - 1][j];
            if (!nonmax_suppression || whetherRecieve(prev, curr, score, j, windowHeight, windowWidth))
            {
                keypoints.push_back(KeyPoint((float)j, (float)(i - 1), 7.f, -1, (float)score));
            }
        }
        delete[] prev;
    }
    delete[] buf;
    delete[] cpbuf;
}

bool whetherRecieve(uchar* prev[], uchar* curr, int score, int position, int windowHeight, int windowWidth){
    for (int i = 0; i < windowHeight - 1; i++) {
        for (int j = -windowWidth / 2; j < (windowWidth + 1) / 2; j++) {
            int position_2 = (position + j) > 0 ? (position + j) : 0;
            if (score <= prev[i][position_2]) {
                return false;
            }
        }
    }
    for (int j = -windowWidth / 2; j < (windowWidth + 1) / 2; j++) {
        int position_2 = (position + j) > 0 ? (position + j) : 0;
        if (score <= curr[position_2]) {
            return false;
        }
    }
    return true;
}

void makeOffsets(int pixel[25], int rowStride, int patternSize)
{
    static const int offsets16[][2] =
    {
        { 0,  3 },{ 1,  3 },{ 2,  2 },{ 3,  1 },{ 3, 0 },{ 3, -1 },{ 2, -2 },{ 1, -3 },
    { 0, -3 },{ -1, -3 },{ -2, -2 },{ -3, -1 },{ -3, 0 },{ -3,  1 },{ -2,  2 },{ -1,  3 }
    };

    static const int offsets12[][2] =
    {
        { 0,  2 },{ 1,  2 },{ 2,  1 },{ 2, 0 },{ 2, -1 },{ 1, -2 },
    { 0, -2 },{ -1, -2 },{ -2, -1 },{ -2, 0 },{ -2,  1 },{ -1,  2 }
    };

    static const int offsets8[][2] =
    {
        { 0,  1 },{ 1,  1 },{ 1, 0 },{ 1, -1 },
    { 0, -1 },{ -1, -1 },{ -1, 0 },{ -1,  1 }
    };

    const int(*offsets)[2] = patternSize == 16 ? offsets16 :
        patternSize == 12 ? offsets12 :
        patternSize == 8 ? offsets8 : 0;

    CV_Assert(pixel && offsets);

    int k = 0;
    for (; k < patternSize; k++)
        pixel[k] = offsets[k][0] + offsets[k][1] * rowStride;
    for (; k < 25; k++)
        pixel[k] = pixel[k - patternSize];
}

template<>
int cornerScore<16>(const uchar* ptr, const int pixel[], int threshold)
{
    const int K = 8, N = K * 3 + 1;
    int k, v = ptr[0];
    short d[N];
    for (k = 0; k < N; k++)
        d[k] = (short)(v - ptr[pixel[k]]);

#if CV_SIMD128
    if (hasSIMD128())
    {
        v_int16x8 q0 = v_setall_s16(-1000), q1 = v_setall_s16(1000);
        for (k = 0; k < 16; k += 8)
        {
            v_int16x8 v0 = v_load(d + k + 1);
            v_int16x8 v1 = v_load(d + k + 2);
            v_int16x8 a = v_min(v0, v1);
            v_int16x8 b = v_max(v0, v1);
            v0 = v_load(d + k + 3);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 4);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 5);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 6);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 7);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 8);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k);
            q0 = v_max(q0, v_min(a, v0));
            q1 = v_min(q1, v_max(b, v0));
            v0 = v_load(d + k + 9);
            q0 = v_max(q0, v_min(a, v0));
            q1 = v_min(q1, v_max(b, v0));
        }
        q0 = v_max(q0, v_setzero_s16() - q1);
        threshold = v_reduce_max(q0) - 1;
    }
    else
#endif
    {

        int a0 = threshold;
        for (k = 0; k < 16; k += 2)
        {
            int a = std::min((int)d[k + 1], (int)d[k + 2]);
            a = std::min(a, (int)d[k + 3]);
            if (a <= a0)
                continue;
            a = std::min(a, (int)d[k + 4]);
            a = std::min(a, (int)d[k + 5]);
            a = std::min(a, (int)d[k + 6]);
            a = std::min(a, (int)d[k + 7]);
            a = std::min(a, (int)d[k + 8]);
            a0 = std::max(a0, std::min(a, (int)d[k]));
            a0 = std::max(a0, std::min(a, (int)d[k + 9]));
        }

        int b0 = -a0;
        for (k = 0; k < 16; k += 2)
        {
            int b = std::max((int)d[k + 1], (int)d[k + 2]);
            b = std::max(b, (int)d[k + 3]);
            b = std::max(b, (int)d[k + 4]);
            b = std::max(b, (int)d[k + 5]);
            if (b >= b0)
                continue;
            b = std::max(b, (int)d[k + 6]);
            b = std::max(b, (int)d[k + 7]);
            b = std::max(b, (int)d[k + 8]);

            b0 = std::min(b0, std::max(b, (int)d[k]));
            b0 = std::min(b0, std::max(b, (int)d[k + 9]));
        }

        threshold = -b0 - 1;
    }

#if VERIFY_CORNERS
    testCorner(ptr, pixel, K, N, threshold);
#endif
    return threshold;
}

template<>
int cornerScore<12>(const uchar* ptr, const int pixel[], int threshold)
{
    const int K = 6, N = K * 3 + 1;
    int k, v = ptr[0];
    short d[N + 4];
    for (k = 0; k < N; k++)
        d[k] = (short)(v - ptr[pixel[k]]);
#if CV_SIMD128
    for (k = 0; k < 4; k++)
        d[N + k] = d[k];
#endif

#if CV_SIMD128
    if (hasSIMD128())
    {
        v_int16x8 q0 = v_setall_s16(-1000), q1 = v_setall_s16(1000);
        for (k = 0; k < 16; k += 8)
        {
            v_int16x8 v0 = v_load(d + k + 1);
            v_int16x8 v1 = v_load(d + k + 2);
            v_int16x8 a = v_min(v0, v1);
            v_int16x8 b = v_max(v0, v1);
            v0 = v_load(d + k + 3);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 4);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 5);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k + 6);
            a = v_min(a, v0);
            b = v_max(b, v0);
            v0 = v_load(d + k);
            q0 = v_max(q0, v_min(a, v0));
            q1 = v_min(q1, v_max(b, v0));
            v0 = v_load(d + k + 7);
            q0 = v_max(q0, v_min(a, v0));
            q1 = v_min(q1, v_max(b, v0));
        }
        q0 = v_max(q0, v_setzero_s16() - q1);
        threshold = v_reduce_max(q0) - 1;
    }
    else
#endif
    {
        int a0 = threshold;
        for (k = 0; k < 12; k += 2)
        {
            int a = std::min((int)d[k + 1], (int)d[k + 2]);
            if (a <= a0)
                continue;
            a = std::min(a, (int)d[k + 3]);
            a = std::min(a, (int)d[k + 4]);
            a = std::min(a, (int)d[k + 5]);
            a = std::min(a, (int)d[k + 6]);
            a0 = std::max(a0, std::min(a, (int)d[k]));
            a0 = std::max(a0, std::min(a, (int)d[k + 7]));
        }

        int b0 = -a0;
        for (k = 0; k < 12; k += 2)
        {
            int b = std::max((int)d[k + 1], (int)d[k + 2]);
            b = std::max(b, (int)d[k + 3]);
            b = std::max(b, (int)d[k + 4]);
            if (b >= b0)
                continue;
            b = std::max(b, (int)d[k + 5]);
            b = std::max(b, (int)d[k + 6]);

            b0 = std::min(b0, std::max(b, (int)d[k]));
            b0 = std::min(b0, std::max(b, (int)d[k + 7]));
        }

        threshold = -b0 - 1;
    }
#if VERIFY_CORNERS
    testCorner(ptr, pixel, K, N, threshold);
#endif
    return threshold;
}
qifengl_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
重构OpenCV的Fast_t函数进行FAST特征提取
谁动了我的奶油的博客
07-25 376
#include "myfast.hpp" using namespace std; void makeOffsets(int pixel[25], int rowStride, int patternSize) { static const int offsets16[][2] = //圆周上各像素点相对于中心点的坐标 { {0, 3}, { 1,
OpenCV算法加速（4）官方源码v4.5.5的默认并行和优化加速的编译选项是什么？请重点关注函数cv::getBuildInformation()的返回值
$firecat利白的代码足迹$
01-25 7336
opencv v4.5.5版本源码 1、并行库的使用情况 \opencv\sources\modules\core\src\parallel.cpp，里面默认使用的是微软PPL加速方式， #if defined _MSC_VER && _MSC_VER >= 1600 #define HAVE_CONCURRENCY #endif 其他方式如TBB，HPX，OPENMP默认是关闭的。 2、指令集优化默认是开启的 cmake编译选项，\open.
opencv源码解析--calcSharrDeriv/copyMakeBorder
findgeneralgirl的博客
08-12 1624
calcSharrDeriv(求微分)、copyMakeBorder(边缘扩展)--opencv源码解析 1. 函数体解析 a. static void calcSharrDeriv(const cv::Mat& src, cv::Mat& dst) 函数作用 对输入图像求微分，并将微分结果存储到dst中，微分模板可见原理 src 待处理图像，src的depth必须为CV_8U,通道不做要求 dst 存放微分结果，类型同src，...
Opencv Harris角点检测源码分析
qq_26129959的博客
01-29 651
一.简介 这两天学习了Harris角点检测的算法原理，想深入了解一下opencv是如何实现的Harris角点检测算法，就产生了这篇文章供大家参考。在opencv中Harris角点检测的函数一共分为3大类：1）AVX优化过的；2）SIMD128优化过的；3）普通的串行处理。我仅仅分析了普通的串行处理，去理解Harris算法原理。至于AVX,IPP或者SIMD128优化的，仅仅是增加了数据的并行处理，...
ORB-SLAM2跟踪之局部地图跟踪
u011380574的专栏
09-13 5465
回顾：帧间匹配得到初始位姿上一次主要说明了ORB-SLAM2跟踪过程中每帧初始位姿的估计。回顾一下，初始位姿的估计主要是在帧与帧之间进行，有三种方法来估计，TrackWithMotionModel，TrackReferenceKeyFrame，Relocalization。TrackWithMotionModel假设相机做恒速运动，根据前一帧的位姿加上恒速位移推算出当前帧的位姿，之后遍历前一帧的特征
Fast特征检测
weixin_30600503的博客
04-21 379
一、Fast算法 1、基本原理 Fast特征点检测feature2D原理是在圆周上按顺时针方向从1到16的顺序对圆周像素点进行编号。如果在圆周上有N个连续的像素的亮度都比圆心像素的亮度Ip加上阈值t还要亮，或者比圆心像素的亮度减去阈值还要暗，则圆心像素被称为角点。 算法核心：利用周围像素比较的信息可以得到特征点，简单、高效。 FAST特征检测算法来源于corner的定义，基于特征点周围的像...
pixel:C和SIMD进行图像处理，有时比OpenCV更快
03-15
像素点 此回购包含一些有关基本图像处理的单独程序。 它主要是出于个人学习的目的，我将继续编写它们的朴素（纯C）和SIMD（ARM NEON，SSE）优化版本。 随时为该回购创建问题/观看/提出拉取请求。
FAST算法解析
PeOS
11-20 1万+
一、FAST特征点     在像素点的周围邻域内有足够多的像素点与该点处于不同的灰度区域。在灰度图像中，也就是有足够多的像素点的灰度值大于该点的灰度值或者小于该点的灰度值。 通常选取以像素点为中心的半径为3的离散化的Bresenham元形区域。     在OpenCV中，当patternSize为16时，用以下数组表示这16个点相对于圆心的坐标：   static const int 
OpenCV - Universal intrinsics 统一指令集
最新发布
行仔ovo的博客
07-22 1460
文章目录0. OpenCV版本1. 寄存器数据类型2. 方法3. 说明 0. OpenCV版本 选用的4.5.2版本，因为4.5.1版本第一次加入对avx256指令集的相关代码，担心不稳定，但是此时4.5.3又下载太慢，所以用了4.5.2。 1. 寄存器数据类型 2. 方法 3. 说明 ......
OpenCV StereoBM深度提取算法自己的一些注释
tianqishi的专栏
07-14 523
参考了，网名叫伊卡洛斯，https://zhuanlan.zhihu.com/p/50801189 他的另一篇SGBM的注释也是写得最好的 先贴上整个过程函数调用关系 和sgbm一样的，x方向的sobel [ -1,0,1] [ -2,0,2] [-1,0,1] 求梯度，也可能不用梯度，而是用prefilterNorm， static void prefilterXSobel( const Mat& src, Mat& dst, int ftzero
Fast 角点提取c++代码
张利 的博客
06-16 2269
本人近来研究opencv的Fast 的源码，发现opencv 对Fast 的算法写的有优化，并不方便初学者来理解代码，本人根据Fast 算法的原理，写了一个相对非常好理解的Fast 算法，在速度上不如opencv， 但是在代码的理解和简洁上绝对是更胜一抽，希望能帮助更多学习Fast 算法的同学们，请大家相信，本程序Fast 的结果经过验证和opencv 结果一样，请大家放心使用。 下面是头文件st
matlab中imfilter()、fspecial()以及meshgrid()的C++实现（LoG算子）
verystory的博客
12-29 3219
LoG算子~matlab上 "imfilter(img,fspecial('log', floor(6*sigma+1), sigma),'replicate') "; 使用C/C++近似实现。
Intel 的AVX2指令集解读
热门推荐
战斗蜗牛的专栏
08-06 5万+
在Intel Sandy Bridge微架构中，Intel引入了256位SIMD扩展AVX，这套指令集在兼容原MMX、SSE、SSE2对128位整点SIMD支持的基础上，把支持的总向量数据宽度扩展成了256位。新增了若干条256位浮点SIMD指令。 昨天，Intel刚刚发布了AVX2指令集，这套指令集在AVX基础上做了扩展，不过要在2013年发布的Haswell处理器上才能支持。参考1给出了
SSE2指令--使用SSE2的整型内存操作和初始化：设置(Set)
bwl111的专栏
05-27 7078
SSE2指令使用下面三种数据类型： __m128, __m128i, 和 __m128d ，但是安腾处理器家族( Itanium Processor Family,IPF)处理器并不支持这三种数据类型；       x64的处理器不支持任何使用 __m64 数据类型的SSE2指令。      所有的SSE2指令的声明都在emmintrin.h头文件中可以找得到。     1.__m128
【特征匹配】Fast原理及源码解析
勿在浮砂筑高台
09-08 1万+
在实时的视频流处理中，需要对每一帧特征提取，对算法处理速度上有很高的要求，传统的SIFT,Harris等特征点提取很难满足。由此提出Fast（Features from Accelerated Segment Test），由于不涉及尺度，梯度，等复杂运算，Fast检测器速度非常快。它使用一定邻域内像元的灰度值与中心点比较大小去判断是否为一个角点。但它的缺点是不具有方向性,尺度不变性。 转载请
SIMD单指令数据流（MMX、SSE2、NEON）
Shawne lee 的博客
10-17 1475
NEON指令：http://blog.csdn.net/fengbingchun/article/details/38085781 SSE2指令：http://blog.csdn.net/fengbingchun/article/details/18460199
openCV的sobel算子的深度学习卷积网络部分的C语言源码
dongbao520的博客
05-13 388
参考的三种边缘检测算子其一，未完待续。。灰度或结构等信息的突变位置是图像的边缘，图像的边缘有幅度和方向属性，沿边缘方向像素变化缓慢，垂直边缘方向像素变化剧烈。因此，边缘上的变化能通过梯度计算出来。 同理: #include "precomp.hpp" #include "opencl_kernels_imgproc.hpp" #include "opencv2/core/openvx/ovx_defs.hpp" #include "filter.hpp" /************************
AVX2整数向量运算
海岛Blog
01-22 1万+
在C/C++程序中，使用AVX2指令有很多种方法。 嵌入汇编是一般的方法，但是对于不熟悉汇编语言的人来说，有点勉为其难。 gcc编译支持AVX2指令的编程。程序中需要使用头文件和，这样通过调用其中定义的一些函数，达到使用AVX2指令的目的，即用C/C++调用SIMD指令（单指令多数据）。 这里给出的样例程序是有关浮点向量运算的例子。 其中函数_mm_add_epi32()实现的是整数向量（
SIMD(单道指令多道数据流)指令(MMX/SSE1/SSE2)详解(中文).
daoqinglin的专栏
06-02 8714
http://www.aogosoft.com/bbs/view.asp?id=74373 作者：ham 向作者致敬！ SIMD(单道指令多道数据流)指令(MMX/SSE1/SSE2)详解(中文).还有更多的多媒体指令集,SSE3,SSE4
SPHORB 代码修改记录
东风小火的博客
07-22 569
SPHORB modified by huangfei, start at 2020.07.11, see it at gitee 调整目录结构 可用命令回看：git checkout 4ba4e13 调整目录结构，修改了 CMakeLists.txt ：使 SPHORB 编译为共享库，输出目录为 lib 文件夹；可执行文件输出目录为 bin 文件夹，运行前需要先把 Data、Image 文件夹复制到 bin 目录。 添加 mask 功能 可用命令回看：git checkout d7c02a4 添加了常用的

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值