P6: Feature Matching

#include <iostream>

#include <vector>

#include <opencv2/core.hpp>

#include <opencv2/imgproc.hpp>

#include <opencv2/highgui.hpp>

#include <opencv2/features2d.hpp>

#include <opencv2/objdetect.hpp>

int main()

{

  // image matching

  // 1. Read input images

  cv::Mat image1= cv::imread("C:/Users/User/Desktop/CV_testimage/image1.jpg", cv::IMREAD_GRAYSCALE);

  cv::Mat image2= cv::imread("C:/Users/User/Desktop/CV_testimage/image2.jpg", cv::IMREAD_GRAYSCALE);

  // 2. Define keypoints vector

  std::vector<cv::KeyPoint> keypoints1;

  std::vector<cv::KeyPoint> keypoints2;

  // 3. Define feature detector

  cv::Ptr<cv::FeatureDetector> ptrDetector;       // generic detector

  ptrDetector= cv::FastFeatureDetector::create(80);   // 選用 FAST detector

  // 4. Keypoint detection

  //檢測關鍵點

  ptrDetector->detect(image1,keypoints1);

  ptrDetector->detect(image2,keypoints2);

  std::cout << "Number of keypoints (image 1): " << keypoints1.size() << std::endl;

  std::cout << "Number of keypoints (image 2): " << keypoints2.size() << std::endl;

  // 5. Define a square neighborhood

  //定義特定大小的矩形，表示關鍵點周圍的]圖像塊

  const int nsize(11); // size of the neighborhood

  cv::Rect neighborhood(0, 0, nsize, nsize); // 11x11

  cv::Mat patch1;

  cv::Mat patch2;

  // 6. For all keypoints in first image

  // find best match in second image

  //在第二章圖中找出與第一幅圖像中的每個關鍵點最匹配的

  cv::Mat result;

  std::vector<cv::DMatch> matches;

  //for all keypoints in image 1

  //針對imaage1的全部關鍵點

  for (int i=0; i<keypoints1.size(); i++) {

       // define image1 patch 定義image1圖像塊

       neighborhood.x = keypoints1[i].pt.x-nsize/2;

       neighborhood.y = keypoints1[i].pt.y-nsize/2;

       // if neighborhood of points outside image, then continue with next point

       //如果鄰域超出圖像範圍，就繼續處理下一個點

       if (neighborhood.x<0 || neighborhood.y<0 ||

           neighborhood.x+nsize >= image1.cols || neighborhood.y+nsize >= image1.rows)

           continue;

       //patch in image 1

       patch1 = image1(neighborhood);

       // reset best correlation value;

       //存放最匹配的值

       cv::DMatch bestMatch;

       //for all keypoints in image 2

       //針對imaage2的全部關鍵點

  for (int j=0; j<keypoints2.size(); j++) {

           // define image2 patch 定義image2圖像塊

           neighborhood.x = keypoints2[j].pt.x-nsize/2;

           neighborhood.y = keypoints2[j].pt.y-nsize/2;

           // if neighborhood of points outside image, then continue with next point

           if (neighborhood.x<0 || neighborhood.y<0 ||

                neighborhood.x + nsize >= image2.cols || neighborhood.y + nsize >= image2.rows)

                continue;

           // patch in image 2

           patch2 = image2(neighborhood);

           // match the two patches匹配兩個圖像塊

           cv::matchTemplate(patch1,patch2,result, cv::TM_SQDIFF);

           // check if it is a best match

           //檢查是否為最佳匹配

           if (result.at<float>(0,0) < bestMatch.distance) {

                bestMatch.distance= result.at<float>(0,0);

                bestMatch.queryIdx= i;

                bestMatch.trainIdx= j;

           }

       }

       // add the best match

       //添加最佳匹配

       matches.push_back(bestMatch);

  }

  std::cout << "Number of matches: " << matches.size() << std::endl;

  // extract the 50 best matches 提取50個最佳匹配項

std::nth_element(matches.begin(),matches.begin()+50,matches.end());

  matches.erase(matches.begin()+50,matches.end());

  std::cout << "Number of matches (after): " << matches.size() << std::endl;

  // Draw the matching results

  //畫出匹配結果

  cv::Mat matchImage;

  cv::drawMatches(image1,keypoints1, // first image

                    image2,keypoints2, // second image

                    matches, // vector of matches

                    matchImage,  // produced image

              cv::Scalar(0,0,255),  // line color 紅色

                 cv::Scalar(0,0,255)); // point color 紅色

// Display the image of matches

  cv::namedWindow("Matches");

  cv::imshow("Matches",matchImage);

  // Match template

  // define a template

  cv::Mat target(image1,cv::Rect(80,105,30,30));

// Display the template

  cv::namedWindow("Template");

  cv::imshow("Template",target);

  // define search region

  cv::Mat roi(image2,

       // here top half of the image

       cv::Rect(0,0,image2.cols,image2.rows/2));

  // perform template matching

  cv::matchTemplate(

       roi, // search region

       target, // template

       result, // result

       cv::TM_SQDIFF); // similarity measure

  // find most similar location

  double minVal, maxVal;

  cv::Point minPt, maxPt;

  cv::minMaxLoc(result, &minVal, &maxVal, &minPt, &maxPt);

  // draw rectangle at most similar location

  // at minPt in this case

  cv::rectangle(roi, cv::Rect(minPt.x, minPt.y, target.cols , target.rows), 255);

// Display the template

  cv::namedWindow("Best");

  cv::imshow("Best",image2);

  cv::waitKey();

  return 0;

}

