Demo entry 6685272

c++

   

Submitted by anonymous on Dec 19, 2017 at 08:39
Language: C++. Code size: 5.1 kB.

#include <iostream>  
#include <opencv2/core/core.hpp>  
#include <opencv2/features2d/features2d.hpp>  
#include <opencv2/highgui/highgui.hpp>  
  
using namespace std;  
using namespace cv;  
  
int main(int argc, char** argv)  
{  
  
    if(argc!=3)//判断命令行输入对错  
    {  
        cout<<"usage: feature_extraction img1 img2"<<endl;  
        return 1;  
    }  
  
    //读取要匹配的两张图像  
    Mat img_1 = imread(argv[1], CV_LOAD_IMAGE_COLOR);  
    Mat img_2 = imread(argv[2], CV_LOAD_IMAGE_COLOR);  
  
  
    //初始化  
    //首先创建两个关键点数组,用于存放两张图像的关键点,数组元素是KeyPoint类型  
    std::vector<KeyPoint> keypoints_1, keypoints_2;  
  
    //创建两张图像的描述子,类型是Mat类型  
    Mat descriptors_1, descriptors_2;  
  
    
    //创建一个Ptr<ORB>类型的orb,用于接收ORB类中create()函数的返回值  
    Ptr<ORB> orb = ORB::create();  
    Ptr<DescriptorMatcher> matcher  = DescriptorMatcher::create ( "BruteForce-Hamming" );   
  
  
  
    //第一步:检测Oriented FAST角点位置.  
    //detect是Feature2D中的方法,orb是子类指针,可以调用  
    //detect()方法的原型参数:需要检测的图像,关键点数组,第三个参数为默认值  
    /* 
    CV_WRAP virtual void detect( InputArray image, 
                                 CV_OUT std::vector<KeyPoint>& keypoints, 
                                 InputArray mask=noArray() ); 
    */  
    orb->detect(img_1, keypoints_1);  
    orb->detect(img_2, keypoints_2);  
  
  
    //第二步:根据角点位置计算BRIEF描述子  
    //compute是Feature2D中的方法,orb是子类指针,可以调用  
    //compute()原型参数:图像,图像的关键点数组,Mat类型的描述子  
    /* 
    CV_WRAP virtual void compute( InputArray image, 
                                  CV_OUT CV_IN_OUT std::vector<KeyPoint>& keypoints, 
                                  OutputArray descriptors ); 
    */  
    orb->compute(img_1, keypoints_1, descriptors_1);  
    orb->compute(img_2, keypoints_2, descriptors_2);  
  
    //定义输出检测特征点的图片。  
    Mat outimg1;  
    //drawKeypoints()函数原型参数:原图,原图关键点,带有关键点的输出图像,后面两个为默认值  
    /* 
    CV_EXPORTS_W void drawKeypoints( InputArray image, 
                                     const std::vector<KeyPoint>& keypoints, 
                                     InputOutputArray outImage, 
                                     const Scalar& color=Scalar::all(-1), 
                                     int flags=DrawMatchesFlags::DEFAULT ); 
    */  
    //这里并没有用到描述子,描述子的作用是用于后面的关键点筛选。  
    drawKeypoints(img_1, keypoints_1, outimg1, Scalar::all(-1), DrawMatchesFlags::DEFAULT);  
  
    imshow("ORB特征点",outimg1); //展示图片  
    imwrite ("ORB特征点1.jpg",outimg1); //保存图片  
  
  
    //第三步:对两幅图像中的BRIEF描述子进行匹配,使用 Hamming 距离  
  
    //创建一个匹配点数组,用于承接匹配出的DMatch。matches类型为数组,元素类型为DMatch  
    vector<DMatch> matches;  
  
  
    //调用matcher的match方法进行匹配,这里用到了描述子,没有用关键点。  
    //匹配出来的结果写入上方定义的matches[]数组中  
    matcher->match ( descriptors_1, descriptors_2, matches );  
  
    //第四步:遍历matches[]数组,找出匹配点的最大距离和最小距离,用于后面的匹配点筛选。  
    //这里的距离是上方求出的汉明距离数组,汉明距离表征了两个匹配的相似程度,所以也就找出了最相似和最不相似的两组点之间的距离。  
    double min_dist=10000, max_dist=0;//定义距离  
  
    for (int i = 0; i < descriptors_1.rows; ++i)//遍历找出最小距离和最大距离  
    {  
        double dist = matches[i].distance;  
        if(dist<min_dist) min_dist = dist;  
        if(dist>max_dist) max_dist = dist;  
    }  
  
    printf("Max dist: %f\n", max_dist);  
    printf("Min dist: %f\n", min_dist);  
  
    //第五步:根据最小距离,对匹配点进行筛选,  
    //当描述自之间的距离大于两倍的min_dist,即认为匹配有误,舍弃掉。  
    //但是有时最小距离非常小,比如趋近于0了,所以这样就会导致min_dist到2*min_dist之间没有几个匹配。  
    // 所以,在2*min_dist小于30的时候,就取30当上限值,小于30即可,不用2*min_dist这个值了  
    std::vector<DMatch> good_matches;  
    for (int j = 0; j < descriptors_1.rows; ++j)  
    {  
        if (matches[j].distance <= max(2*min_dist, 30.0))  
            good_matches.push_back(matches[j]);  
    }  
  
    //第六步:绘制匹配结果  
  
    Mat img_match;//所有匹配点图  
    //drawMatches()原型参数,用法就是:图1,图1关键点,图2,图2关键点,匹配数组,承接图像,后面的有默认值  
    /* 
    CV_EXPORTS_W void drawMatches( InputArray img1, 
                                   const std::vector<KeyPoint>& keypoints1, 
                                   InputArray img2, 
                                   const std::vector<KeyPoint>& keypoints2, 
                                   const std::vector<DMatch>& matches1to2, 
                                   InputOutputArray outImg, 
                                   const Scalar& matchColor=Scalar::all(-1), 
                                   const Scalar& singlePointColor=Scalar::all(-1), 
                                   const std::vector<char>& matchesMask=std::vector<char>(), 
                                   int flags=DrawMatchesFlags::DEFAULT ); 
    */  
  
    drawMatches(img_1, keypoints_1, img_2, keypoints_2, matches, img_match);  
    imshow("所有匹配点对", img_match);  
    imwrite ( "所有匹配点对.jpg", img_match );  
  
    Mat img_goodmatch;//筛选后的匹配点图  
    drawMatches(img_1, keypoints_1, img_2, keypoints_2, good_matches, img_goodmatch);  
    imshow("优化后的匹配点对", img_goodmatch);  
    imwrite ( "优化后匹配点对.jpg", img_goodmatch );  
  
    waitKey(0);  
  
    return 0;  
}  

This snippet took 0.01 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).