moved nonfree and a part of features2d to opencv_contrib/xfeatures2d
This commit is contained in:
Vadim Pisarevsky
@@ -5,7 +5,7 @@
|
||||
|
||||
SET(OPENCV_CPP_SAMPLES_REQUIRED_DEPS opencv_core opencv_imgproc opencv_flann
|
||||
opencv_imgcodecs opencv_videoio opencv_highgui opencv_ml opencv_video
|
||||
opencv_objdetect opencv_photo opencv_nonfree opencv_features2d opencv_calib3d
|
||||
opencv_objdetect opencv_photo opencv_features2d opencv_calib3d
|
||||
opencv_stitching opencv_videostab opencv_shape)
|
||||
|
||||
ocv_check_dependencies(${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,305 +0,0 @@
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/highgui/highgui.hpp"
|
||||
#include "opencv2/calib3d/calib3d.hpp"
|
||||
#include "opencv2/imgproc/imgproc.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include "opencv2/nonfree/nonfree.hpp"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
static void help(char** argv)
|
||||
{
|
||||
cout << "\nThis program demonstrats keypoint finding and matching between 2 images using features2d framework.\n"
|
||||
<< " In one case, the 2nd image is synthesized by homography from the first, in the second case, there are 2 images\n"
|
||||
<< "\n"
|
||||
<< "Case1: second image is obtained from the first (given) image using random generated homography matrix\n"
|
||||
<< argv[0] << " [detectorType] [descriptorType] [matcherType] [matcherFilterType] [image] [evaluate(0 or 1)]\n"
|
||||
<< "Example of case1:\n"
|
||||
<< "./descriptor_extractor_matcher SURF SURF FlannBased NoneFilter cola.jpg 0\n"
|
||||
<< "\n"
|
||||
<< "Case2: both images are given. If ransacReprojThreshold>=0 then homography matrix are calculated\n"
|
||||
<< argv[0] << " [detectorType] [descriptorType] [matcherType] [matcherFilterType] [image1] [image2] [ransacReprojThreshold]\n"
|
||||
<< "\n"
|
||||
<< "Matches are filtered using homography matrix in case1 and case2 (if ransacReprojThreshold>=0)\n"
|
||||
<< "Example of case2:\n"
|
||||
<< "./descriptor_extractor_matcher SURF SURF BruteForce CrossCheckFilter cola1.jpg cola2.jpg 3\n"
|
||||
<< "\n"
|
||||
<< "Possible detectorType values: see in documentation on createFeatureDetector().\n"
|
||||
<< "Possible descriptorType values: see in documentation on createDescriptorExtractor().\n"
|
||||
<< "Possible matcherType values: see in documentation on createDescriptorMatcher().\n"
|
||||
<< "Possible matcherFilterType values: NoneFilter, CrossCheckFilter." << endl;
|
||||
}
|
||||
|
||||
#define DRAW_RICH_KEYPOINTS_MODE 0
|
||||
#define DRAW_OUTLIERS_MODE 0
|
||||
|
||||
const string winName = "correspondences";
|
||||
|
||||
enum { NONE_FILTER = 0, CROSS_CHECK_FILTER = 1 };
|
||||
|
||||
static int getMatcherFilterType( const string& str )
|
||||
{
|
||||
if( str == "NoneFilter" )
|
||||
return NONE_FILTER;
|
||||
if( str == "CrossCheckFilter" )
|
||||
return CROSS_CHECK_FILTER;
|
||||
CV_Error(Error::StsBadArg, "Invalid filter name");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void simpleMatching( Ptr<DescriptorMatcher>& descriptorMatcher,
|
||||
const Mat& descriptors1, const Mat& descriptors2,
|
||||
vector<DMatch>& matches12 )
|
||||
{
|
||||
vector<DMatch> matches;
|
||||
descriptorMatcher->match( descriptors1, descriptors2, matches12 );
|
||||
}
|
||||
|
||||
static void crossCheckMatching( Ptr<DescriptorMatcher>& descriptorMatcher,
|
||||
const Mat& descriptors1, const Mat& descriptors2,
|
||||
vector<DMatch>& filteredMatches12, int knn=1 )
|
||||
{
|
||||
filteredMatches12.clear();
|
||||
vector<vector<DMatch> > matches12, matches21;
|
||||
descriptorMatcher->knnMatch( descriptors1, descriptors2, matches12, knn );
|
||||
descriptorMatcher->knnMatch( descriptors2, descriptors1, matches21, knn );
|
||||
for( size_t m = 0; m < matches12.size(); m++ )
|
||||
{
|
||||
bool findCrossCheck = false;
|
||||
for( size_t fk = 0; fk < matches12[m].size(); fk++ )
|
||||
{
|
||||
DMatch forward = matches12[m][fk];
|
||||
|
||||
for( size_t bk = 0; bk < matches21[forward.trainIdx].size(); bk++ )
|
||||
{
|
||||
DMatch backward = matches21[forward.trainIdx][bk];
|
||||
if( backward.trainIdx == forward.queryIdx )
|
||||
{
|
||||
filteredMatches12.push_back(forward);
|
||||
findCrossCheck = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if( findCrossCheck ) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void warpPerspectiveRand( const Mat& src, Mat& dst, Mat& H, RNG& rng )
|
||||
{
|
||||
H.create(3, 3, CV_32FC1);
|
||||
H.at<float>(0,0) = rng.uniform( 0.8f, 1.2f);
|
||||
H.at<float>(0,1) = rng.uniform(-0.1f, 0.1f);
|
||||
H.at<float>(0,2) = rng.uniform(-0.1f, 0.1f)*src.cols;
|
||||
H.at<float>(1,0) = rng.uniform(-0.1f, 0.1f);
|
||||
H.at<float>(1,1) = rng.uniform( 0.8f, 1.2f);
|
||||
H.at<float>(1,2) = rng.uniform(-0.1f, 0.1f)*src.rows;
|
||||
H.at<float>(2,0) = rng.uniform( -1e-4f, 1e-4f);
|
||||
H.at<float>(2,1) = rng.uniform( -1e-4f, 1e-4f);
|
||||
H.at<float>(2,2) = rng.uniform( 0.8f, 1.2f);
|
||||
|
||||
warpPerspective( src, dst, H, src.size() );
|
||||
}
|
||||
|
||||
static void doIteration( const Mat& img1, Mat& img2, bool isWarpPerspective,
|
||||
vector<KeyPoint>& keypoints1, const Mat& descriptors1,
|
||||
Ptr<FeatureDetector>& detector, Ptr<DescriptorExtractor>& descriptorExtractor,
|
||||
Ptr<DescriptorMatcher>& descriptorMatcher, int matcherFilter, bool eval,
|
||||
double ransacReprojThreshold, RNG& rng )
|
||||
{
|
||||
CV_Assert( !img1.empty() );
|
||||
Mat H12;
|
||||
if( isWarpPerspective )
|
||||
warpPerspectiveRand(img1, img2, H12, rng );
|
||||
else
|
||||
CV_Assert( !img2.empty()/* && img2.cols==img1.cols && img2.rows==img1.rows*/ );
|
||||
|
||||
cout << endl << "< Extracting keypoints from second image..." << endl;
|
||||
vector<KeyPoint> keypoints2;
|
||||
detector->detect( img2, keypoints2 );
|
||||
cout << keypoints2.size() << " points" << endl << ">" << endl;
|
||||
|
||||
if( !H12.empty() && eval )
|
||||
{
|
||||
cout << "< Evaluate feature detector..." << endl;
|
||||
float repeatability;
|
||||
int correspCount;
|
||||
evaluateFeatureDetector( img1, img2, H12, &keypoints1, &keypoints2, repeatability, correspCount );
|
||||
cout << "repeatability = " << repeatability << endl;
|
||||
cout << "correspCount = " << correspCount << endl;
|
||||
cout << ">" << endl;
|
||||
}
|
||||
|
||||
cout << "< Computing descriptors for keypoints from second image..." << endl;
|
||||
Mat descriptors2;
|
||||
descriptorExtractor->compute( img2, keypoints2, descriptors2 );
|
||||
cout << ">" << endl;
|
||||
|
||||
cout << "< Matching descriptors..." << endl;
|
||||
vector<DMatch> filteredMatches;
|
||||
switch( matcherFilter )
|
||||
{
|
||||
case CROSS_CHECK_FILTER :
|
||||
crossCheckMatching( descriptorMatcher, descriptors1, descriptors2, filteredMatches, 1 );
|
||||
break;
|
||||
default :
|
||||
simpleMatching( descriptorMatcher, descriptors1, descriptors2, filteredMatches );
|
||||
}
|
||||
cout << ">" << endl;
|
||||
|
||||
if( !H12.empty() && eval )
|
||||
{
|
||||
cout << "< Evaluate descriptor matcher..." << endl;
|
||||
vector<Point2f> curve;
|
||||
Ptr<GenericDescriptorMatcher> gdm = makePtr<VectorDescriptorMatcher>( descriptorExtractor, descriptorMatcher );
|
||||
evaluateGenericDescriptorMatcher( img1, img2, H12, keypoints1, keypoints2, 0, 0, curve, gdm );
|
||||
|
||||
Point2f firstPoint = *curve.begin();
|
||||
Point2f lastPoint = *curve.rbegin();
|
||||
int prevPointIndex = -1;
|
||||
cout << "1-precision = " << firstPoint.x << "; recall = " << firstPoint.y << endl;
|
||||
for( float l_p = 0; l_p <= 1 + FLT_EPSILON; l_p+=0.05f )
|
||||
{
|
||||
int nearest = getNearestPoint( curve, l_p );
|
||||
if( nearest >= 0 )
|
||||
{
|
||||
Point2f curPoint = curve[nearest];
|
||||
if( curPoint.x > firstPoint.x && curPoint.x < lastPoint.x && nearest != prevPointIndex )
|
||||
{
|
||||
cout << "1-precision = " << curPoint.x << "; recall = " << curPoint.y << endl;
|
||||
prevPointIndex = nearest;
|
||||
}
|
||||
}
|
||||
}
|
||||
cout << "1-precision = " << lastPoint.x << "; recall = " << lastPoint.y << endl;
|
||||
cout << ">" << endl;
|
||||
}
|
||||
|
||||
vector<int> queryIdxs( filteredMatches.size() ), trainIdxs( filteredMatches.size() );
|
||||
for( size_t i = 0; i < filteredMatches.size(); i++ )
|
||||
{
|
||||
queryIdxs[i] = filteredMatches[i].queryIdx;
|
||||
trainIdxs[i] = filteredMatches[i].trainIdx;
|
||||
}
|
||||
|
||||
if( !isWarpPerspective && ransacReprojThreshold >= 0 )
|
||||
{
|
||||
cout << "< Computing homography (RANSAC)..." << endl;
|
||||
vector<Point2f> points1; KeyPoint::convert(keypoints1, points1, queryIdxs);
|
||||
vector<Point2f> points2; KeyPoint::convert(keypoints2, points2, trainIdxs);
|
||||
H12 = findHomography( Mat(points1), Mat(points2), RANSAC, ransacReprojThreshold );
|
||||
cout << ">" << endl;
|
||||
}
|
||||
|
||||
Mat drawImg;
|
||||
if( !H12.empty() ) // filter outliers
|
||||
{
|
||||
vector<char> matchesMask( filteredMatches.size(), 0 );
|
||||
vector<Point2f> points1; KeyPoint::convert(keypoints1, points1, queryIdxs);
|
||||
vector<Point2f> points2; KeyPoint::convert(keypoints2, points2, trainIdxs);
|
||||
Mat points1t; perspectiveTransform(Mat(points1), points1t, H12);
|
||||
|
||||
double maxInlierDist = ransacReprojThreshold < 0 ? 3 : ransacReprojThreshold;
|
||||
for( size_t i1 = 0; i1 < points1.size(); i1++ )
|
||||
{
|
||||
if( norm(points2[i1] - points1t.at<Point2f>((int)i1,0)) <= maxInlierDist ) // inlier
|
||||
matchesMask[i1] = 1;
|
||||
}
|
||||
// draw inliers
|
||||
drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, Scalar(0, 255, 0), Scalar(255, 0, 0), matchesMask
|
||||
#if DRAW_RICH_KEYPOINTS_MODE
|
||||
, DrawMatchesFlags::DRAW_RICH_KEYPOINTS
|
||||
#endif
|
||||
);
|
||||
|
||||
#if DRAW_OUTLIERS_MODE
|
||||
// draw outliers
|
||||
for( size_t i1 = 0; i1 < matchesMask.size(); i1++ )
|
||||
matchesMask[i1] = !matchesMask[i1];
|
||||
drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, Scalar(255, 0, 0), Scalar(0, 0, 255), matchesMask,
|
||||
DrawMatchesFlags::DRAW_OVER_OUTIMG | DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
|
||||
#endif
|
||||
|
||||
cout << "Number of inliers: " << countNonZero(matchesMask) << endl;
|
||||
}
|
||||
else
|
||||
drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg );
|
||||
|
||||
imshow( winName, drawImg );
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
if( argc != 7 && argc != 8 )
|
||||
{
|
||||
help(argv);
|
||||
return -1;
|
||||
}
|
||||
|
||||
cv::initModule_nonfree();
|
||||
|
||||
bool isWarpPerspective = argc == 7;
|
||||
double ransacReprojThreshold = -1;
|
||||
if( !isWarpPerspective )
|
||||
ransacReprojThreshold = atof(argv[7]);
|
||||
|
||||
cout << "< Creating detector, descriptor extractor and descriptor matcher ..." << endl;
|
||||
Ptr<FeatureDetector> detector = FeatureDetector::create( argv[1] );
|
||||
Ptr<DescriptorExtractor> descriptorExtractor = DescriptorExtractor::create( argv[2] );
|
||||
Ptr<DescriptorMatcher> descriptorMatcher = DescriptorMatcher::create( argv[3] );
|
||||
int mactherFilterType = getMatcherFilterType( argv[4] );
|
||||
bool eval = !isWarpPerspective ? false : (atoi(argv[6]) == 0 ? false : true);
|
||||
cout << ">" << endl;
|
||||
if( !detector || !descriptorExtractor || !descriptorMatcher )
|
||||
{
|
||||
cout << "Can not create detector or descriptor exstractor or descriptor matcher of given types" << endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
cout << "< Reading the images..." << endl;
|
||||
Mat img1 = imread( argv[5] ), img2;
|
||||
if( !isWarpPerspective )
|
||||
img2 = imread( argv[6] );
|
||||
cout << ">" << endl;
|
||||
if( img1.empty() || (!isWarpPerspective && img2.empty()) )
|
||||
{
|
||||
cout << "Can not read images" << endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
cout << endl << "< Extracting keypoints from first image..." << endl;
|
||||
vector<KeyPoint> keypoints1;
|
||||
detector->detect( img1, keypoints1 );
|
||||
cout << keypoints1.size() << " points" << endl << ">" << endl;
|
||||
|
||||
cout << "< Computing descriptors for keypoints from first image..." << endl;
|
||||
Mat descriptors1;
|
||||
descriptorExtractor->compute( img1, keypoints1, descriptors1 );
|
||||
cout << ">" << endl;
|
||||
|
||||
namedWindow(winName, 1);
|
||||
RNG rng = theRNG();
|
||||
doIteration( img1, img2, isWarpPerspective, keypoints1, descriptors1,
|
||||
detector, descriptorExtractor, descriptorMatcher, mactherFilterType, eval,
|
||||
ransacReprojThreshold, rng );
|
||||
for(;;)
|
||||
{
|
||||
char c = (char)waitKey(0);
|
||||
if( c == '\x1b' ) // esc
|
||||
{
|
||||
cout << "Exiting ..." << endl;
|
||||
break;
|
||||
}
|
||||
else if( isWarpPerspective )
|
||||
{
|
||||
doIteration( img1, img2, isWarpPerspective, keypoints1, descriptors1,
|
||||
detector, descriptorExtractor, descriptorMatcher, mactherFilterType, eval,
|
||||
ransacReprojThreshold, rng );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
/*
|
||||
* shape_context.cpp -- Shape context demo for shape matching
|
||||
*/
|
||||
|
||||
#include "opencv2/shape.hpp"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include "opencv2/nonfree/nonfree.hpp"
|
||||
#include <opencv2/core/utility.hpp>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
static void help()
|
||||
{
|
||||
printf("\nThis program demonstrates how to use common interface for shape transformers\n"
|
||||
"Call\n"
|
||||
"shape_transformation [image1] [image2]\n");
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
help();
|
||||
Mat img1 = imread(argv[1], IMREAD_GRAYSCALE);
|
||||
Mat img2 = imread(argv[2], IMREAD_GRAYSCALE);
|
||||
if(img1.empty() || img2.empty() || argc<2)
|
||||
{
|
||||
printf("Can't read one of the images\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// detecting keypoints
|
||||
SurfFeatureDetector detector(5000);
|
||||
vector<KeyPoint> keypoints1, keypoints2;
|
||||
detector.detect(img1, keypoints1);
|
||||
detector.detect(img2, keypoints2);
|
||||
|
||||
// computing descriptors
|
||||
SurfDescriptorExtractor extractor;
|
||||
Mat descriptors1, descriptors2;
|
||||
extractor.compute(img1, keypoints1, descriptors1);
|
||||
extractor.compute(img2, keypoints2, descriptors2);
|
||||
|
||||
// matching descriptors
|
||||
BFMatcher matcher(extractor.defaultNorm());
|
||||
vector<DMatch> matches;
|
||||
matcher.match(descriptors1, descriptors2, matches);
|
||||
|
||||
// drawing the results
|
||||
namedWindow("matches", 1);
|
||||
Mat img_matches;
|
||||
drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches);
|
||||
imshow("matches", img_matches);
|
||||
|
||||
// extract points
|
||||
vector<Point2f> pts1, pts2;
|
||||
for (size_t ii=0; ii<keypoints1.size(); ii++)
|
||||
pts1.push_back( keypoints1[ii].pt );
|
||||
for (size_t ii=0; ii<keypoints2.size(); ii++)
|
||||
pts2.push_back( keypoints2[ii].pt );
|
||||
|
||||
// Apply TPS
|
||||
Ptr<ThinPlateSplineShapeTransformer> mytps = createThinPlateSplineShapeTransformer(25000); //TPS with a relaxed constraint
|
||||
mytps->estimateTransformation(pts1, pts2, matches);
|
||||
mytps->warpImage(img2, img2);
|
||||
|
||||
imshow("Tranformed", img2);
|
||||
waitKey(0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
/**
|
||||
* @file SURF_FlannMatcher
|
||||
* @brief SURF detector + descriptor + FLANN Matcher
|
||||
* @author A. Huaman
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include "opencv2/core/core.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/highgui/highgui.hpp"
|
||||
#include "opencv2/nonfree/features2d.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
void readme();
|
||||
|
||||
/**
|
||||
* @function main
|
||||
* @brief Main function
|
||||
*/
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
if( argc != 3 )
|
||||
{ readme(); return -1; }
|
||||
|
||||
Mat img_1 = imread( argv[1], IMREAD_GRAYSCALE );
|
||||
Mat img_2 = imread( argv[2], IMREAD_GRAYSCALE );
|
||||
|
||||
if( !img_1.data || !img_2.data )
|
||||
{ std::cout<< " --(!) Error reading images " << std::endl; return -1; }
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector
|
||||
int minHessian = 400;
|
||||
|
||||
SurfFeatureDetector detector( minHessian );
|
||||
|
||||
std::vector<KeyPoint> keypoints_1, keypoints_2;
|
||||
|
||||
detector.detect( img_1, keypoints_1 );
|
||||
detector.detect( img_2, keypoints_2 );
|
||||
|
||||
//-- Step 2: Calculate descriptors (feature vectors)
|
||||
SurfDescriptorExtractor extractor;
|
||||
|
||||
Mat descriptors_1, descriptors_2;
|
||||
|
||||
extractor.compute( img_1, keypoints_1, descriptors_1 );
|
||||
extractor.compute( img_2, keypoints_2, descriptors_2 );
|
||||
|
||||
//-- Step 3: Matching descriptor vectors using FLANN matcher
|
||||
FlannBasedMatcher matcher;
|
||||
std::vector< DMatch > matches;
|
||||
matcher.match( descriptors_1, descriptors_2, matches );
|
||||
|
||||
double max_dist = 0; double min_dist = 100;
|
||||
|
||||
//-- Quick calculation of max and min distances between keypoints
|
||||
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 );
|
||||
|
||||
//-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist,
|
||||
//-- or a small arbitary value ( 0.02 ) in the event that min_dist is very
|
||||
//-- small)
|
||||
//-- PS.- radiusMatch can also be used here.
|
||||
std::vector< DMatch > good_matches;
|
||||
|
||||
for( int i = 0; i < descriptors_1.rows; i++ )
|
||||
{ if( matches[i].distance <= max(2*min_dist, 0.02) )
|
||||
{ good_matches.push_back( matches[i]); }
|
||||
}
|
||||
|
||||
//-- Draw only "good" matches
|
||||
Mat img_matches;
|
||||
drawMatches( img_1, keypoints_1, img_2, keypoints_2,
|
||||
good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
|
||||
vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
|
||||
|
||||
//-- Show detected matches
|
||||
imshow( "Good Matches", img_matches );
|
||||
|
||||
for( int i = 0; i < (int)good_matches.size(); i++ )
|
||||
{ printf( "-- Good Match [%d] Keypoint 1: %d -- Keypoint 2: %d \n", i, good_matches[i].queryIdx, good_matches[i].trainIdx ); }
|
||||
|
||||
waitKey(0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @function readme
|
||||
*/
|
||||
void readme()
|
||||
{ std::cout << " Usage: ./SURF_FlannMatcher <img1> <img2>" << std::endl; }
|
||||
@@ -1,126 +0,0 @@
|
||||
/**
|
||||
* @file SURF_Homography
|
||||
* @brief SURF detector + descriptor + FLANN Matcher + FindHomography
|
||||
* @author A. Huaman
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include "opencv2/core/core.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/highgui/highgui.hpp"
|
||||
#include "opencv2/calib3d/calib3d.hpp"
|
||||
#include "opencv2/nonfree/features2d.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
void readme();
|
||||
|
||||
/**
|
||||
* @function main
|
||||
* @brief Main function
|
||||
*/
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
if( argc != 3 )
|
||||
{ readme(); return -1; }
|
||||
|
||||
Mat img_object = imread( argv[1], IMREAD_GRAYSCALE );
|
||||
Mat img_scene = imread( argv[2], IMREAD_GRAYSCALE );
|
||||
|
||||
if( !img_object.data || !img_scene.data )
|
||||
{ std::cout<< " --(!) Error reading images " << std::endl; return -1; }
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector
|
||||
int minHessian = 400;
|
||||
|
||||
SurfFeatureDetector detector( minHessian );
|
||||
|
||||
std::vector<KeyPoint> keypoints_object, keypoints_scene;
|
||||
|
||||
detector.detect( img_object, keypoints_object );
|
||||
detector.detect( img_scene, keypoints_scene );
|
||||
|
||||
//-- Step 2: Calculate descriptors (feature vectors)
|
||||
SurfDescriptorExtractor extractor;
|
||||
|
||||
Mat descriptors_object, descriptors_scene;
|
||||
|
||||
extractor.compute( img_object, keypoints_object, descriptors_object );
|
||||
extractor.compute( img_scene, keypoints_scene, descriptors_scene );
|
||||
|
||||
//-- Step 3: Matching descriptor vectors using FLANN matcher
|
||||
FlannBasedMatcher matcher;
|
||||
std::vector< DMatch > matches;
|
||||
matcher.match( descriptors_object, descriptors_scene, matches );
|
||||
|
||||
double max_dist = 0; double min_dist = 100;
|
||||
|
||||
//-- Quick calculation of max and min distances between keypoints
|
||||
for( int i = 0; i < descriptors_object.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 );
|
||||
|
||||
//-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist )
|
||||
std::vector< DMatch > good_matches;
|
||||
|
||||
for( int i = 0; i < descriptors_object.rows; i++ )
|
||||
{ if( matches[i].distance < 3*min_dist )
|
||||
{ good_matches.push_back( matches[i]); }
|
||||
}
|
||||
|
||||
Mat img_matches;
|
||||
drawMatches( img_object, keypoints_object, img_scene, keypoints_scene,
|
||||
good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
|
||||
vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
|
||||
|
||||
|
||||
//-- Localize the object from img_1 in img_2
|
||||
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 );
|
||||
}
|
||||
|
||||
Mat H = findHomography( obj, scene, RANSAC );
|
||||
|
||||
//-- Get the corners from the image_1 ( the object to be "detected" )
|
||||
std::vector<Point2f> obj_corners(4);
|
||||
obj_corners[0] = Point(0,0); obj_corners[1] = Point( img_object.cols, 0 );
|
||||
obj_corners[2] = Point( img_object.cols, img_object.rows ); obj_corners[3] = Point( 0, 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 )
|
||||
Point2f offset( (float)img_object.cols, 0);
|
||||
line( img_matches, scene_corners[0] + offset, scene_corners[1] + offset, Scalar(0, 255, 0), 4 );
|
||||
line( img_matches, scene_corners[1] + offset, scene_corners[2] + offset, Scalar( 0, 255, 0), 4 );
|
||||
line( img_matches, scene_corners[2] + offset, scene_corners[3] + offset, Scalar( 0, 255, 0), 4 );
|
||||
line( img_matches, scene_corners[3] + offset, scene_corners[0] + offset, Scalar( 0, 255, 0), 4 );
|
||||
|
||||
//-- Show detected matches
|
||||
imshow( "Good Matches & Object detection", img_matches );
|
||||
|
||||
waitKey(0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @function readme
|
||||
*/
|
||||
void readme()
|
||||
{ std::cout << " Usage: ./SURF_Homography <img1> <img2>" << std::endl; }
|
||||
@@ -1,73 +0,0 @@
|
||||
/**
|
||||
* @file SURF_descriptor
|
||||
* @brief SURF detector + descritpor + BruteForce Matcher + drawing matches with OpenCV functions
|
||||
* @author A. Huaman
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include "opencv2/core/core.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/highgui/highgui.hpp"
|
||||
#include "opencv2/nonfree/features2d.hpp"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
void readme();
|
||||
|
||||
/**
|
||||
* @function main
|
||||
* @brief Main function
|
||||
*/
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
if( argc != 3 )
|
||||
{ return -1; }
|
||||
|
||||
Mat img_1 = imread( argv[1], IMREAD_GRAYSCALE );
|
||||
Mat img_2 = imread( argv[2], IMREAD_GRAYSCALE );
|
||||
|
||||
if( !img_1.data || !img_2.data )
|
||||
{ return -1; }
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector
|
||||
int minHessian = 400;
|
||||
|
||||
SurfFeatureDetector detector( minHessian );
|
||||
|
||||
std::vector<KeyPoint> keypoints_1, keypoints_2;
|
||||
|
||||
detector.detect( img_1, keypoints_1 );
|
||||
detector.detect( img_2, keypoints_2 );
|
||||
|
||||
//-- Step 2: Calculate descriptors (feature vectors)
|
||||
SurfDescriptorExtractor extractor;
|
||||
|
||||
Mat descriptors_1, descriptors_2;
|
||||
|
||||
extractor.compute( img_1, keypoints_1, descriptors_1 );
|
||||
extractor.compute( img_2, keypoints_2, descriptors_2 );
|
||||
|
||||
//-- Step 3: Matching descriptor vectors with a brute force matcher
|
||||
BFMatcher matcher(extractor.defaultNorm());
|
||||
std::vector< DMatch > matches;
|
||||
matcher.match( descriptors_1, descriptors_2, matches );
|
||||
|
||||
//-- Draw matches
|
||||
Mat img_matches;
|
||||
drawMatches( img_1, keypoints_1, img_2, keypoints_2, matches, img_matches );
|
||||
|
||||
//-- Show detected matches
|
||||
imshow("Matches", img_matches );
|
||||
|
||||
waitKey(0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @function readme
|
||||
*/
|
||||
void readme()
|
||||
{ std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; }
|
||||
@@ -1,63 +0,0 @@
|
||||
/**
|
||||
* @file SURF_detector
|
||||
* @brief SURF keypoint detection + keypoint drawing with OpenCV functions
|
||||
* @author A. Huaman
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <iostream>
|
||||
#include "opencv2/core/core.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/highgui/highgui.hpp"
|
||||
#include "opencv2/nonfree/features2d.hpp"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
void readme();
|
||||
|
||||
/**
|
||||
* @function main
|
||||
* @brief Main function
|
||||
*/
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
if( argc != 3 )
|
||||
{ readme(); return -1; }
|
||||
|
||||
Mat img_1 = imread( argv[1], IMREAD_GRAYSCALE );
|
||||
Mat img_2 = imread( argv[2], IMREAD_GRAYSCALE );
|
||||
|
||||
if( !img_1.data || !img_2.data )
|
||||
{ std::cout<< " --(!) Error reading images " << std::endl; return -1; }
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector
|
||||
int minHessian = 400;
|
||||
|
||||
SurfFeatureDetector detector( minHessian );
|
||||
|
||||
std::vector<KeyPoint> keypoints_1, keypoints_2;
|
||||
|
||||
detector.detect( img_1, keypoints_1 );
|
||||
detector.detect( img_2, keypoints_2 );
|
||||
|
||||
//-- Draw keypoints
|
||||
Mat img_keypoints_1; Mat img_keypoints_2;
|
||||
|
||||
drawKeypoints( img_1, keypoints_1, img_keypoints_1, Scalar::all(-1), DrawMatchesFlags::DEFAULT );
|
||||
drawKeypoints( img_2, keypoints_2, img_keypoints_2, Scalar::all(-1), DrawMatchesFlags::DEFAULT );
|
||||
|
||||
//-- Show detected (drawn) keypoints
|
||||
imshow("Keypoints 1", img_keypoints_1 );
|
||||
imshow("Keypoints 2", img_keypoints_2 );
|
||||
|
||||
waitKey(0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @function readme
|
||||
*/
|
||||
void readme()
|
||||
{ std::cout << " Usage: ./SURF_detector <img1> <img2>" << std::endl; }
|
||||
@@ -1,234 +0,0 @@
|
||||
/*
|
||||
* video_homography.cpp
|
||||
*
|
||||
* Created on: Oct 18, 2010
|
||||
* Author: erublee
|
||||
*/
|
||||
|
||||
#include "opencv2/calib3d/calib3d.hpp"
|
||||
#include "opencv2/videoio/videoio.hpp"
|
||||
#include "opencv2/highgui/highgui.hpp"
|
||||
#include "opencv2/imgproc/imgproc.hpp"
|
||||
#include "opencv2/features2d/features2d.hpp"
|
||||
#include <iostream>
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
static void help(char **av)
|
||||
{
|
||||
cout << "\nThis program demonstrated the use of features2d with the Fast corner detector and brief descriptors\n"
|
||||
<< "to track planar objects by computing their homography from the key (training) image to the query (test) image\n\n" << endl;
|
||||
cout << "usage: " << av[0] << " <video device number>\n" << endl;
|
||||
cout << "The following keys do stuff:" << endl;
|
||||
cout << " t : grabs a reference frame to match against" << endl;
|
||||
cout << " l : makes the reference frame new every frame" << endl;
|
||||
cout << " q or escape: quit" << endl;
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
void drawMatchesRelative(const vector<KeyPoint>& train, const vector<KeyPoint>& query,
|
||||
std::vector<cv::DMatch>& matches, Mat& img, const vector<unsigned char>& mask = vector<
|
||||
unsigned char> ())
|
||||
{
|
||||
for (int i = 0; i < (int)matches.size(); i++)
|
||||
{
|
||||
if (mask.empty() || mask[i])
|
||||
{
|
||||
Point2f pt_new = query[matches[i].queryIdx].pt;
|
||||
Point2f pt_old = train[matches[i].trainIdx].pt;
|
||||
|
||||
cv::line(img, pt_new, pt_old, Scalar(125, 255, 125), 1);
|
||||
cv::circle(img, pt_new, 2, Scalar(255, 0, 125), 1);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Takes a descriptor and turns it into an xy point
|
||||
void keypoints2points(const vector<KeyPoint>& in, vector<Point2f>& out)
|
||||
{
|
||||
out.clear();
|
||||
out.reserve(in.size());
|
||||
for (size_t i = 0; i < in.size(); ++i)
|
||||
{
|
||||
out.push_back(in[i].pt);
|
||||
}
|
||||
}
|
||||
|
||||
//Takes an xy point and appends that to a keypoint structure
|
||||
void points2keypoints(const vector<Point2f>& in, vector<KeyPoint>& out)
|
||||
{
|
||||
out.clear();
|
||||
out.reserve(in.size());
|
||||
for (size_t i = 0; i < in.size(); ++i)
|
||||
{
|
||||
out.push_back(KeyPoint(in[i], 1));
|
||||
}
|
||||
}
|
||||
|
||||
//Uses computed homography H to warp original input points to new planar position
|
||||
void warpKeypoints(const Mat& H, const vector<KeyPoint>& in, vector<KeyPoint>& out)
|
||||
{
|
||||
vector<Point2f> pts;
|
||||
keypoints2points(in, pts);
|
||||
vector<Point2f> pts_w(pts.size());
|
||||
Mat m_pts_w(pts_w);
|
||||
perspectiveTransform(Mat(pts), m_pts_w, H);
|
||||
points2keypoints(pts_w, out);
|
||||
}
|
||||
|
||||
//Converts matching indices to xy points
|
||||
void matches2points(const vector<KeyPoint>& train, const vector<KeyPoint>& query,
|
||||
const std::vector<cv::DMatch>& matches, std::vector<cv::Point2f>& pts_train,
|
||||
std::vector<Point2f>& pts_query)
|
||||
{
|
||||
|
||||
pts_train.clear();
|
||||
pts_query.clear();
|
||||
pts_train.reserve(matches.size());
|
||||
pts_query.reserve(matches.size());
|
||||
|
||||
size_t i = 0;
|
||||
|
||||
for (; i < matches.size(); i++)
|
||||
{
|
||||
|
||||
const DMatch & dmatch = matches[i];
|
||||
|
||||
pts_query.push_back(query[dmatch.queryIdx].pt);
|
||||
pts_train.push_back(train[dmatch.trainIdx].pt);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void resetH(Mat&H)
|
||||
{
|
||||
H = Mat::eye(3, 3, CV_32FC1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int ac, char ** av)
|
||||
{
|
||||
|
||||
if (ac != 2)
|
||||
{
|
||||
help(av);
|
||||
return 1;
|
||||
}
|
||||
|
||||
BriefDescriptorExtractor brief(32);
|
||||
|
||||
VideoCapture capture;
|
||||
capture.open(atoi(av[1]));
|
||||
if (!capture.isOpened())
|
||||
{
|
||||
help(av);
|
||||
cout << "capture device " << atoi(av[1]) << " failed to open!" << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
cout << "following keys do stuff:" << endl;
|
||||
cout << "t : grabs a reference frame to match against" << endl;
|
||||
cout << "l : makes the reference frame new every frame" << endl;
|
||||
cout << "q or escape: quit" << endl;
|
||||
|
||||
Mat frame;
|
||||
|
||||
vector<DMatch> matches;
|
||||
|
||||
BFMatcher desc_matcher(brief.defaultNorm());
|
||||
|
||||
vector<Point2f> train_pts, query_pts;
|
||||
vector<KeyPoint> train_kpts, query_kpts;
|
||||
vector<unsigned char> match_mask;
|
||||
|
||||
Mat gray;
|
||||
|
||||
bool ref_live = true;
|
||||
|
||||
Mat train_desc, query_desc;
|
||||
const int DESIRED_FTRS = 500;
|
||||
GridAdaptedFeatureDetector detector(makePtr<FastFeatureDetector>(10, true), DESIRED_FTRS, 4, 4);
|
||||
|
||||
Mat H_prev = Mat::eye(3, 3, CV_32FC1);
|
||||
for (;;)
|
||||
{
|
||||
capture >> frame;
|
||||
if (frame.empty())
|
||||
break;
|
||||
|
||||
cvtColor(frame, gray, COLOR_RGB2GRAY);
|
||||
|
||||
detector.detect(gray, query_kpts); //Find interest points
|
||||
|
||||
brief.compute(gray, query_kpts, query_desc); //Compute brief descriptors at each keypoint location
|
||||
|
||||
if (!train_kpts.empty())
|
||||
{
|
||||
|
||||
vector<KeyPoint> test_kpts;
|
||||
warpKeypoints(H_prev.inv(), query_kpts, test_kpts);
|
||||
|
||||
Mat mask = windowedMatchingMask(test_kpts, train_kpts, 25, 25);
|
||||
desc_matcher.match(query_desc, train_desc, matches, mask);
|
||||
drawKeypoints(frame, test_kpts, frame, Scalar(255, 0, 0), DrawMatchesFlags::DRAW_OVER_OUTIMG);
|
||||
|
||||
matches2points(train_kpts, query_kpts, matches, train_pts, query_pts);
|
||||
|
||||
if (matches.size() > 5)
|
||||
{
|
||||
Mat H = findHomography(train_pts, query_pts, RANSAC, 4, match_mask);
|
||||
if (countNonZero(Mat(match_mask)) > 15)
|
||||
{
|
||||
H_prev = H;
|
||||
}
|
||||
else
|
||||
resetH(H_prev);
|
||||
drawMatchesRelative(train_kpts, query_kpts, matches, frame, match_mask);
|
||||
}
|
||||
else
|
||||
resetH(H_prev);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
H_prev = Mat::eye(3, 3, CV_32FC1);
|
||||
Mat out;
|
||||
drawKeypoints(gray, query_kpts, out);
|
||||
frame = out;
|
||||
}
|
||||
|
||||
imshow("frame", frame);
|
||||
|
||||
if (ref_live)
|
||||
{
|
||||
train_kpts = query_kpts;
|
||||
query_desc.copyTo(train_desc);
|
||||
}
|
||||
char key = (char)waitKey(2);
|
||||
switch (key)
|
||||
{
|
||||
case 'l':
|
||||
ref_live = true;
|
||||
resetH(H_prev);
|
||||
break;
|
||||
case 't':
|
||||
ref_live = false;
|
||||
train_kpts = query_kpts;
|
||||
query_desc.copyTo(train_desc);
|
||||
resetH(H_prev);
|
||||
break;
|
||||
case 27:
|
||||
case 'q':
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user