#include <iostream>

#include <vector>

#include <opencv2/core.hpp>

#include <opencv2/imgproc.hpp>

#include <opencv2/highgui.hpp>

#include <opencv2/features2d.hpp>

#include <opencv2/objdetect.hpp>

#include <opencv2/xfeatures2d.hpp>

int main()

{

  // image matching

  // 1. Read input images

  cv::Mat image1= cv::imread("C:/Users/User/Desktop/CV_testimage/P6/image1.jpg",cv::IMREAD_GRAYSCALE);

  cv::Mat image2= cv::imread("C:/Users/User/Desktop/CV_testimage/P6/image2.jpg",cv::IMREAD_GRAYSCALE);

  //cv::Mat image1 = cv::imread("C:/Users/User/Desktop/CV_testimage/P5/p51.jpg", cv::IMREAD_GRAYSCALE);

  //cv::Mat image2 = cv::imread("C:/Users/User/Desktop/CV_testimage/P5/p52.jpg", cv::IMREAD_GRAYSCALE);

  // 2. Define keypoints vector

  std::vector<cv::KeyPoint> keypoints1;

  std::vector<cv::KeyPoint> keypoints2;

  // 3. Define feature detector

  // Construct the SURF feature detector object

  cv::Ptr<cv::Feature2D> ptrFeature2D = cv::xfeatures2d::SURF::create(2000.0);

  // to test with SIFT instead of SURF

// cv::Ptr<cv::Feature2D> ptrFeature2D = cv::xfeatures2d::SIFT::create(74);

  // 4. Keypoint detection

  // Detect the SURF features

  ptrFeature2D->detect(image1,keypoints1);

  ptrFeature2D->detect(image2,keypoints2);

  // Draw feature points

  cv::Mat featureImage;

cv::drawKeypoints(image1,keypoints1,featureImage,cv::Scalar(255,255,0),cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

// Display the corners

  cv::namedWindow("SURF");

  cv::imshow("SURF",featureImage);

  std::cout << "Number of SURF keypoints (image 1): " << keypoints1.size() << std::endl;

  std::cout << "Number of SURF keypoints (image 2): " << keypoints2.size() << std::endl;

  // SURF includes both the detector and descriptor extractor

  // 5. Extract the descriptor

cv::Mat descriptors1;

cv::Mat descriptors2;

  ptrFeature2D->compute(image1,keypoints1,descriptors1);

  ptrFeature2D->compute(image2,keypoints2,descriptors2);

// Construction of the matcher

  cv::BFMatcher matcher(cv::NORM_L2);

  // to test with crosscheck (symmetry) test

  // note: must not be used in conjunction with ratio test

// cv::BFMatcher matcher(cv::NORM_L2, true); // with crosscheck

  // Match the two image descriptors

std::vector<cv::DMatch> matches;

    matcher.match(descriptors1,descriptors2, matches);

// draw matches

cv::Mat imageMatches;

    cv::drawMatches(

    image1, keypoints1, // 1st image and its keypoints

    image2, keypoints2, // 2nd image and its keypoints

    matches,        // the matches

    imageMatches,   // the image produced

    cv::Scalar(0, 255, 255),  // color of lines

    cv::Scalar(0, 255, 255),  // color of points

    std::vector< char >(),  // masks if any

    cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS | cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

// Display the image of matches

  cv::namedWindow("SURF Matches");

  cv::imshow("SURF Matches",imageMatches);

  std::cout << "Number of matches: " << matches.size() << std::endl;

  // perform the ratio test

  // find the best two matches of each keypoint

  std::vector<std::vector<cv::DMatch> > matches2;

  matcher.knnMatch(descriptors1, descriptors2,

               matches2,

               2); // find the k (2) best matches

  matches.clear();

  // perform ratio test

  double ratioMax= 0.6;

std::vector<std::vector<cv::DMatch> >::iterator it;

  for (it= matches2.begin(); it!= matches2.end(); ++it) {

       //   first best match/second best match

       if ((*it)[0].distance/(*it)[1].distance < ratioMax) {

           // it is an acceptable match

           matches.push_back((*it)[0]);

       }

  }

  // matches is the new match set

    cv::drawMatches(

     image1,keypoints1, // 1st image and its keypoints

     image2,keypoints2, // 2nd image and its keypoints

  matches,       // the matches

     imageMatches,  // the image produced

  cv::Scalar(255,0,0),  // color of lines

  cv::Scalar(255,0,0),  // color of points

  std::vector< char >(), // masks if any

  cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS | cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

  std::cout << "Number of matches (after ratio test): " << matches.size() << std::endl;

// Display the image of matches

  cv::namedWindow("SURF Matches (ratio test at 0.6)");

  cv::imshow("SURF Matches (ratio test at 0.6)",imageMatches);

  // radius match

  float maxDist = 0.3;

  matches2.clear();

  matcher.radiusMatch(descriptors1, descriptors2, matches2,

                   maxDist); // maximum acceptable distance

                              // between the 2 descriptors

  cv::drawMatches(

       image1, keypoints1, // 1st image and its keypoints

       image2, keypoints2, // 2nd image and its keypoints

       matches2,      // the matches

       imageMatches,  // the image produced

       cv::Scalar(0, 255, 0),  // color of lines

       cv::Scalar(0, 255, 0),  // color of points

       std::vector<std::vector< char >>(), // masks if any

       cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS | cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

  int nmatches = 0;

  for (int i = 0; i< matches2.size(); i++) nmatches += matches2[i].size();

  std::cout << "Number of matches (with max radius): " << nmatches << std::endl;

  // Display the image of matches

  cv::namedWindow("SURF Matches (with max radius)");

  cv::imshow("SURF Matches (with max radius)", imageMatches);

  // scale-invariance test

  // Read input images

  image1= cv::imread("C:/Users/User/Desktop/CV_testimage/P6/image1.jpg",cv::IMREAD_GRAYSCALE);

  image2= cv::imread("C:/Users/User/Desktop/CV_testimage/P6/image2.jpg",cv::IMREAD_GRAYSCALE);

  std::cout << "Number of SIFT keypoints (image 1): " << keypoints1.size() << std::endl;

  std::cout << "Number of SIFT keypoints (image 2): " << keypoints2.size() << std::endl;

  // Extract the keypoints and descriptors

  ptrFeature2D = cv::SIFT::create();

  ptrFeature2D->detectAndCompute(image1, cv::noArray(), keypoints1, descriptors1);

  ptrFeature2D->detectAndCompute(image2, cv::noArray(), keypoints2, descriptors2);

// Match the two image descriptors

    matcher.match(descriptors1,descriptors2, matches);

  // extract the 50 best matches

std::nth_element(matches.begin(),matches.begin()+50,matches.end());

  matches.erase(matches.begin()+50,matches.end());

   // draw matches

  cv::drawMatches(

       image1, keypoints1, // 1st image and its keypoints

       image2, keypoints2, // 2nd image and its keypoints

       matches,        // the matches

       imageMatches,  // the image produced

       cv::Scalar(0, 0, 255),  // color of lines

       cv::Scalar(0, 0, 255), // color of points

       std::vector<char>(), cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS| cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

// Display the image of matches

  cv::namedWindow("Multi-scale SIFT Matches");

  cv::imshow("Multi-scale SIFT Matches",imageMatches);

  std::cout << "Number of matches: " << matches.size() << std::endl;

cv::waitKey();

return 0;

}

#include <iostream>

#include <vector>

#include <opencv2/core.hpp>

#include <opencv2/imgproc.hpp>

#include <opencv2/highgui.hpp>

#include <opencv2/features2d.hpp>

#include <opencv2/objdetect.hpp>

#include <opencv2/xfeatures2d.hpp>

int main()

{

  // image matching

  // 1. Read input images

  //cv::Mat image1= cv::imread("C:/Users/User/Desktop/CV_testimage/P6/image1.jpg", cv::IMREAD_GRAYSCALE);

  //cv::Mat image2= cv::imread("C:/Users/User/Desktop/CV_testimage/P6/image2.jpg", cv::IMREAD_GRAYSCALE);

  cv::Mat image1 = cv::imread("C:/Users/User/Desktop/CV_testimage/P5/p51.jpg", cv::IMREAD_GRAYSCALE);

  cv::Mat image2 = cv::imread("C:/Users/User/Desktop/CV_testimage/P5/p52.jpg", cv::IMREAD_GRAYSCALE);

  // 2. Define keypoint vectors and descriptors

  std::vector<cv::KeyPoint> keypoints1;

  std::vector<cv::KeyPoint> keypoints2;

  cv::Mat descriptors1;

  cv::Mat descriptors2;

  // 3. Define feature detector/descriptor

  // Construct the ORB feature object

  cv::Ptr<cv::Feature2D> feature =

       cv::ORB::create(60);

  //   cv::BRISK::create(80);

  // 4. Keypoint detection and description

  // Detect the ORB features

  feature->detectAndCompute(image1, cv::noArray(), keypoints1, descriptors1);

  feature->detectAndCompute(image2, cv::noArray(), keypoints2, descriptors2);

  // Draw feature points

  cv::Mat featureImage;

cv::drawKeypoints(image1,keypoints1,featureImage,cv::Scalar(0,0,255),cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

// Display the corners

  cv::namedWindow("ORB");

  cv::imshow("ORB",featureImage);

  std::cout << "Number of ORB keypoints (image 1): " << keypoints1.size() << std::endl;

  std::cout << "Number of ORB keypoints (image 2): " << keypoints2.size() << std::endl;

  // to describe with FREAK (use with BRISK)

  // feature = cv::xfeatures2d::FREAK::create();

  // feature->compute(image1, keypoints1, descriptors1);

  // feature->compute(image1, keypoints2, descriptors2);

   // Construction of the matcher

   cv::BFMatcher matcher(

    cv::NORM_HAMMING); // always use hamming norm

                          // for binary descriptors

   // Match the two image descriptors

   std::vector<cv::DMatch> matches;

   matcher.match(descriptors1,descriptors2, matches);

   // draw matches

   cv::Mat imageMatches;

   cv::drawMatches(

     image1,keypoints1, // 1st image and its keypoints

     image2,keypoints2, // 2nd image and its keypoints

  matches,       // the matches

     imageMatches,  // the image produced

  cv::Scalar(0,0,255),  // color of lines

  cv::Scalar(0,0,255),  // color of points

  std::vector< char >(), // masks if any

  cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS | cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);

// Display the image of matches

   cv::namedWindow("ORB Matches");

   cv::imshow("ORB Matches", imageMatches);

//   cv::namedWindow("FREAK Matches");

//   cv::imshow("FREAK Matches", imageMatches);

  std::cout << "Number of matches: " << matches.size() << std::endl;

   cv::waitKey();

   return 0;

}