【图像特征】【OPENCV】SIFT，SURF，ORB，Harris，FAST，量化匹配度

    #include "stdafx.h"
    #include <opencv2\xfeatures2d\nonfree.hpp>
    #include <iostream> 
    #include<vector>
    #include"opencv2\core\core.hpp"
    #include"opencv2\xfeatures2d.hpp"
    #include "opencv2/highgui/highgui.hpp"
    using namespace cv;
    using namespace std;
    
    int main()
    {
    Mat src0 = imread("C:\ titleTemp.bmp",IMREAD_GRAYSCALE);
    Mat src1 = imread("C:\ test1.jpg",IMREAD_GRAYSCALE);
    
    if (src0.data == NULL || src1.data == NULL)
    {
        cout << "image no exist!" << endl;
        return -1;
    }
    
    Ptr<Feature2D> sift = xfeatures2d::SIFT::create();
    vector<KeyPoint> keypoint0,keypoint1,keypointImg;
    
    Mat descriptor1, descriptor0;
    
    sift->detect(src0, keypoint0);
    sift->detect(src1, keypoint1);
    sift->compute(src0, keypoint0, descriptor0);
    sift->compute(src1, keypoint1, descriptor1);
    
    BFMatcher matcher;
    matcher.BRUTEFORCE_SL2;
    vector<DMatch> matches;
    
    matcher.match(descriptor0, descriptor1, matches);
    //排序
    sort(matches.begin(), matches.end());
    
    vector<KeyPoint> imgPt1, imgPt2;
    vector<DMatch> matchesVoted;
    
    for (int idx=0;idx <10;idx++)
    {
        DMatch dmatch;
        dmatch.queryIdx = idx;
        dmatch.trainIdx = idx;
    
        matchesVoted.push_back(dmatch);
        imgPt1.push_back(keypoint0[matches[idx].queryIdx]);
        imgPt2.push_back(keypoint1[matches[idx].trainIdx]);
    }
    
    Mat img_matches;
    std::vector< DMatch > emptyVec;
    drawMatches(src0, imgPt1, src1, imgPt2, matchesVoted, img_matches, DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    imshow("SIFT_Match_Image", img_matches);
    waitKey();
    return 0;
    }

    Mat src_gray = imread("C:\titleTemp.bmp", IMREAD_GRAYSCALE);
    
    Mat dst, dst_norm, dst_norm_scaled;
    dst = Mat::zeros(src_gray.size(), CV_32FC1);
    
    /// Detector parameters
    int blockSize = 2;
    int apertureSize = 3;
    double k = 0.04;
    
    /// Detecting corners
    cornerHarris(src_gray, dst, blockSize, apertureSize, k, BORDER_DEFAULT);
    
    /// Normalizing
    normalize(dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat());
    convertScaleAbs(dst_norm, dst_norm_scaled);
    
    /// Drawing a circle around corners 
    for (int j = 0; j < dst_norm.rows; j++)
    {
        for (int i = 0; i < dst_norm.cols; i++)
        {
            if ((int)dst_norm.at<float>(j, i) > 128)
            {
                circle(dst_norm_scaled, Point(i, j), 5, Scalar(0), 2, 8, 0);
            }
        }
    }
    /// Showing the result
    namedWindow("Harris", CV_WINDOW_AUTOSIZE);
    imshow("Harris", dst_norm_scaled);
    waitKey();
    
    return 0;

    Mat src0 = imread("C:\ Users\ Xue.Bicycle\ Desktop\ titleTemp.bmp", IMREAD_GRAYSCALE);
    Mat src1 = imread("C:\ Users\ Xue.Bicycle\ Desktop\ test1.jpg", IMREAD_GRAYSCALE);
    
    if (src0.data == NULL || src1.data == NULL)
    {
        cout << "image no exist!" << endl;
        return -1;
    }
    //fast
    Ptr<FastFeatureDetector> fast = FastFeatureDetector::create(0);
    vector<KeyPoint> keypoint0, keypoint1;
    fast->detect(src0, keypoint0);
    fast->detect(src1, keypoint1);
    
    Ptr<xfeatures2d::SiftDescriptorExtractor> extractor = xfeatures2d::SiftDescriptorExtractor::create();
    Mat descriptor1, descriptor0;
    extractor->compute(src0, keypoint0, descriptor0);
    extractor->compute(src1, keypoint1, descriptor1);
    
    BFMatcher matcher;
    matcher.BRUTEFORCE_SL2;
    vector<DMatch> matches;
    
    matcher.match(descriptor0, descriptor1, matches);
    //排序
    sort(matches.begin(), matches.end());
    
    vector<KeyPoint> imgPt1, imgPt2;
    vector<DMatch> matchesVoted;
    
    if (0 == matches.size())
        return 0;
    
    for (int idx = 0; idx <10; idx++)
    {
        DMatch dmatch;
        dmatch.queryIdx = idx;
        dmatch.trainIdx = idx;
    
        matchesVoted.push_back(dmatch);
        imgPt1.push_back(keypoint0[matches[idx].queryIdx]);
        imgPt2.push_back(keypoint1[matches[idx].trainIdx]);
    }
    
    Mat img_matches;
    std::vector< DMatch > emptyVec;
    drawMatches(src0, imgPt1, src1, imgPt2, matchesVoted, img_matches, DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    imshow("SIFT_Match_Image", img_matches);
    waitKey();
    return 0;

    //keypointOri，keypoint分别为Img，ImgTitle的特征点。matches为暴力匹配法的结果。(接上述代码)
    vector<int> vScore, vScore1, vScoreOri, vScoreOri1;
    
    if (matches.size() <=1)
        return -1;
    
    int reNScore = 0;
    for (auto itr = matches.begin();itr != matches.end() - matches.size()/2;itr++)
    {
        Point2f p2f0 = keypointOri[itr->trainIdx].pt;
        Point2f p2f1 = keypointOri[(itr+1)->trainIdx].pt;
    
        vScoreOri.push_back(p2f0.x - p2f1.x);
        vScoreOri1.push_back(p2f0.y - p2f1.y);
    
        p2f0 = keypoint[itr->queryIdx].pt;
        p2f1 = keypoint[(itr + 1)->queryIdx].pt;
    
        vScore.push_back(p2f0.x - p2f1.x);
        vScore1.push_back(p2f0.y - p2f1.y);
    }
    float nScore = 0;
    float nScore_ = 0;
    
    for (int idx = 0; idx < std::min((int)10,(int)vScore.size()/10); idx++)
    {
        nScore += abs(vScore[idx]);
        nScore_ += abs(vScoreOri[idx]);
    }
    
    float fR;
    if (nScore == 0 || nScore_ == 0)
        return -1;
    else
    {
        fR = nScore / nScore_;
    }
    
    nScore = nScore_ = 0;
    for (int idx = 0; idx < vScore.size()/2; idx++)
    {           
        nScore += abs(vScoreOri[idx]*fR - vScore[idx]);
        nScore_ += abs(vScoreOri1[idx]*fR - vScore1[idx]);
    
    }
    return (nScore*0.8 + nScore_*0.2)/matches.size();