SIFT算法+RANSAC(OpenCV4.5）

#include<opencv2/opencv.hpp>
using namespace cv;
#include<iostream>
using namespace std;
int main()
{

    /*Mat img_object = imread("D://1.jpg", IMREAD_GRAYSCALE);
    Mat img_scene = imread("d://2.jpg", IMREAD_GRAYSCALE);*/

    /*Mat img_object = imread("7.png", IMREAD_GRAYSCALE);
    Mat img_scene = imread("8.png", IMREAD_GRAYSCALE);*/

    Mat img_object = imread("adam1.png", IMREAD_GRAYSCALE);
    Mat img_scene = imread("adam2.png", IMREAD_GRAYSCALE);

    if (img_object.empty() || img_scene.empty())
    {
        cout << "Could not open or find the image!\n" << endl;
        return -1;
    }
    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
    int minHessian = 10000; // default: 400
    Ptr<SIFT> detector = SIFT::create(minHessian);
    std::vector<KeyPoint> keypoints_object, keypoints_scene;
    Mat descriptors_object, descriptors_scene;
    detector->detectAndCompute(img_object, noArray(), keypoints_object, descriptors_object);
    detector->detectAndCompute(img_scene, noArray(), keypoints_scene, descriptors_scene);

    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
    // Since SURF is a floating-point descriptor NORM_L2 is used
    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
    std::vector< std::vector<DMatch> > knn_matches;
    matcher->knnMatch(descriptors_object, descriptors_scene, knn_matches, 2);

    //-- Filter matches using the Lowe's ratio test
    const float ratio_thresh = 0.75f;
    std::vector<DMatch> good_matches;
    for (size_t i = 0; i < knn_matches.size(); i++)
    {
        if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance)
        {
            good_matches.push_back(knn_matches[i][0]);
        }
    }

    //-- Draw matches
    Mat img_matches;
    drawMatches(img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1),
        Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);

    //-- Localize the object
    std::vector<Point2f> obj;
    std::vector<Point2f> scene;

    for (size_t i = 0; i < good_matches.size(); i++)
    {
        //-- Get the keypoints from the good matches
        obj.push_back(keypoints_object[good_matches[i].queryIdx].pt);
        scene.push_back(keypoints_scene[good_matches[i].trainIdx].pt);
    }
    vector<uchar>inliers;
    Mat H = findHomography(obj, scene, inliers, RANSAC);


    //-- Draw matches with RANSAC
    Mat img_matches_ransac;
    std::vector<DMatch> good_matches_ransac;
    for (size_t i = 0; i < inliers.size(); i++)
    {
        if (inliers[i])
        {
            good_matches_ransac.push_back(good_matches[i]);
        }
    }
    drawMatches(img_object, keypoints_object, img_scene, keypoints_scene, good_matches_ransac, img_matches_ransac, Scalar::all(-1),
        Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);


    ////-- Get the corners from the image_1 ( the object to be "detected" )
    //std::vector<Point2f> obj_corners(4);
    //obj_corners[0] = Point2f(0, 0);
    //obj_corners[1] = Point2f((float)img_object.cols, 0);
    //obj_corners[2] = Point2f((float)img_object.cols, (float)img_object.rows);
    //obj_corners[3] = Point2f(0, (float)img_object.rows);
    //std::vector<Point2f> scene_corners(4);

    //perspectiveTransform(obj_corners, scene_corners, H);

    ////-- Draw lines between the corners (the mapped object in the scene - image_2 )
    //line(img_matches, scene_corners[0] + Point2f((float)img_object.cols, 0),
    //    scene_corners[1] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4);
    //line(img_matches, scene_corners[1] + Point2f((float)img_object.cols, 0),
    //    scene_corners[2] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4);
    //line(img_matches, scene_corners[2] + Point2f((float)img_object.cols, 0),
    //    scene_corners[3] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4);
    //line(img_matches, scene_corners[3] + Point2f((float)img_object.cols, 0),
    //    scene_corners[0] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4);

    //-- Show detected matches
    namedWindow("img_matches", WINDOW_NORMAL);
    imshow("img_matches", img_matches);

    namedWindow("img_matches_ransac", WINDOW_NORMAL);
    imshow("img_matches_ransac", img_matches_ransac);

    waitKey(0);
    return 1;
}

 

 

 

速度比ASIFT快的多了，准确率也很高，几乎没见到过误匹配，但是点数量和ASIFT无法比，这对相机位姿估算不见得是一件好事

ASIFT找的点多，而且分散，这是VSLAM乐见的一件事，虽然非常耗时，但是作为局部小规模重建是一件好事，有空测试一下低纹理图片。