catree
7 years ago
parent
670acd99f9
commit
c02b241e52
5 changed files with 754 additions and 0 deletions
@ -0,0 +1,138 @@ |
||||
#include <iostream> |
||||
#include <opencv2/core.hpp> |
||||
#include <opencv2/videoio.hpp> |
||||
#include <opencv2/highgui.hpp> |
||||
#include <opencv2/imgproc.hpp> |
||||
#include <opencv2/features2d.hpp> |
||||
#include <opencv2/flann.hpp> |
||||
#include <opencv2/xfeatures2d.hpp> |
||||
|
||||
using namespace cv; |
||||
using namespace cv::xfeatures2d; |
||||
|
||||
////////////////////////////////////////////////////
|
||||
// This program demonstrates the GMS matching strategy.
|
||||
int main(int argc, char* argv[]) |
||||
{ |
||||
const char* keys = |
||||
"{ h help | | print help message }" |
||||
"{ l left | | specify left (reference) image }" |
||||
"{ r right | | specify right (query) image }" |
||||
"{ camera | 0 | specify the camera device number }" |
||||
"{ nfeatures | 10000 | specify the maximum number of ORB features }" |
||||
"{ fastThreshold | 20 | specify the FAST threshold }" |
||||
"{ drawSimple | true | do not draw not matched keypoints }" |
||||
"{ withRotation | false | take rotation into account }" |
||||
"{ withScale | false | take scale into account }"; |
||||
|
||||
CommandLineParser cmd(argc, argv, keys); |
||||
if (cmd.has("help")) |
||||
{ |
||||
std::cout << "Usage: gms_matcher [options]" << std::endl; |
||||
std::cout << "Available options:" << std::endl; |
||||
cmd.printMessage(); |
||||
return EXIT_SUCCESS; |
||||
} |
||||
|
||||
Ptr<Feature2D> orb = ORB::create(cmd.get<int>("nfeatures")); |
||||
orb.dynamicCast<cv::ORB>()->setFastThreshold(cmd.get<int>("fastThreshold")); |
||||
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming"); |
||||
|
||||
if (!cmd.get<String>("left").empty() && !cmd.get<String>("right").empty()) |
||||
{ |
||||
Mat imgL = imread(cmd.get<String>("left")); |
||||
Mat imgR = imread(cmd.get<String>("right")); |
||||
|
||||
std::vector<KeyPoint> kpRef, kpCur; |
||||
Mat descRef, descCur; |
||||
orb->detectAndCompute(imgL, noArray(), kpRef, descRef); |
||||
orb->detectAndCompute(imgR, noArray(), kpCur, descCur); |
||||
|
||||
std::vector<DMatch> matchesAll, matchesGMS; |
||||
matcher->match(descCur, descRef, matchesAll); |
||||
|
||||
matchGMS(imgR.size(), imgL.size(), kpCur, kpRef, matchesAll, matchesGMS, cmd.get<bool>("withRotation"), cmd.get<bool>("withScale")); |
||||
std::cout << "matchesGMS: " << matchesGMS.size() << std::endl; |
||||
|
||||
Mat frameMatches; |
||||
if (cmd.get<bool>("drawSimple")) |
||||
drawMatches(imgR, kpCur, imgL, kpRef, matchesGMS, frameMatches, Scalar::all(-1), Scalar::all(-1), |
||||
std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS); |
||||
else |
||||
drawMatches(imgR, kpCur, imgL, kpRef, matchesGMS, frameMatches); |
||||
imshow("Matches GMS", frameMatches); |
||||
waitKey(); |
||||
} |
||||
else |
||||
{ |
||||
std::vector<KeyPoint> kpRef; |
||||
Mat descRef; |
||||
|
||||
VideoCapture capture(cmd.get<int>("camera")); |
||||
//Camera warm-up
|
||||
for (int i = 0; i < 10; i++) |
||||
{ |
||||
Mat frame; |
||||
capture >> frame; |
||||
} |
||||
|
||||
Mat frameRef; |
||||
for (;;) |
||||
{ |
||||
Mat frame; |
||||
capture >> frame; |
||||
|
||||
if (frameRef.empty()) |
||||
{ |
||||
frame.copyTo(frameRef); |
||||
orb->detectAndCompute(frameRef, noArray(), kpRef, descRef); |
||||
} |
||||
|
||||
TickMeter tm; |
||||
tm.start(); |
||||
std::vector<KeyPoint> kp; |
||||
Mat desc; |
||||
orb->detectAndCompute(frame, noArray(), kp, desc); |
||||
tm.stop(); |
||||
double t_orb = tm.getTimeMilli(); |
||||
|
||||
tm.reset(); |
||||
tm.start(); |
||||
std::vector<DMatch> matchesAll, matchesGMS; |
||||
matcher->match(desc, descRef, matchesAll); |
||||
tm.stop(); |
||||
double t_match = tm.getTimeMilli(); |
||||
|
||||
matchGMS(frame.size(), frameRef.size(), kp, kpRef, matchesAll, matchesGMS, cmd.get<bool>("withRotation"), cmd.get<bool>("withScale")); |
||||
tm.stop(); |
||||
Mat frameMatches; |
||||
if (cmd.get<bool>("drawSimple")) |
||||
drawMatches(frame, kp, frameRef, kpRef, matchesGMS, frameMatches, Scalar::all(-1), Scalar::all(-1), |
||||
std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS); |
||||
else |
||||
drawMatches(frame, kp, frameRef, kpRef, matchesGMS, frameMatches); |
||||
|
||||
String label = format("ORB: %.2f ms", t_orb); |
||||
putText(frameMatches, label, Point(20, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255)); |
||||
label = format("Matching: %.2f ms", t_match); |
||||
putText(frameMatches, label, Point(20, 40), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255)); |
||||
label = format("GMS matching: %.2f ms", tm.getTimeMilli()); |
||||
putText(frameMatches, label, Point(20, 60), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255)); |
||||
putText(frameMatches, "Press r to reinitialize the reference image.", Point(frameMatches.cols-380, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255)); |
||||
putText(frameMatches, "Press esc to quit.", Point(frameMatches.cols-180, 40), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255)); |
||||
|
||||
imshow("Matches GMS", frameMatches); |
||||
int c = waitKey(30); |
||||
if (c == 27) |
||||
break; |
||||
else if (c == 'r') |
||||
{ |
||||
frame.copyTo(frameRef); |
||||
orb->detectAndCompute(frameRef, noArray(), kpRef, descRef); |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
return EXIT_SUCCESS; |
||||
} |
||||
@ -0,0 +1,460 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
/*********************************************************************
|
||||
* This is the implementation of the paper |
||||
* GMS: Grid-based Motion Statistics for Fast, Ultra-robust Feature Correspondence. |
||||
* JiaWang Bian, Wen-Yan Lin, Yasuyuki Matsushita, Sai-Kit Yeung, Tan Dat Nguyen, Ming-Ming Cheng |
||||
* IEEE CVPR, 2017 |
||||
* ProjectPage: http://jwbian.net/gms
|
||||
*********************************************************************/ |
||||
|
||||
#include "precomp.hpp" |
||||
#include <algorithm> |
||||
|
||||
using namespace std; |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace xfeatures2d |
||||
{ |
||||
// 8 possible rotation and each one is 3 X 3
|
||||
const int mRotationPatterns[8][9] = { |
||||
{ |
||||
1,2,3, |
||||
4,5,6, |
||||
7,8,9 |
||||
}, |
||||
{ |
||||
4,1,2, |
||||
7,5,3, |
||||
8,9,6 |
||||
}, |
||||
{ |
||||
7,4,1, |
||||
8,5,2, |
||||
9,6,3 |
||||
}, |
||||
{ |
||||
8,7,4, |
||||
9,5,1, |
||||
6,3,2 |
||||
}, |
||||
{ |
||||
9,8,7, |
||||
6,5,4, |
||||
3,2,1 |
||||
}, |
||||
{ |
||||
6,9,8, |
||||
3,5,7, |
||||
2,1,4 |
||||
}, |
||||
{ |
||||
3,6,9, |
||||
2,5,8, |
||||
1,4,7 |
||||
}, |
||||
{ |
||||
2,3,6, |
||||
1,5,9, |
||||
4,7,8 |
||||
} |
||||
}; |
||||
|
||||
// 5 level scales
|
||||
const double mScaleRatios[5] = { 1.0, 1.0 / 2, 1.0 / std::sqrt(2.0), std::sqrt(2.0), 2.0 }; |
||||
|
||||
class GMSMatcher |
||||
{ |
||||
public: |
||||
// OpenCV Keypoints & Correspond Image Size & Nearest Neighbor Matches
|
||||
GMSMatcher(const vector<KeyPoint>& vkp1, const Size& size1, const vector<KeyPoint>& vkp2, const Size& size2, |
||||
const vector<DMatch>& vDMatches, const double thresholdFactor) : mThresholdFactor(thresholdFactor) |
||||
{ |
||||
// Input initialize
|
||||
normalizePoints(vkp1, size1, mvP1); |
||||
normalizePoints(vkp2, size2, mvP2); |
||||
mNumberMatches = vDMatches.size(); |
||||
convertMatches(vDMatches, mvMatches); |
||||
|
||||
// Grid initialize
|
||||
mGridSizeLeft = Size(20, 20); |
||||
mGridNumberLeft = mGridSizeLeft.width * mGridSizeLeft.height; |
||||
|
||||
// Initialize the neighbor of left grid
|
||||
mGridNeighborLeft = Mat::zeros(mGridNumberLeft, 9, CV_32SC1); |
||||
initalizeNeighbors(mGridNeighborLeft, mGridSizeLeft); |
||||
} |
||||
|
||||
~GMSMatcher() {} |
||||
|
||||
// Get Inlier Mask
|
||||
// Return number of inliers
|
||||
int getInlierMask(vector<bool> &vbInliers, const bool withRotation = false, const bool withScale = false); |
||||
|
||||
|
||||
private: |
||||
// Normalized Points
|
||||
vector<Point2f> mvP1, mvP2; |
||||
|
||||
// Matches
|
||||
vector<pair<int, int> > mvMatches; |
||||
|
||||
// Number of Matches
|
||||
size_t mNumberMatches; |
||||
|
||||
// Grid Size
|
||||
Size mGridSizeLeft, mGridSizeRight; |
||||
int mGridNumberLeft; |
||||
int mGridNumberRight; |
||||
|
||||
// x : left grid idx
|
||||
// y : right grid idx
|
||||
// value : how many matches from idx_left to idx_right
|
||||
Mat mMotionStatistics; |
||||
|
||||
//
|
||||
vector<int> mNumberPointsInPerCellLeft; |
||||
|
||||
// Inldex : grid_idx_left
|
||||
// Value : grid_idx_right
|
||||
vector<int> mCellPairs; |
||||
|
||||
// Every Matches has a cell-pair
|
||||
// first : grid_idx_left
|
||||
// second : grid_idx_right
|
||||
vector<pair<int, int> > mvMatchPairs; |
||||
|
||||
// Inlier Mask for output
|
||||
vector<bool> mvbInlierMask; |
||||
|
||||
//
|
||||
Mat mGridNeighborLeft; |
||||
Mat mGridNeighborRight; |
||||
|
||||
double mThresholdFactor; |
||||
|
||||
|
||||
// Assign Matches to Cell Pairs
|
||||
void assignMatchPairs(const int GridType); |
||||
|
||||
void convertMatches(const vector<DMatch> &vDMatches, vector<pair<int, int> > &vMatches); |
||||
|
||||
int getGridIndexLeft(const Point2f &pt, const int type); |
||||
|
||||
int getGridIndexRight(const Point2f &pt); |
||||
|
||||
vector<int> getNB9(const int idx, const Size& GridSize); |
||||
|
||||
void initalizeNeighbors(Mat &neighbor, const Size& GridSize); |
||||
|
||||
void normalizePoints(const vector<KeyPoint> &kp, const Size &size, vector<Point2f> &npts); |
||||
|
||||
// Run
|
||||
int run(const int rotationType); |
||||
|
||||
void setScale(const int scale); |
||||
|
||||
// Verify Cell Pairs
|
||||
void verifyCellPairs(const int rotationType); |
||||
}; |
||||
|
||||
void GMSMatcher::assignMatchPairs(const int gridType) |
||||
{ |
||||
for (size_t i = 0; i < mNumberMatches; i++) |
||||
{ |
||||
Point2f &lp = mvP1[mvMatches[i].first]; |
||||
Point2f &rp = mvP2[mvMatches[i].second]; |
||||
|
||||
int lgidx = mvMatchPairs[i].first = getGridIndexLeft(lp, gridType); |
||||
int rgidx = -1; |
||||
|
||||
if (gridType == 1) |
||||
{ |
||||
rgidx = mvMatchPairs[i].second = getGridIndexRight(rp); |
||||
} |
||||
else |
||||
{ |
||||
rgidx = mvMatchPairs[i].second; |
||||
} |
||||
|
||||
if (lgidx < 0 || rgidx < 0) continue; |
||||
|
||||
mMotionStatistics.at<int>(lgidx, rgidx)++; |
||||
mNumberPointsInPerCellLeft[lgidx]++; |
||||
} |
||||
} |
||||
|
||||
// Convert OpenCV DMatch to Match (pair<int, int>)
|
||||
void GMSMatcher::convertMatches(const vector<DMatch> &vDMatches, vector<pair<int, int> > &vMatches) |
||||
{ |
||||
vMatches.resize(mNumberMatches); |
||||
for (size_t i = 0; i < mNumberMatches; i++) |
||||
vMatches[i] = pair<int, int>(vDMatches[i].queryIdx, vDMatches[i].trainIdx); |
||||
} |
||||
|
||||
int GMSMatcher::getGridIndexLeft(const Point2f &pt, const int type) |
||||
{ |
||||
int x = 0, y = 0; |
||||
|
||||
if (type == 1) { |
||||
x = cvFloor(pt.x * mGridSizeLeft.width); |
||||
y = cvFloor(pt.y * mGridSizeLeft.height); |
||||
} |
||||
|
||||
if (type == 2) { |
||||
x = cvFloor(pt.x * mGridSizeLeft.width + 0.5); |
||||
y = cvFloor(pt.y * mGridSizeLeft.height); |
||||
} |
||||
|
||||
if (type == 3) { |
||||
x = cvFloor(pt.x * mGridSizeLeft.width); |
||||
y = cvFloor(pt.y * mGridSizeLeft.height + 0.5); |
||||
} |
||||
|
||||
if (type == 4) { |
||||
x = cvFloor(pt.x * mGridSizeLeft.width + 0.5); |
||||
y = cvFloor(pt.y * mGridSizeLeft.height + 0.5); |
||||
} |
||||
|
||||
|
||||
if (x >= mGridSizeLeft.width || y >= mGridSizeLeft.height) |
||||
return -1; |
||||
|
||||
return x + y * mGridSizeLeft.width; |
||||
} |
||||
|
||||
int GMSMatcher::getGridIndexRight(const Point2f &pt) |
||||
{ |
||||
int x = cvFloor(pt.x * mGridSizeRight.width); |
||||
int y = cvFloor(pt.y * mGridSizeRight.height); |
||||
|
||||
return x + y * mGridSizeRight.width; |
||||
} |
||||
|
||||
int GMSMatcher::getInlierMask(vector<bool> &vbInliers, const bool withRotation, const bool withScale) |
||||
{ |
||||
int max_inlier = 0; |
||||
|
||||
if (!withScale && !withRotation) |
||||
{ |
||||
setScale(0); |
||||
max_inlier = run(1); |
||||
vbInliers = mvbInlierMask; |
||||
return max_inlier; |
||||
} |
||||
|
||||
if (withRotation && withScale) |
||||
{ |
||||
for (int scale = 0; scale < 5; scale++) |
||||
{ |
||||
setScale(scale); |
||||
for (int rotationType = 1; rotationType <= 8; rotationType++) |
||||
{ |
||||
int num_inlier = run(rotationType); |
||||
|
||||
if (num_inlier > max_inlier) |
||||
{ |
||||
vbInliers = mvbInlierMask; |
||||
max_inlier = num_inlier; |
||||
} |
||||
} |
||||
} |
||||
return max_inlier; |
||||
} |
||||
|
||||
if (withRotation && !withScale) |
||||
{ |
||||
setScale(0); |
||||
for (int rotationType = 1; rotationType <= 8; rotationType++) |
||||
{ |
||||
int num_inlier = run(rotationType); |
||||
|
||||
if (num_inlier > max_inlier) |
||||
{ |
||||
vbInliers = mvbInlierMask; |
||||
max_inlier = num_inlier; |
||||
} |
||||
} |
||||
return max_inlier; |
||||
} |
||||
|
||||
if (!withRotation && withScale) |
||||
{ |
||||
for (int scale = 0; scale < 5; scale++) |
||||
{ |
||||
setScale(scale); |
||||
int num_inlier = run(1); |
||||
|
||||
if (num_inlier > max_inlier) |
||||
{ |
||||
vbInliers = mvbInlierMask; |
||||
max_inlier = num_inlier; |
||||
} |
||||
|
||||
} |
||||
return max_inlier; |
||||
} |
||||
|
||||
return max_inlier; |
||||
} |
||||
|
||||
// Get Neighbor 9
|
||||
vector<int> GMSMatcher::getNB9(const int idx, const Size& gridSize) |
||||
{ |
||||
vector<int> NB9(9, -1); |
||||
|
||||
int idx_x = idx % gridSize.width; |
||||
int idx_y = idx / gridSize.width; |
||||
|
||||
for (int yi = -1; yi <= 1; yi++) |
||||
{ |
||||
for (int xi = -1; xi <= 1; xi++) |
||||
{ |
||||
int idx_xx = idx_x + xi; |
||||
int idx_yy = idx_y + yi; |
||||
|
||||
if (idx_xx < 0 || idx_xx >= gridSize.width || idx_yy < 0 || idx_yy >= gridSize.height) |
||||
continue; |
||||
|
||||
NB9[xi + 4 + yi * 3] = idx_xx + idx_yy * gridSize.width; |
||||
} |
||||
} |
||||
return NB9; |
||||
} |
||||
|
||||
void GMSMatcher::initalizeNeighbors(Mat &neighbor, const Size& gridSize) |
||||
{ |
||||
for (int i = 0; i < neighbor.rows; i++) |
||||
{ |
||||
vector<int> NB9 = getNB9(i, gridSize); |
||||
int *data = neighbor.ptr<int>(i); |
||||
memcpy(data, &NB9[0], sizeof(int) * 9); |
||||
} |
||||
} |
||||
|
||||
// Normalize Key Points to Range(0 - 1)
|
||||
void GMSMatcher::normalizePoints(const vector<KeyPoint> &kp, const Size &size, vector<Point2f> &npts) |
||||
{ |
||||
const size_t numP = kp.size(); |
||||
const int width = size.width; |
||||
const int height = size.height; |
||||
npts.resize(numP); |
||||
|
||||
for (size_t i = 0; i < numP; i++) |
||||
{ |
||||
npts[i].x = kp[i].pt.x / width; |
||||
npts[i].y = kp[i].pt.y / height; |
||||
} |
||||
} |
||||
|
||||
int GMSMatcher::run(const int rotationType) |
||||
{ |
||||
mvbInlierMask.assign(mNumberMatches, false); |
||||
|
||||
// Initialize Motion Statisctics
|
||||
mMotionStatistics = Mat::zeros(mGridNumberLeft, mGridNumberRight, CV_32SC1); |
||||
mvMatchPairs.assign(mNumberMatches, pair<int, int>(0, 0)); |
||||
|
||||
for (int gridType = 1; gridType <= 4; gridType++) |
||||
{ |
||||
// initialize
|
||||
mMotionStatistics.setTo(0); |
||||
mCellPairs.assign(mGridNumberLeft, -1); |
||||
mNumberPointsInPerCellLeft.assign(mGridNumberLeft, 0); |
||||
|
||||
assignMatchPairs(gridType); |
||||
verifyCellPairs(rotationType); |
||||
|
||||
// Mark inliers
|
||||
for (size_t i = 0; i < mNumberMatches; i++) |
||||
{ |
||||
if (mCellPairs[mvMatchPairs[i].first] == mvMatchPairs[i].second) |
||||
mvbInlierMask[i] = true; |
||||
} |
||||
} |
||||
|
||||
return (int) count(mvbInlierMask.begin(), mvbInlierMask.end(), true); //number of inliers
|
||||
} |
||||
|
||||
void GMSMatcher::setScale(const int scale) |
||||
{ |
||||
// Set Scale
|
||||
mGridSizeRight.width = cvRound(mGridSizeLeft.width * mScaleRatios[scale]); |
||||
mGridSizeRight.height = cvRound(mGridSizeLeft.height * mScaleRatios[scale]); |
||||
mGridNumberRight = mGridSizeRight.width * mGridSizeRight.height; |
||||
|
||||
// Initialize the neighbor of right grid
|
||||
mGridNeighborRight = Mat::zeros(mGridNumberRight, 9, CV_32SC1); |
||||
initalizeNeighbors(mGridNeighborRight, mGridSizeRight); |
||||
} |
||||
|
||||
void GMSMatcher::verifyCellPairs(const int rotationType) |
||||
{ |
||||
const int *CurrentRP = mRotationPatterns[rotationType - 1]; |
||||
|
||||
for (int i = 0; i < mGridNumberLeft; i++) |
||||
{ |
||||
if (sum(mMotionStatistics.row(i))[0] == 0) |
||||
{ |
||||
mCellPairs[i] = -1; |
||||
continue; |
||||
} |
||||
|
||||
int max_number = 0; |
||||
for (int j = 0; j < mGridNumberRight; j++) |
||||
{ |
||||
int *value = mMotionStatistics.ptr<int>(i); |
||||
if (value[j] > max_number) |
||||
{ |
||||
mCellPairs[i] = j; |
||||
max_number = value[j]; |
||||
} |
||||
} |
||||
|
||||
int idx_grid_rt = mCellPairs[i]; |
||||
|
||||
const int *NB9_lt = mGridNeighborLeft.ptr<int>(i); |
||||
const int *NB9_rt = mGridNeighborRight.ptr<int>(idx_grid_rt); |
||||
|
||||
int score = 0; |
||||
double thresh = 0; |
||||
int numpair = 0; |
||||
|
||||
for (size_t j = 0; j < 9; j++) |
||||
{ |
||||
int ll = NB9_lt[j]; |
||||
int rr = NB9_rt[CurrentRP[j] - 1]; |
||||
if (ll == -1 || rr == -1) |
||||
continue; |
||||
|
||||
score += mMotionStatistics.at<int>(ll, rr); |
||||
thresh += mNumberPointsInPerCellLeft[ll]; |
||||
numpair++; |
||||
} |
||||
|
||||
thresh = mThresholdFactor * std::sqrt(thresh / numpair); |
||||
|
||||
if (score < thresh) |
||||
mCellPairs[i] = -2; |
||||
} |
||||
} |
||||
|
||||
void matchGMS( const Size& size1, const Size& size2, const vector<KeyPoint>& keypoints1, const vector<KeyPoint>& keypoints2, |
||||
const vector<DMatch>& matches1to2, vector<DMatch>& matchesGMS, const bool withRotation, const bool withScale, |
||||
const double thresholdFactor ) |
||||
{ |
||||
GMSMatcher gms(keypoints1, size1, keypoints2, size2, matches1to2, thresholdFactor); |
||||
vector<bool> inlierMask; |
||||
gms.getInlierMask(inlierMask, withRotation, withScale); |
||||
|
||||
matchesGMS.clear(); |
||||
for (size_t i = 0; i < inlierMask.size(); i++) { |
||||
if (inlierMask[i]) |
||||
matchesGMS.push_back(matches1to2[i]); |
||||
} |
||||
} |
||||
|
||||
} //namespace xfeatures2d
|
||||
} //namespace cv
|
||||
@ -0,0 +1,119 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
|
||||
#include "test_precomp.hpp" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
using namespace cv::xfeatures2d; |
||||
|
||||
class CV_GMSMatcherTest : public cvtest::BaseTest |
||||
{ |
||||
public: |
||||
CV_GMSMatcherTest(); |
||||
~CV_GMSMatcherTest(); |
||||
|
||||
protected: |
||||
virtual void run(int); |
||||
|
||||
bool combinations[4][2]; |
||||
double eps[3][4]; //3 imgs x 4 combinations
|
||||
double correctMatchDistThreshold; |
||||
}; |
||||
|
||||
CV_GMSMatcherTest::CV_GMSMatcherTest() |
||||
{ |
||||
combinations[0][0] = false; combinations[0][1] = false; |
||||
combinations[1][0] = false; combinations[1][1] = true; |
||||
combinations[2][0] = true; combinations[2][1] = false; |
||||
combinations[3][0] = true; combinations[3][1] = true; |
||||
|
||||
//Threshold = truncate(min(acc_win32, acc_win64))
|
||||
eps[0][0] = 0.9313; |
||||
eps[0][1] = 0.9223; |
||||
eps[0][2] = 0.9313; |
||||
eps[0][3] = 0.9223; |
||||
|
||||
eps[1][0] = 0.8199; |
||||
eps[1][1] = 0.7964; |
||||
eps[1][2] = 0.8199; |
||||
eps[1][3] = 0.7964; |
||||
|
||||
eps[2][0] = 0.7098; |
||||
eps[2][1] = 0.6659; |
||||
eps[2][2] = 0.6939; |
||||
eps[2][3] = 0.6457; |
||||
|
||||
correctMatchDistThreshold = 5.0; |
||||
} |
||||
|
||||
CV_GMSMatcherTest::~CV_GMSMatcherTest() {} |
||||
|
||||
void CV_GMSMatcherTest::run( int ) |
||||
{ |
||||
ts->set_failed_test_info(cvtest::TS::OK); |
||||
|
||||
Mat imgRef = imread(string(ts->get_data_path()) + "detectors_descriptors_evaluation/images_datasets/graf/img1.png"); |
||||
|
||||
Ptr<Feature2D> orb = ORB::create(10000); |
||||
vector<KeyPoint> keypointsRef, keypointsCur; |
||||
Mat descriptorsRef, descriptorsCur; |
||||
orb->detectAndCompute(imgRef, noArray(), keypointsRef, descriptorsRef); |
||||
|
||||
vector<DMatch> matchesAll, matchesGMS; |
||||
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming"); |
||||
|
||||
const int startImg = 2; |
||||
const int nImgs = 3; |
||||
for (int num = startImg; num < startImg+nImgs; num++) |
||||
{ |
||||
string imgPath = string(ts->get_data_path()) + format("detectors_descriptors_evaluation/images_datasets/graf/img%d.png", num); |
||||
Mat imgCur = imread(imgPath); |
||||
orb->detectAndCompute(imgCur, noArray(), keypointsCur, descriptorsCur); |
||||
|
||||
matcher->match(descriptorsCur, descriptorsRef, matchesAll); |
||||
|
||||
string xml = string(ts->get_data_path()) + format("detectors_descriptors_evaluation/images_datasets/graf/H1to%dp.xml", num); |
||||
FileStorage fs(xml, FileStorage::READ); |
||||
if (!fs.isOpened()) |
||||
{ |
||||
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA); |
||||
return; |
||||
} |
||||
|
||||
Mat H1toCur; |
||||
fs[format("H1%d", num)] >> H1toCur; |
||||
|
||||
for (int comb = 0; comb < 4; comb++) |
||||
{ |
||||
matchGMS(imgCur.size(), imgRef.size(), keypointsCur, keypointsRef, matchesAll, matchesGMS, combinations[comb][0], combinations[comb][1]); |
||||
|
||||
int nbCorrectMatches = 0; |
||||
for (size_t i = 0; i < matchesGMS.size(); i++) |
||||
{ |
||||
Point2f ptRef = keypointsRef[matchesGMS[i].trainIdx].pt; |
||||
Point2f ptCur = keypointsCur[matchesGMS[i].queryIdx].pt; |
||||
Mat matRef = (Mat_<double>(3,1) << ptRef.x, ptRef.y, 1); |
||||
Mat matTrans = H1toCur * matRef; |
||||
Point2f ptTrans( (float) (matTrans.at<double>(0,0)/matTrans.at<double>(2,0)), |
||||
(float) (matTrans.at<double>(1,0)/matTrans.at<double>(2,0))); |
||||
|
||||
if (norm(ptTrans-ptCur) < correctMatchDistThreshold) |
||||
nbCorrectMatches++; |
||||
} |
||||
|
||||
double ratio = nbCorrectMatches / (double) matchesGMS.size(); |
||||
if (ratio < eps[num-startImg][comb]) |
||||
{ |
||||
ts->printf( cvtest::TS::LOG, "Invalid accuracy for image %s and combination withRotation=%d withScale=%d, " |
||||
"matches ratio is %f, ratio threshold is %f, distance threshold is %f.\n", |
||||
imgPath.substr(imgPath.size()-8).c_str(), combinations[comb][0], combinations[comb][1], ratio, |
||||
eps[num-startImg][comb], correctMatchDistThreshold); |
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
TEST(XFeatures2d_GMSMatcher, gms_matcher_regression) { CV_GMSMatcherTest test; test.safe_run(); } |
||||
Loading…
Reference in new issue