mirror of
https://github.com/opencv/opencv.git
synced 2026-07-29 23:33:05 +04:00
Merge pull request #8869 from hrnr:akaze_part1
[GSOC] Speeding-up AKAZE, part #1 (#8869)
* ts: expand arguments before stringifications in CV_ENUM and CV_FLAGS
added protective macros to always force macro expansion of arguments. This allows using CV_ENUM and CV_FLAGS with macro arguments.
* feature2d: unify perf test
use the same test for all detectors/descriptors we have.
* added AKAZE tests
* features2d: extend perf tests
* add BRISK, KAZE, MSER
* run all extract tests on AKAZE keypoints, so that the test si more comparable for the speed of extraction
* feature2d: rework opencl perf tests
use the same configuration as cpu tests
* feature2d: fix descriptors allocation for AKAZE and KAZE
fix crash when descriptors are UMat
* feature2d: name enum to fix build with older gcc
* Revert "ts: expand arguments before stringifications in CV_ENUM and CV_FLAGS"
This reverts commit 19538cac1e.
This wasn't a great idea after all. There is a lot of flags implemented as #define, that we don't want to expand.
* feature2d: fix expansion problems with CV_ENUM in perf
* expand arguments before passing them to CV_ENUM. This does not need modifications of CV_ENUM.
* added include guards to `perf_feature2d.hpp`
* feature2d: fix crash in AKAZE when using KAZE descriptors
* out-of-bound access in Get_MSURF_Descriptor_64
* this happened reliably when running on provided keypoints (not computed by the same instance)
* feature2d: added regression tests for AKAZE
* test with both MLDB and KAZE keypoints
* feature2d: do not compute keypoints orientation twice
* always compute keypoints orientation, when computing keypoints
* do not recompute keypoint orientation when computing descriptors
this allows to test detection and extraction separately
* features2d: fix crash in AKAZE
* out-of-bound reads near the image edge
* same as the bug in KAZE descriptors
* feature2d: refactor invariance testing
* split detectors and descriptors tests
* rewrite to google test to simplify debugging
* add tests for AKAZE and one test for ORB
* stitching: add tests with AKAZE feature finder
* added basic stitching cpu and ocl tests
* fix bug in AKAZE wrapper for stitching pipeline causing lots of
! OPENCV warning: getUMat()/getMat() call chain possible problem.
! Base object is dead, while nested/derived object is still alive or processed.
! Please check lifetime of UMat/Mat objects!
This commit is contained in:
Jiri Horner
committed by
Alexander Alekhin
Alexander Alekhin
parent
437ca0b62a
commit
5f20e802d2
@@ -0,0 +1,192 @@
|
||||
// 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"
|
||||
#include "test_invariance_utils.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
using std::tr1::make_tuple;
|
||||
using std::tr1::get;
|
||||
using namespace testing;
|
||||
|
||||
#define SHOW_DEBUG_LOG 0
|
||||
|
||||
typedef std::tr1::tuple<std::string, Ptr<FeatureDetector>, Ptr<DescriptorExtractor>, float>
|
||||
String_FeatureDetector_DescriptorExtractor_Float_t;
|
||||
const static std::string IMAGE_TSUKUBA = "features2d/tsukuba.png";
|
||||
const static std::string IMAGE_BIKES = "detectors_descriptors_evaluation/images_datasets/bikes/img1.png";
|
||||
#define Value(...) Values(String_FeatureDetector_DescriptorExtractor_Float_t(__VA_ARGS__))
|
||||
|
||||
static
|
||||
void rotateKeyPoints(const vector<KeyPoint>& src, const Mat& H, float angle, vector<KeyPoint>& dst)
|
||||
{
|
||||
// suppose that H is rotation given from rotateImage() and angle has value passed to rotateImage()
|
||||
vector<Point2f> srcCenters, dstCenters;
|
||||
KeyPoint::convert(src, srcCenters);
|
||||
|
||||
perspectiveTransform(srcCenters, dstCenters, H);
|
||||
|
||||
dst = src;
|
||||
for(size_t i = 0; i < dst.size(); i++)
|
||||
{
|
||||
dst[i].pt = dstCenters[i];
|
||||
float dstAngle = src[i].angle + angle;
|
||||
if(dstAngle >= 360.f)
|
||||
dstAngle -= 360.f;
|
||||
dst[i].angle = dstAngle;
|
||||
}
|
||||
}
|
||||
|
||||
class DescriptorInvariance : public TestWithParam<String_FeatureDetector_DescriptorExtractor_Float_t>
|
||||
{
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
// Read test data
|
||||
const std::string filename = cvtest::TS::ptr()->get_data_path() + get<0>(GetParam());
|
||||
image0 = imread(filename);
|
||||
ASSERT_FALSE(image0.empty()) << "couldn't read input image";
|
||||
|
||||
featureDetector = get<1>(GetParam());
|
||||
descriptorExtractor = get<2>(GetParam());
|
||||
minInliersRatio = get<3>(GetParam());
|
||||
}
|
||||
|
||||
Ptr<FeatureDetector> featureDetector;
|
||||
Ptr<DescriptorExtractor> descriptorExtractor;
|
||||
float minInliersRatio;
|
||||
Mat image0;
|
||||
};
|
||||
|
||||
typedef DescriptorInvariance DescriptorScaleInvariance;
|
||||
typedef DescriptorInvariance DescriptorRotationInvariance;
|
||||
|
||||
TEST_P(DescriptorRotationInvariance, rotation)
|
||||
{
|
||||
Mat image1, mask1;
|
||||
const int borderSize = 16;
|
||||
Mat mask0(image0.size(), CV_8UC1, Scalar(0));
|
||||
mask0(Rect(borderSize, borderSize, mask0.cols - 2*borderSize, mask0.rows - 2*borderSize)).setTo(Scalar(255));
|
||||
|
||||
vector<KeyPoint> keypoints0;
|
||||
Mat descriptors0;
|
||||
featureDetector->detect(image0, keypoints0, mask0);
|
||||
std::cout << "Intial keypoints: " << keypoints0.size() << std::endl;
|
||||
EXPECT_GE(keypoints0.size(), 15u);
|
||||
descriptorExtractor->compute(image0, keypoints0, descriptors0);
|
||||
|
||||
BFMatcher bfmatcher(descriptorExtractor->defaultNorm());
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
const int maxAngle = 360, angleStep = 15;
|
||||
for(int angle = 0; angle < maxAngle; angle += angleStep)
|
||||
{
|
||||
Mat H = rotateImage(image0, mask0, static_cast<float>(angle), image1, mask1);
|
||||
|
||||
vector<KeyPoint> keypoints1;
|
||||
rotateKeyPoints(keypoints0, H, static_cast<float>(angle), keypoints1);
|
||||
Mat descriptors1;
|
||||
descriptorExtractor->compute(image1, keypoints1, descriptors1);
|
||||
|
||||
vector<DMatch> descMatches;
|
||||
bfmatcher.match(descriptors0, descriptors1, descMatches);
|
||||
|
||||
int descInliersCount = 0;
|
||||
for(size_t m = 0; m < descMatches.size(); m++)
|
||||
{
|
||||
const KeyPoint& transformed_p0 = keypoints1[descMatches[m].queryIdx];
|
||||
const KeyPoint& p1 = keypoints1[descMatches[m].trainIdx];
|
||||
if(calcIntersectRatio(transformed_p0.pt, 0.5f * transformed_p0.size,
|
||||
p1.pt, 0.5f * p1.size) >= minIntersectRatio)
|
||||
{
|
||||
descInliersCount++;
|
||||
}
|
||||
}
|
||||
|
||||
float descInliersRatio = static_cast<float>(descInliersCount) / keypoints0.size();
|
||||
EXPECT_GE(descInliersRatio, minInliersRatio);
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "angle = " << angle
|
||||
<< ", keypoints = " << keypoints1.size()
|
||||
<< ", descInliersRatio = " << static_cast<float>(descInliersCount) / keypoints0.size()
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_P(DescriptorScaleInvariance, scale)
|
||||
{
|
||||
vector<KeyPoint> keypoints0;
|
||||
featureDetector->detect(image0, keypoints0);
|
||||
EXPECT_GE(keypoints0.size(), 15u);
|
||||
Mat descriptors0;
|
||||
descriptorExtractor->compute(image0, keypoints0, descriptors0);
|
||||
|
||||
BFMatcher bfmatcher(descriptorExtractor->defaultNorm());
|
||||
for(int scaleIdx = 1; scaleIdx <= 3; scaleIdx++)
|
||||
{
|
||||
float scale = 1.f + scaleIdx * 0.5f;
|
||||
|
||||
Mat image1;
|
||||
resize(image0, image1, Size(), 1./scale, 1./scale);
|
||||
|
||||
vector<KeyPoint> keypoints1;
|
||||
scaleKeyPoints(keypoints0, keypoints1, 1.0f/scale);
|
||||
Mat descriptors1;
|
||||
descriptorExtractor->compute(image1, keypoints1, descriptors1);
|
||||
|
||||
vector<DMatch> descMatches;
|
||||
bfmatcher.match(descriptors0, descriptors1, descMatches);
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
int descInliersCount = 0;
|
||||
for(size_t m = 0; m < descMatches.size(); m++)
|
||||
{
|
||||
const KeyPoint& transformed_p0 = keypoints0[descMatches[m].queryIdx];
|
||||
const KeyPoint& p1 = keypoints0[descMatches[m].trainIdx];
|
||||
if(calcIntersectRatio(transformed_p0.pt, 0.5f * transformed_p0.size,
|
||||
p1.pt, 0.5f * p1.size) >= minIntersectRatio)
|
||||
{
|
||||
descInliersCount++;
|
||||
}
|
||||
}
|
||||
|
||||
float descInliersRatio = static_cast<float>(descInliersCount) / keypoints0.size();
|
||||
EXPECT_GE(descInliersRatio, minInliersRatio);
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "scale = " << scale
|
||||
<< ", descInliersRatio = " << static_cast<float>(descInliersCount) / keypoints0.size()
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Descriptors's rotation invariance check
|
||||
*/
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BRISK, DescriptorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, BRISK::create(), BRISK::create(), 0.99f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ORB, DescriptorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, ORB::create(), ORB::create(), 0.99f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE, DescriptorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, AKAZE::create(), AKAZE::create(), 0.99f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE_DESCRIPTOR_KAZE, DescriptorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, AKAZE::create(AKAZE::DESCRIPTOR_KAZE), AKAZE::create(AKAZE::DESCRIPTOR_KAZE), 0.002f));
|
||||
|
||||
/*
|
||||
* Descriptor's scale invariance check
|
||||
*/
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE, DescriptorScaleInvariance,
|
||||
Value(IMAGE_BIKES, AKAZE::create(), AKAZE::create(), 0.6f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE_DESCRIPTOR_KAZE, DescriptorScaleInvariance,
|
||||
Value(IMAGE_BIKES, AKAZE::create(AKAZE::DESCRIPTOR_KAZE), AKAZE::create(AKAZE::DESCRIPTOR_KAZE), 0.0004f));
|
||||
@@ -350,6 +350,14 @@ TEST( Features2d_DescriptorExtractor_AKAZE, regression )
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST( Features2d_DescriptorExtractor_AKAZE_DESCRIPTOR_KAZE, regression )
|
||||
{
|
||||
CV_DescriptorExtractorTest< L2<float> > test( "descriptor-akaze-with-kaze-desc", 0.03f,
|
||||
AKAZE::create(AKAZE::DESCRIPTOR_KAZE),
|
||||
L2<float>(), AKAZE::create(AKAZE::DESCRIPTOR_KAZE));
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST( Features2d_DescriptorExtractor, batch )
|
||||
{
|
||||
string path = string(cvtest::TS::ptr()->get_data_path() + "detectors_descriptors_evaluation/images_datasets/graf");
|
||||
|
||||
@@ -0,0 +1,255 @@
|
||||
// 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"
|
||||
#include "test_invariance_utils.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
using std::tr1::make_tuple;
|
||||
using std::tr1::get;
|
||||
using namespace testing;
|
||||
|
||||
#define SHOW_DEBUG_LOG 0
|
||||
|
||||
typedef std::tr1::tuple<std::string, Ptr<FeatureDetector>, float, float> String_FeatureDetector_Float_Float_t;
|
||||
const static std::string IMAGE_TSUKUBA = "features2d/tsukuba.png";
|
||||
const static std::string IMAGE_BIKES = "detectors_descriptors_evaluation/images_datasets/bikes/img1.png";
|
||||
#define Value(...) Values(String_FeatureDetector_Float_Float_t(__VA_ARGS__))
|
||||
|
||||
static
|
||||
void matchKeyPoints(const vector<KeyPoint>& keypoints0, const Mat& H,
|
||||
const vector<KeyPoint>& keypoints1,
|
||||
vector<DMatch>& matches)
|
||||
{
|
||||
vector<Point2f> points0;
|
||||
KeyPoint::convert(keypoints0, points0);
|
||||
Mat points0t;
|
||||
if(H.empty())
|
||||
points0t = Mat(points0);
|
||||
else
|
||||
perspectiveTransform(Mat(points0), points0t, H);
|
||||
|
||||
matches.clear();
|
||||
vector<uchar> usedMask(keypoints1.size(), 0);
|
||||
for(int i0 = 0; i0 < static_cast<int>(keypoints0.size()); i0++)
|
||||
{
|
||||
int nearestPointIndex = -1;
|
||||
float maxIntersectRatio = 0.f;
|
||||
const float r0 = 0.5f * keypoints0[i0].size;
|
||||
for(size_t i1 = 0; i1 < keypoints1.size(); i1++)
|
||||
{
|
||||
if(nearestPointIndex >= 0 && usedMask[i1])
|
||||
continue;
|
||||
|
||||
float r1 = 0.5f * keypoints1[i1].size;
|
||||
float intersectRatio = calcIntersectRatio(points0t.at<Point2f>(i0), r0,
|
||||
keypoints1[i1].pt, r1);
|
||||
if(intersectRatio > maxIntersectRatio)
|
||||
{
|
||||
maxIntersectRatio = intersectRatio;
|
||||
nearestPointIndex = static_cast<int>(i1);
|
||||
}
|
||||
}
|
||||
|
||||
matches.push_back(DMatch(i0, nearestPointIndex, maxIntersectRatio));
|
||||
if(nearestPointIndex >= 0)
|
||||
usedMask[nearestPointIndex] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
class DetectorInvariance : public TestWithParam<String_FeatureDetector_Float_Float_t>
|
||||
{
|
||||
protected:
|
||||
virtual void SetUp() {
|
||||
// Read test data
|
||||
const std::string filename = cvtest::TS::ptr()->get_data_path() + get<0>(GetParam());
|
||||
image0 = imread(filename);
|
||||
ASSERT_FALSE(image0.empty()) << "couldn't read input image";
|
||||
|
||||
featureDetector = get<1>(GetParam());
|
||||
minKeyPointMatchesRatio = get<2>(GetParam());
|
||||
minInliersRatio = get<3>(GetParam());
|
||||
}
|
||||
|
||||
Ptr<FeatureDetector> featureDetector;
|
||||
float minKeyPointMatchesRatio;
|
||||
float minInliersRatio;
|
||||
Mat image0;
|
||||
};
|
||||
|
||||
typedef DetectorInvariance DetectorScaleInvariance;
|
||||
typedef DetectorInvariance DetectorRotationInvariance;
|
||||
|
||||
TEST_P(DetectorRotationInvariance, rotation)
|
||||
{
|
||||
Mat image1, mask1;
|
||||
const int borderSize = 16;
|
||||
Mat mask0(image0.size(), CV_8UC1, Scalar(0));
|
||||
mask0(Rect(borderSize, borderSize, mask0.cols - 2*borderSize, mask0.rows - 2*borderSize)).setTo(Scalar(255));
|
||||
|
||||
vector<KeyPoint> keypoints0;
|
||||
featureDetector->detect(image0, keypoints0, mask0);
|
||||
EXPECT_GE(keypoints0.size(), 15u);
|
||||
|
||||
const int maxAngle = 360, angleStep = 15;
|
||||
for(int angle = 0; angle < maxAngle; angle += angleStep)
|
||||
{
|
||||
Mat H = rotateImage(image0, mask0, static_cast<float>(angle), image1, mask1);
|
||||
|
||||
vector<KeyPoint> keypoints1;
|
||||
featureDetector->detect(image1, keypoints1, mask1);
|
||||
|
||||
vector<DMatch> matches;
|
||||
matchKeyPoints(keypoints0, H, keypoints1, matches);
|
||||
|
||||
int angleInliersCount = 0;
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
int keyPointMatchesCount = 0;
|
||||
for(size_t m = 0; m < matches.size(); m++)
|
||||
{
|
||||
if(matches[m].distance < minIntersectRatio)
|
||||
continue;
|
||||
|
||||
keyPointMatchesCount++;
|
||||
|
||||
// Check does this inlier have consistent angles
|
||||
const float maxAngleDiff = 15.f; // grad
|
||||
float angle0 = keypoints0[matches[m].queryIdx].angle;
|
||||
float angle1 = keypoints1[matches[m].trainIdx].angle;
|
||||
ASSERT_FALSE(angle0 == -1 || angle1 == -1) << "Given FeatureDetector is not rotation invariant, it can not be tested here.";
|
||||
ASSERT_GE(angle0, 0.f);
|
||||
ASSERT_LT(angle0, 360.f);
|
||||
ASSERT_GE(angle1, 0.f);
|
||||
ASSERT_LT(angle1, 360.f);
|
||||
|
||||
float rotAngle0 = angle0 + angle;
|
||||
if(rotAngle0 >= 360.f)
|
||||
rotAngle0 -= 360.f;
|
||||
|
||||
float angleDiff = std::max(rotAngle0, angle1) - std::min(rotAngle0, angle1);
|
||||
angleDiff = std::min(angleDiff, static_cast<float>(360.f - angleDiff));
|
||||
ASSERT_GE(angleDiff, 0.f);
|
||||
bool isAngleCorrect = angleDiff < maxAngleDiff;
|
||||
if(isAngleCorrect)
|
||||
angleInliersCount++;
|
||||
}
|
||||
|
||||
float keyPointMatchesRatio = static_cast<float>(keyPointMatchesCount) / keypoints0.size();
|
||||
EXPECT_GE(keyPointMatchesRatio, minKeyPointMatchesRatio) << "angle: " << angle;
|
||||
|
||||
if(keyPointMatchesCount)
|
||||
{
|
||||
float angleInliersRatio = static_cast<float>(angleInliersCount) / keyPointMatchesCount;
|
||||
EXPECT_GE(angleInliersRatio, minInliersRatio) << "angle: " << angle;
|
||||
}
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "angle = " << angle
|
||||
<< ", keypoints = " << keypoints1.size()
|
||||
<< ", keyPointMatchesRatio = " << keyPointMatchesRatio
|
||||
<< ", angleInliersRatio = " << (keyPointMatchesCount ? (static_cast<float>(angleInliersCount) / keyPointMatchesCount) : 0)
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
TEST_P(DetectorScaleInvariance, scale)
|
||||
{
|
||||
vector<KeyPoint> keypoints0;
|
||||
featureDetector->detect(image0, keypoints0);
|
||||
EXPECT_GE(keypoints0.size(), 15u);
|
||||
|
||||
for(int scaleIdx = 1; scaleIdx <= 3; scaleIdx++)
|
||||
{
|
||||
float scale = 1.f + scaleIdx * 0.5f;
|
||||
Mat image1;
|
||||
resize(image0, image1, Size(), 1./scale, 1./scale);
|
||||
|
||||
vector<KeyPoint> keypoints1, osiKeypoints1; // osi - original size image
|
||||
featureDetector->detect(image1, keypoints1);
|
||||
EXPECT_GE(keypoints1.size(), 15u);
|
||||
EXPECT_LE(keypoints1.size(), keypoints0.size()) << "Strange behavior of the detector. "
|
||||
"It gives more points count in an image of the smaller size.";
|
||||
|
||||
scaleKeyPoints(keypoints1, osiKeypoints1, scale);
|
||||
vector<DMatch> matches;
|
||||
// image1 is query image (it's reduced image0)
|
||||
// image0 is train image
|
||||
matchKeyPoints(osiKeypoints1, Mat(), keypoints0, matches);
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
int keyPointMatchesCount = 0;
|
||||
int scaleInliersCount = 0;
|
||||
|
||||
for(size_t m = 0; m < matches.size(); m++)
|
||||
{
|
||||
if(matches[m].distance < minIntersectRatio)
|
||||
continue;
|
||||
|
||||
keyPointMatchesCount++;
|
||||
|
||||
// Check does this inlier have consistent sizes
|
||||
const float maxSizeDiff = 0.8f;//0.9f; // grad
|
||||
float size0 = keypoints0[matches[m].trainIdx].size;
|
||||
float size1 = osiKeypoints1[matches[m].queryIdx].size;
|
||||
ASSERT_GT(size0, 0);
|
||||
ASSERT_GT(size1, 0);
|
||||
if(std::min(size0, size1) > maxSizeDiff * std::max(size0, size1))
|
||||
scaleInliersCount++;
|
||||
}
|
||||
|
||||
float keyPointMatchesRatio = static_cast<float>(keyPointMatchesCount) / keypoints1.size();
|
||||
EXPECT_GE(keyPointMatchesRatio, minKeyPointMatchesRatio);
|
||||
|
||||
if(keyPointMatchesCount)
|
||||
{
|
||||
float scaleInliersRatio = static_cast<float>(scaleInliersCount) / keyPointMatchesCount;
|
||||
EXPECT_GE(scaleInliersRatio, minInliersRatio);
|
||||
}
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "scale = " << scale
|
||||
<< ", keyPointMatchesRatio = " << keyPointMatchesRatio
|
||||
<< ", scaleInliersRatio = " << (keyPointMatchesCount ? static_cast<float>(scaleInliersCount) / keyPointMatchesCount : 0)
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Detector's rotation invariance check
|
||||
*/
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BRISK, DetectorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, BRISK::create(), 0.45f, 0.76f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ORB, DetectorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, ORB::create(), 0.5f, 0.76f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE, DetectorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, AKAZE::create(), 0.5f, 0.76f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE_DESCRIPTOR_KAZE, DetectorRotationInvariance,
|
||||
Value(IMAGE_TSUKUBA, AKAZE::create(AKAZE::DESCRIPTOR_KAZE), 0.5f, 0.76f));
|
||||
|
||||
/*
|
||||
* Detector's scale invariance check
|
||||
*/
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BRISK, DetectorScaleInvariance,
|
||||
Value(IMAGE_BIKES, BRISK::create(), 0.08f, 0.49f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ORB, DetectorScaleInvariance,
|
||||
Value(IMAGE_BIKES, ORB::create(), 0.08f, 0.49f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KAZE, DetectorScaleInvariance,
|
||||
Value(IMAGE_BIKES, KAZE::create(), 0.08f, 0.49f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE, DetectorScaleInvariance,
|
||||
Value(IMAGE_BIKES, AKAZE::create(), 0.08f, 0.49f));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AKAZE_DESCRIPTOR_KAZE, DetectorScaleInvariance,
|
||||
Value(IMAGE_BIKES, AKAZE::create(AKAZE::DESCRIPTOR_KAZE), 0.08f, 0.49f));
|
||||
@@ -302,6 +302,13 @@ TEST( Features2d_Detector_AKAZE, regression )
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST( Features2d_Detector_AKAZE_DESCRIPTOR_KAZE, regression )
|
||||
{
|
||||
CV_FeatureDetectorTest test( "detector-akaze-with-kaze-desc", AKAZE::create(AKAZE::DESCRIPTOR_KAZE) );
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
|
||||
TEST( Features2d_Detector_AKAZE, detect_and_compute_split )
|
||||
{
|
||||
Mat testImg(100, 100, CV_8U);
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
// 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
|
||||
|
||||
#ifndef __OPENCV_TEST_INVARIANCE_UTILS_HPP__
|
||||
#define __OPENCV_TEST_INVARIANCE_UTILS_HPP__
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
static
|
||||
Mat generateHomography(float angle)
|
||||
{
|
||||
// angle - rotation around Oz in degrees
|
||||
float angleRadian = static_cast<float>(angle * CV_PI / 180);
|
||||
Mat H = Mat::eye(3, 3, CV_32FC1);
|
||||
H.at<float>(0,0) = H.at<float>(1,1) = std::cos(angleRadian);
|
||||
H.at<float>(0,1) = -std::sin(angleRadian);
|
||||
H.at<float>(1,0) = std::sin(angleRadian);
|
||||
|
||||
return H;
|
||||
}
|
||||
|
||||
static
|
||||
Mat rotateImage(const Mat& srcImage, const Mat& srcMask, float angle, Mat& dstImage, Mat& dstMask)
|
||||
{
|
||||
// angle - rotation around Oz in degrees
|
||||
float diag = std::sqrt(static_cast<float>(srcImage.cols * srcImage.cols + srcImage.rows * srcImage.rows));
|
||||
Mat LUShift = Mat::eye(3, 3, CV_32FC1); // left up
|
||||
LUShift.at<float>(0,2) = static_cast<float>(-srcImage.cols/2);
|
||||
LUShift.at<float>(1,2) = static_cast<float>(-srcImage.rows/2);
|
||||
Mat RDShift = Mat::eye(3, 3, CV_32FC1); // right down
|
||||
RDShift.at<float>(0,2) = diag/2;
|
||||
RDShift.at<float>(1,2) = diag/2;
|
||||
Size sz(cvRound(diag), cvRound(diag));
|
||||
|
||||
Mat H = RDShift * generateHomography(angle) * LUShift;
|
||||
warpPerspective(srcImage, dstImage, H, sz);
|
||||
warpPerspective(srcMask, dstMask, H, sz);
|
||||
|
||||
return H;
|
||||
}
|
||||
|
||||
static
|
||||
float calcCirclesIntersectArea(const Point2f& p0, float r0, const Point2f& p1, float r1)
|
||||
{
|
||||
float c = static_cast<float>(norm(p0 - p1)), sqr_c = c * c;
|
||||
|
||||
float sqr_r0 = r0 * r0;
|
||||
float sqr_r1 = r1 * r1;
|
||||
|
||||
if(r0 + r1 <= c)
|
||||
return 0;
|
||||
|
||||
float minR = std::min(r0, r1);
|
||||
float maxR = std::max(r0, r1);
|
||||
if(c + minR <= maxR)
|
||||
return static_cast<float>(CV_PI * minR * minR);
|
||||
|
||||
float cos_halfA0 = (sqr_r0 + sqr_c - sqr_r1) / (2 * r0 * c);
|
||||
float cos_halfA1 = (sqr_r1 + sqr_c - sqr_r0) / (2 * r1 * c);
|
||||
|
||||
float A0 = 2 * acos(cos_halfA0);
|
||||
float A1 = 2 * acos(cos_halfA1);
|
||||
|
||||
return 0.5f * sqr_r0 * (A0 - sin(A0)) +
|
||||
0.5f * sqr_r1 * (A1 - sin(A1));
|
||||
}
|
||||
|
||||
static
|
||||
float calcIntersectRatio(const Point2f& p0, float r0, const Point2f& p1, float r1)
|
||||
{
|
||||
float intersectArea = calcCirclesIntersectArea(p0, r0, p1, r1);
|
||||
float unionArea = static_cast<float>(CV_PI) * (r0 * r0 + r1 * r1) - intersectArea;
|
||||
return intersectArea / unionArea;
|
||||
}
|
||||
|
||||
static
|
||||
void scaleKeyPoints(const vector<KeyPoint>& src, vector<KeyPoint>& dst, float scale)
|
||||
{
|
||||
dst.resize(src.size());
|
||||
for (size_t i = 0; i < src.size(); i++) {
|
||||
dst[i] = src[i];
|
||||
dst[i].pt.x *= scale;
|
||||
dst[i].pt.y *= scale;
|
||||
dst[i].size *= scale;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // __OPENCV_TEST_INVARIANCE_UTILS_HPP__
|
||||
@@ -1,717 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
const string IMAGE_TSUKUBA = "/features2d/tsukuba.png";
|
||||
const string IMAGE_BIKES = "/detectors_descriptors_evaluation/images_datasets/bikes/img1.png";
|
||||
|
||||
#define SHOW_DEBUG_LOG 1
|
||||
|
||||
static
|
||||
Mat generateHomography(float angle)
|
||||
{
|
||||
// angle - rotation around Oz in degrees
|
||||
float angleRadian = static_cast<float>(angle * CV_PI / 180);
|
||||
Mat H = Mat::eye(3, 3, CV_32FC1);
|
||||
H.at<float>(0,0) = H.at<float>(1,1) = std::cos(angleRadian);
|
||||
H.at<float>(0,1) = -std::sin(angleRadian);
|
||||
H.at<float>(1,0) = std::sin(angleRadian);
|
||||
|
||||
return H;
|
||||
}
|
||||
|
||||
static
|
||||
Mat rotateImage(const Mat& srcImage, const Mat& srcMask, float angle, Mat& dstImage, Mat& dstMask)
|
||||
{
|
||||
// angle - rotation around Oz in degrees
|
||||
float diag = std::sqrt(static_cast<float>(srcImage.cols * srcImage.cols + srcImage.rows * srcImage.rows));
|
||||
Mat LUShift = Mat::eye(3, 3, CV_32FC1); // left up
|
||||
LUShift.at<float>(0,2) = static_cast<float>(-srcImage.cols/2);
|
||||
LUShift.at<float>(1,2) = static_cast<float>(-srcImage.rows/2);
|
||||
Mat RDShift = Mat::eye(3, 3, CV_32FC1); // right down
|
||||
RDShift.at<float>(0,2) = diag/2;
|
||||
RDShift.at<float>(1,2) = diag/2;
|
||||
Size sz(cvRound(diag), cvRound(diag));
|
||||
|
||||
Mat H = RDShift * generateHomography(angle) * LUShift;
|
||||
warpPerspective(srcImage, dstImage, H, sz);
|
||||
warpPerspective(srcMask, dstMask, H, sz);
|
||||
|
||||
return H;
|
||||
}
|
||||
|
||||
void rotateKeyPoints(const vector<KeyPoint>& src, const Mat& H, float angle, vector<KeyPoint>& dst)
|
||||
{
|
||||
// suppose that H is rotation given from rotateImage() and angle has value passed to rotateImage()
|
||||
vector<Point2f> srcCenters, dstCenters;
|
||||
KeyPoint::convert(src, srcCenters);
|
||||
|
||||
perspectiveTransform(srcCenters, dstCenters, H);
|
||||
|
||||
dst = src;
|
||||
for(size_t i = 0; i < dst.size(); i++)
|
||||
{
|
||||
dst[i].pt = dstCenters[i];
|
||||
float dstAngle = src[i].angle + angle;
|
||||
if(dstAngle >= 360.f)
|
||||
dstAngle -= 360.f;
|
||||
dst[i].angle = dstAngle;
|
||||
}
|
||||
}
|
||||
|
||||
void scaleKeyPoints(const vector<KeyPoint>& src, vector<KeyPoint>& dst, float scale)
|
||||
{
|
||||
dst.resize(src.size());
|
||||
for(size_t i = 0; i < src.size(); i++)
|
||||
dst[i] = KeyPoint(src[i].pt.x * scale, src[i].pt.y * scale, src[i].size * scale, src[i].angle);
|
||||
}
|
||||
|
||||
static
|
||||
float calcCirclesIntersectArea(const Point2f& p0, float r0, const Point2f& p1, float r1)
|
||||
{
|
||||
float c = static_cast<float>(norm(p0 - p1)), sqr_c = c * c;
|
||||
|
||||
float sqr_r0 = r0 * r0;
|
||||
float sqr_r1 = r1 * r1;
|
||||
|
||||
if(r0 + r1 <= c)
|
||||
return 0;
|
||||
|
||||
float minR = std::min(r0, r1);
|
||||
float maxR = std::max(r0, r1);
|
||||
if(c + minR <= maxR)
|
||||
return static_cast<float>(CV_PI * minR * minR);
|
||||
|
||||
float cos_halfA0 = (sqr_r0 + sqr_c - sqr_r1) / (2 * r0 * c);
|
||||
float cos_halfA1 = (sqr_r1 + sqr_c - sqr_r0) / (2 * r1 * c);
|
||||
|
||||
float A0 = 2 * acos(cos_halfA0);
|
||||
float A1 = 2 * acos(cos_halfA1);
|
||||
|
||||
return 0.5f * sqr_r0 * (A0 - sin(A0)) +
|
||||
0.5f * sqr_r1 * (A1 - sin(A1));
|
||||
}
|
||||
|
||||
static
|
||||
float calcIntersectRatio(const Point2f& p0, float r0, const Point2f& p1, float r1)
|
||||
{
|
||||
float intersectArea = calcCirclesIntersectArea(p0, r0, p1, r1);
|
||||
float unionArea = static_cast<float>(CV_PI) * (r0 * r0 + r1 * r1) - intersectArea;
|
||||
return intersectArea / unionArea;
|
||||
}
|
||||
|
||||
static
|
||||
void matchKeyPoints(const vector<KeyPoint>& keypoints0, const Mat& H,
|
||||
const vector<KeyPoint>& keypoints1,
|
||||
vector<DMatch>& matches)
|
||||
{
|
||||
vector<Point2f> points0;
|
||||
KeyPoint::convert(keypoints0, points0);
|
||||
Mat points0t;
|
||||
if(H.empty())
|
||||
points0t = Mat(points0);
|
||||
else
|
||||
perspectiveTransform(Mat(points0), points0t, H);
|
||||
|
||||
matches.clear();
|
||||
vector<uchar> usedMask(keypoints1.size(), 0);
|
||||
for(int i0 = 0; i0 < static_cast<int>(keypoints0.size()); i0++)
|
||||
{
|
||||
int nearestPointIndex = -1;
|
||||
float maxIntersectRatio = 0.f;
|
||||
const float r0 = 0.5f * keypoints0[i0].size;
|
||||
for(size_t i1 = 0; i1 < keypoints1.size(); i1++)
|
||||
{
|
||||
if(nearestPointIndex >= 0 && usedMask[i1])
|
||||
continue;
|
||||
|
||||
float r1 = 0.5f * keypoints1[i1].size;
|
||||
float intersectRatio = calcIntersectRatio(points0t.at<Point2f>(i0), r0,
|
||||
keypoints1[i1].pt, r1);
|
||||
if(intersectRatio > maxIntersectRatio)
|
||||
{
|
||||
maxIntersectRatio = intersectRatio;
|
||||
nearestPointIndex = static_cast<int>(i1);
|
||||
}
|
||||
}
|
||||
|
||||
matches.push_back(DMatch(i0, nearestPointIndex, maxIntersectRatio));
|
||||
if(nearestPointIndex >= 0)
|
||||
usedMask[nearestPointIndex] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
class DetectorRotationInvarianceTest : public cvtest::BaseTest
|
||||
{
|
||||
public:
|
||||
DetectorRotationInvarianceTest(const Ptr<FeatureDetector>& _featureDetector,
|
||||
float _minKeyPointMatchesRatio,
|
||||
float _minAngleInliersRatio) :
|
||||
featureDetector(_featureDetector),
|
||||
minKeyPointMatchesRatio(_minKeyPointMatchesRatio),
|
||||
minAngleInliersRatio(_minAngleInliersRatio)
|
||||
{
|
||||
CV_Assert(featureDetector);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
void run(int)
|
||||
{
|
||||
const string imageFilename = string(ts->get_data_path()) + IMAGE_TSUKUBA;
|
||||
|
||||
// Read test data
|
||||
Mat image0 = imread(imageFilename), image1, mask1;
|
||||
if(image0.empty())
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Image %s can not be read.\n", imageFilename.c_str());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
|
||||
return;
|
||||
}
|
||||
std::cout << "Image: " << image0.size() << std::endl;
|
||||
|
||||
const int borderSize = 16;
|
||||
Mat mask0(image0.size(), CV_8UC1, Scalar(0));
|
||||
mask0(Rect(borderSize, borderSize, mask0.cols - 2*borderSize, mask0.rows - 2*borderSize)).setTo(Scalar(255));
|
||||
|
||||
vector<KeyPoint> keypoints0;
|
||||
featureDetector->detect(image0, keypoints0, mask0);
|
||||
std::cout << "Intial keypoints: " << keypoints0.size() << std::endl;
|
||||
if(keypoints0.size() < 15)
|
||||
CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
|
||||
|
||||
const int maxAngle = 360, angleStep = 15;
|
||||
for(int angle = 0; angle < maxAngle; angle += angleStep)
|
||||
{
|
||||
Mat H = rotateImage(image0, mask0, static_cast<float>(angle), image1, mask1);
|
||||
|
||||
vector<KeyPoint> keypoints1;
|
||||
featureDetector->detect(image1, keypoints1, mask1);
|
||||
|
||||
vector<DMatch> matches;
|
||||
matchKeyPoints(keypoints0, H, keypoints1, matches);
|
||||
|
||||
int angleInliersCount = 0;
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
int keyPointMatchesCount = 0;
|
||||
for(size_t m = 0; m < matches.size(); m++)
|
||||
{
|
||||
if(matches[m].distance < minIntersectRatio)
|
||||
continue;
|
||||
|
||||
keyPointMatchesCount++;
|
||||
|
||||
// Check does this inlier have consistent angles
|
||||
const float maxAngleDiff = 15.f; // grad
|
||||
float angle0 = keypoints0[matches[m].queryIdx].angle;
|
||||
float angle1 = keypoints1[matches[m].trainIdx].angle;
|
||||
if(angle0 == -1 || angle1 == -1)
|
||||
CV_Error(Error::StsBadArg, "Given FeatureDetector is not rotation invariant, it can not be tested here.\n");
|
||||
CV_Assert(angle0 >= 0.f && angle0 < 360.f);
|
||||
CV_Assert(angle1 >= 0.f && angle1 < 360.f);
|
||||
|
||||
float rotAngle0 = angle0 + angle;
|
||||
if(rotAngle0 >= 360.f)
|
||||
rotAngle0 -= 360.f;
|
||||
|
||||
float angleDiff = std::max(rotAngle0, angle1) - std::min(rotAngle0, angle1);
|
||||
angleDiff = std::min(angleDiff, static_cast<float>(360.f - angleDiff));
|
||||
CV_Assert(angleDiff >= 0.f);
|
||||
bool isAngleCorrect = angleDiff < maxAngleDiff;
|
||||
if(isAngleCorrect)
|
||||
angleInliersCount++;
|
||||
}
|
||||
|
||||
float keyPointMatchesRatio = static_cast<float>(keyPointMatchesCount) / keypoints0.size();
|
||||
if(keyPointMatchesRatio < minKeyPointMatchesRatio)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Angle: %f: Incorrect keyPointMatchesRatio: curr = %f, min = %f (matched=%d total=%d - %d).\n",
|
||||
(float)angle, keyPointMatchesRatio, minKeyPointMatchesRatio, (int)keyPointMatchesCount, (int)keypoints0.size(), (int)keypoints1.size());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
|
||||
}
|
||||
|
||||
if(keyPointMatchesCount)
|
||||
{
|
||||
float angleInliersRatio = static_cast<float>(angleInliersCount) / keyPointMatchesCount;
|
||||
if(angleInliersRatio < minAngleInliersRatio)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Angle: %f: Incorrect angleInliersRatio: curr = %f, min = %f.\n",
|
||||
(float)angle, angleInliersRatio, minAngleInliersRatio);
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
|
||||
}
|
||||
}
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "angle = " << angle
|
||||
<< ", keypoints = " << keypoints1.size()
|
||||
<< ", keyPointMatchesRatio = " << keyPointMatchesRatio
|
||||
<< ", angleInliersRatio = " << (keyPointMatchesCount ? (static_cast<float>(angleInliersCount) / keyPointMatchesCount) : 0)
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
ts->set_failed_test_info( cvtest::TS::OK );
|
||||
}
|
||||
|
||||
Ptr<FeatureDetector> featureDetector;
|
||||
float minKeyPointMatchesRatio;
|
||||
float minAngleInliersRatio;
|
||||
};
|
||||
|
||||
class DescriptorRotationInvarianceTest : public cvtest::BaseTest
|
||||
{
|
||||
public:
|
||||
DescriptorRotationInvarianceTest(const Ptr<FeatureDetector>& _featureDetector,
|
||||
const Ptr<DescriptorExtractor>& _descriptorExtractor,
|
||||
int _normType,
|
||||
float _minDescInliersRatio) :
|
||||
featureDetector(_featureDetector),
|
||||
descriptorExtractor(_descriptorExtractor),
|
||||
normType(_normType),
|
||||
minDescInliersRatio(_minDescInliersRatio)
|
||||
{
|
||||
CV_Assert(featureDetector);
|
||||
CV_Assert(descriptorExtractor);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
void run(int)
|
||||
{
|
||||
const string imageFilename = string(ts->get_data_path()) + IMAGE_TSUKUBA;
|
||||
|
||||
// Read test data
|
||||
Mat image0 = imread(imageFilename), image1, mask1;
|
||||
if(image0.empty())
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Image %s can not be read.\n", imageFilename.c_str());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
|
||||
return;
|
||||
}
|
||||
std::cout << "Image: " << image0.size() << std::endl;
|
||||
|
||||
const int borderSize = 16;
|
||||
Mat mask0(image0.size(), CV_8UC1, Scalar(0));
|
||||
mask0(Rect(borderSize, borderSize, mask0.cols - 2*borderSize, mask0.rows - 2*borderSize)).setTo(Scalar(255));
|
||||
|
||||
vector<KeyPoint> keypoints0;
|
||||
Mat descriptors0;
|
||||
featureDetector->detect(image0, keypoints0, mask0);
|
||||
std::cout << "Intial keypoints: " << keypoints0.size() << std::endl;
|
||||
if(keypoints0.size() < 15)
|
||||
CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
|
||||
descriptorExtractor->compute(image0, keypoints0, descriptors0);
|
||||
|
||||
BFMatcher bfmatcher(normType);
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
const int maxAngle = 360, angleStep = 15;
|
||||
for(int angle = 0; angle < maxAngle; angle += angleStep)
|
||||
{
|
||||
Mat H = rotateImage(image0, mask0, static_cast<float>(angle), image1, mask1);
|
||||
|
||||
vector<KeyPoint> keypoints1;
|
||||
rotateKeyPoints(keypoints0, H, static_cast<float>(angle), keypoints1);
|
||||
Mat descriptors1;
|
||||
descriptorExtractor->compute(image1, keypoints1, descriptors1);
|
||||
|
||||
vector<DMatch> descMatches;
|
||||
bfmatcher.match(descriptors0, descriptors1, descMatches);
|
||||
|
||||
int descInliersCount = 0;
|
||||
for(size_t m = 0; m < descMatches.size(); m++)
|
||||
{
|
||||
const KeyPoint& transformed_p0 = keypoints1[descMatches[m].queryIdx];
|
||||
const KeyPoint& p1 = keypoints1[descMatches[m].trainIdx];
|
||||
if(calcIntersectRatio(transformed_p0.pt, 0.5f * transformed_p0.size,
|
||||
p1.pt, 0.5f * p1.size) >= minIntersectRatio)
|
||||
{
|
||||
descInliersCount++;
|
||||
}
|
||||
}
|
||||
|
||||
float descInliersRatio = static_cast<float>(descInliersCount) / keypoints0.size();
|
||||
if(descInliersRatio < minDescInliersRatio)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Incorrect descInliersRatio: curr = %f, min = %f.\n",
|
||||
descInliersRatio, minDescInliersRatio);
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
|
||||
return;
|
||||
}
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "angle = " << angle
|
||||
<< ", keypoints = " << keypoints1.size()
|
||||
<< ", descInliersRatio = " << static_cast<float>(descInliersCount) / keypoints0.size()
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
ts->set_failed_test_info( cvtest::TS::OK );
|
||||
}
|
||||
|
||||
Ptr<FeatureDetector> featureDetector;
|
||||
Ptr<DescriptorExtractor> descriptorExtractor;
|
||||
int normType;
|
||||
float minDescInliersRatio;
|
||||
};
|
||||
|
||||
class DetectorScaleInvarianceTest : public cvtest::BaseTest
|
||||
{
|
||||
public:
|
||||
DetectorScaleInvarianceTest(const Ptr<FeatureDetector>& _featureDetector,
|
||||
float _minKeyPointMatchesRatio,
|
||||
float _minScaleInliersRatio) :
|
||||
featureDetector(_featureDetector),
|
||||
minKeyPointMatchesRatio(_minKeyPointMatchesRatio),
|
||||
minScaleInliersRatio(_minScaleInliersRatio)
|
||||
{
|
||||
CV_Assert(featureDetector);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
void run(int)
|
||||
{
|
||||
const string imageFilename = string(ts->get_data_path()) + IMAGE_BIKES;
|
||||
|
||||
// Read test data
|
||||
Mat image0 = imread(imageFilename);
|
||||
if(image0.empty())
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Image %s can not be read.\n", imageFilename.c_str());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
|
||||
return;
|
||||
}
|
||||
|
||||
vector<KeyPoint> keypoints0;
|
||||
featureDetector->detect(image0, keypoints0);
|
||||
if(keypoints0.size() < 15)
|
||||
CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
|
||||
|
||||
for(int scaleIdx = 1; scaleIdx <= 3; scaleIdx++)
|
||||
{
|
||||
float scale = 1.f + scaleIdx * 0.5f;
|
||||
Mat image1;
|
||||
resize(image0, image1, Size(), 1./scale, 1./scale);
|
||||
|
||||
vector<KeyPoint> keypoints1, osiKeypoints1; // osi - original size image
|
||||
featureDetector->detect(image1, keypoints1);
|
||||
if(keypoints1.size() < 15)
|
||||
CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
|
||||
|
||||
if(keypoints1.size() > keypoints0.size())
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Strange behavior of the detector. "
|
||||
"It gives more points count in an image of the smaller size.\n"
|
||||
"original size (%d, %d), keypoints count = %d\n"
|
||||
"reduced size (%d, %d), keypoints count = %d\n",
|
||||
image0.cols, image0.rows, keypoints0.size(),
|
||||
image1.cols, image1.rows, keypoints1.size());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
|
||||
return;
|
||||
}
|
||||
|
||||
scaleKeyPoints(keypoints1, osiKeypoints1, scale);
|
||||
|
||||
vector<DMatch> matches;
|
||||
// image1 is query image (it's reduced image0)
|
||||
// image0 is train image
|
||||
matchKeyPoints(osiKeypoints1, Mat(), keypoints0, matches);
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
int keyPointMatchesCount = 0;
|
||||
int scaleInliersCount = 0;
|
||||
|
||||
for(size_t m = 0; m < matches.size(); m++)
|
||||
{
|
||||
if(matches[m].distance < minIntersectRatio)
|
||||
continue;
|
||||
|
||||
keyPointMatchesCount++;
|
||||
|
||||
// Check does this inlier have consistent sizes
|
||||
const float maxSizeDiff = 0.8f;//0.9f; // grad
|
||||
float size0 = keypoints0[matches[m].trainIdx].size;
|
||||
float size1 = osiKeypoints1[matches[m].queryIdx].size;
|
||||
CV_Assert(size0 > 0 && size1 > 0);
|
||||
if(std::min(size0, size1) > maxSizeDiff * std::max(size0, size1))
|
||||
scaleInliersCount++;
|
||||
}
|
||||
|
||||
float keyPointMatchesRatio = static_cast<float>(keyPointMatchesCount) / keypoints1.size();
|
||||
if(keyPointMatchesRatio < minKeyPointMatchesRatio)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Incorrect keyPointMatchesRatio: curr = %f, min = %f.\n",
|
||||
keyPointMatchesRatio, minKeyPointMatchesRatio);
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
|
||||
return;
|
||||
}
|
||||
|
||||
if(keyPointMatchesCount)
|
||||
{
|
||||
float scaleInliersRatio = static_cast<float>(scaleInliersCount) / keyPointMatchesCount;
|
||||
if(scaleInliersRatio < minScaleInliersRatio)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Incorrect scaleInliersRatio: curr = %f, min = %f.\n",
|
||||
scaleInliersRatio, minScaleInliersRatio);
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
|
||||
return;
|
||||
}
|
||||
}
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "scale = " << scale
|
||||
<< ", keyPointMatchesRatio = " << keyPointMatchesRatio
|
||||
<< ", scaleInliersRatio = " << (keyPointMatchesCount ? static_cast<float>(scaleInliersCount) / keyPointMatchesCount : 0)
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
ts->set_failed_test_info( cvtest::TS::OK );
|
||||
}
|
||||
|
||||
Ptr<FeatureDetector> featureDetector;
|
||||
float minKeyPointMatchesRatio;
|
||||
float minScaleInliersRatio;
|
||||
};
|
||||
|
||||
class DescriptorScaleInvarianceTest : public cvtest::BaseTest
|
||||
{
|
||||
public:
|
||||
DescriptorScaleInvarianceTest(const Ptr<FeatureDetector>& _featureDetector,
|
||||
const Ptr<DescriptorExtractor>& _descriptorExtractor,
|
||||
int _normType,
|
||||
float _minDescInliersRatio) :
|
||||
featureDetector(_featureDetector),
|
||||
descriptorExtractor(_descriptorExtractor),
|
||||
normType(_normType),
|
||||
minDescInliersRatio(_minDescInliersRatio)
|
||||
{
|
||||
CV_Assert(featureDetector);
|
||||
CV_Assert(descriptorExtractor);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
void run(int)
|
||||
{
|
||||
const string imageFilename = string(ts->get_data_path()) + IMAGE_BIKES;
|
||||
|
||||
// Read test data
|
||||
Mat image0 = imread(imageFilename);
|
||||
if(image0.empty())
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Image %s can not be read.\n", imageFilename.c_str());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
|
||||
return;
|
||||
}
|
||||
|
||||
vector<KeyPoint> keypoints0;
|
||||
featureDetector->detect(image0, keypoints0);
|
||||
if(keypoints0.size() < 15)
|
||||
CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
|
||||
Mat descriptors0;
|
||||
descriptorExtractor->compute(image0, keypoints0, descriptors0);
|
||||
|
||||
BFMatcher bfmatcher(normType);
|
||||
for(int scaleIdx = 1; scaleIdx <= 3; scaleIdx++)
|
||||
{
|
||||
float scale = 1.f + scaleIdx * 0.5f;
|
||||
|
||||
Mat image1;
|
||||
resize(image0, image1, Size(), 1./scale, 1./scale);
|
||||
|
||||
vector<KeyPoint> keypoints1;
|
||||
scaleKeyPoints(keypoints0, keypoints1, 1.0f/scale);
|
||||
Mat descriptors1;
|
||||
descriptorExtractor->compute(image1, keypoints1, descriptors1);
|
||||
|
||||
vector<DMatch> descMatches;
|
||||
bfmatcher.match(descriptors0, descriptors1, descMatches);
|
||||
|
||||
const float minIntersectRatio = 0.5f;
|
||||
int descInliersCount = 0;
|
||||
for(size_t m = 0; m < descMatches.size(); m++)
|
||||
{
|
||||
const KeyPoint& transformed_p0 = keypoints0[descMatches[m].queryIdx];
|
||||
const KeyPoint& p1 = keypoints0[descMatches[m].trainIdx];
|
||||
if(calcIntersectRatio(transformed_p0.pt, 0.5f * transformed_p0.size,
|
||||
p1.pt, 0.5f * p1.size) >= minIntersectRatio)
|
||||
{
|
||||
descInliersCount++;
|
||||
}
|
||||
}
|
||||
|
||||
float descInliersRatio = static_cast<float>(descInliersCount) / keypoints0.size();
|
||||
if(descInliersRatio < minDescInliersRatio)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "Incorrect descInliersRatio: curr = %f, min = %f.\n",
|
||||
descInliersRatio, minDescInliersRatio);
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
|
||||
return;
|
||||
}
|
||||
#if SHOW_DEBUG_LOG
|
||||
std::cout
|
||||
<< "scale = " << scale
|
||||
<< ", descInliersRatio = " << static_cast<float>(descInliersCount) / keypoints0.size()
|
||||
<< std::endl;
|
||||
#endif
|
||||
}
|
||||
ts->set_failed_test_info( cvtest::TS::OK );
|
||||
}
|
||||
|
||||
Ptr<FeatureDetector> featureDetector;
|
||||
Ptr<DescriptorExtractor> descriptorExtractor;
|
||||
int normType;
|
||||
float minKeyPointMatchesRatio;
|
||||
float minDescInliersRatio;
|
||||
};
|
||||
|
||||
// Tests registration
|
||||
|
||||
/*
|
||||
* Detector's rotation invariance check
|
||||
*/
|
||||
|
||||
TEST(Features2d_RotationInvariance_Detector_BRISK, regression)
|
||||
{
|
||||
DetectorRotationInvarianceTest test(BRISK::create(),
|
||||
0.45f,
|
||||
0.76f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST(Features2d_RotationInvariance_Detector_ORB, regression)
|
||||
{
|
||||
DetectorRotationInvarianceTest test(ORB::create(),
|
||||
0.5f,
|
||||
0.76f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
/*
|
||||
* Descriptors's rotation invariance check
|
||||
*/
|
||||
|
||||
TEST(Features2d_RotationInvariance_Descriptor_BRISK, regression)
|
||||
{
|
||||
Ptr<Feature2D> f2d = BRISK::create();
|
||||
DescriptorRotationInvarianceTest test(f2d, f2d, f2d->defaultNorm(), 0.99f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST(Features2d_RotationInvariance_Descriptor_ORB, regression)
|
||||
{
|
||||
Ptr<Feature2D> f2d = ORB::create();
|
||||
DescriptorRotationInvarianceTest test(f2d, f2d, f2d->defaultNorm(), 0.99f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
//TEST(Features2d_RotationInvariance_Descriptor_FREAK, regression)
|
||||
//{
|
||||
// DescriptorRotationInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.ORB"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.FREAK"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.FREAK")->defaultNorm(),
|
||||
// 0.f);
|
||||
// test.safe_run();
|
||||
//}
|
||||
|
||||
/*
|
||||
* Detector's scale invariance check
|
||||
*/
|
||||
|
||||
TEST(Features2d_ScaleInvariance_Detector_BRISK, regression)
|
||||
{
|
||||
DetectorScaleInvarianceTest test(BRISK::create(), 0.08f, 0.49f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST(Features2d_ScaleInvariance_Detector_KAZE, regression)
|
||||
{
|
||||
DetectorScaleInvarianceTest test(KAZE::create(), 0.08f, 0.49f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST(Features2d_ScaleInvariance_Detector_AKAZE, regression)
|
||||
{
|
||||
DetectorScaleInvarianceTest test(AKAZE::create(), 0.08f, 0.49f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
TEST(Features2d_ScaleInvariance_Detector_ORB, regression)
|
||||
{
|
||||
DetectorScaleInvarianceTest test(ORB::create(), 0.08f, 0.49f);
|
||||
test.safe_run();
|
||||
}
|
||||
|
||||
/*
|
||||
* Descriptor's scale invariance check
|
||||
*/
|
||||
|
||||
//TEST(Features2d_ScaleInvariance_Descriptor_BRISK, regression)
|
||||
//{
|
||||
// DescriptorScaleInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.BRISK"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.BRISK"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.BRISK")->defaultNorm(),
|
||||
// 0.99f);
|
||||
// test.safe_run();
|
||||
//}
|
||||
|
||||
//TEST(Features2d_ScaleInvariance_Descriptor_ORB, regression)
|
||||
//{
|
||||
// DescriptorScaleInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.ORB"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.ORB"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.ORB")->defaultNorm(),
|
||||
// 0.01f);
|
||||
// test.safe_run();
|
||||
//}
|
||||
|
||||
//TEST(Features2d_ScaleInvariance_Descriptor_FREAK, regression)
|
||||
//{
|
||||
// DescriptorScaleInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.ORB"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.FREAK"),
|
||||
// Algorithm::create<DescriptorExtractor>("Feature2D.FREAK")->defaultNorm(),
|
||||
// 0.01f);
|
||||
// test.safe_run();
|
||||
//}
|
||||
Reference in New Issue
Block a user