mirror of https://github.com/opencv/opencv.git
Alexander Alekhin
4 years ago
commit
fa25faa2d2
52 changed files with 1498 additions and 319 deletions
@ -0,0 +1,2 @@ |
|||||||
|
// This file is needed for compilation on some platforms e.g. with XCode generator
|
||||||
|
// Related issue: https://gitlab.kitware.com/cmake/cmake/-/issues/17457
|
||||||
@ -0,0 +1,2 @@ |
|||||||
|
// This file is needed for compilation on some platforms e.g. with XCode generator
|
||||||
|
// Related issue: https://gitlab.kitware.com/cmake/cmake/-/issues/17457
|
||||||
|
Before Width: | Height: | Size: 4.4 KiB After Width: | Height: | Size: 5.2 KiB |
|
Before Width: | Height: | Size: 1.4 KiB After Width: | Height: | Size: 2.1 KiB |
|
Before Width: | Height: | Size: 7.9 KiB After Width: | Height: | Size: 9.5 KiB |
|
Before Width: | Height: | Size: 17 KiB After Width: | Height: | Size: 36 KiB |
|
Before Width: | Height: | Size: 24 KiB After Width: | Height: | Size: 42 KiB |
|
Before Width: | Height: | Size: 4.7 KiB After Width: | Height: | Size: 4.2 KiB |
|
Before Width: | Height: | Size: 4.4 KiB After Width: | Height: | Size: 5.2 KiB |
@ -0,0 +1,358 @@ |
|||||||
|
// 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 file is based on code issued with the following license.
|
||||||
|
/*********************************************************************
|
||||||
|
* Software License Agreement (BSD License) |
||||||
|
* |
||||||
|
* Copyright (C) 2000-2008, Intel Corporation, all rights reserved. |
||||||
|
* Copyright (C) 2008-2013, Willow Garage Inc., all rights reserved. |
||||||
|
* Copyright (C) 2013, Evgeny Toropov, 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: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions 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 the copyright holders 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 |
||||||
|
* COPYRIGHT OWNER 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. |
||||||
|
*********************************************************************/ |
||||||
|
|
||||||
|
/*
|
||||||
|
Guoshen Yu, Jean-Michel Morel, ASIFT: An Algorithm for Fully Affine |
||||||
|
Invariant Comparison, Image Processing On Line, 1 (2011), pp. 11–38. |
||||||
|
https://doi.org/10.5201/ipol.2011.my-asift
|
||||||
|
*/ |
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
#include <iostream> |
||||||
|
namespace cv { |
||||||
|
|
||||||
|
class AffineFeature_Impl CV_FINAL : public AffineFeature |
||||||
|
{ |
||||||
|
public: |
||||||
|
explicit AffineFeature_Impl(const Ptr<Feature2D>& backend, |
||||||
|
int maxTilt, int minTilt, float tiltStep, float rotateStepBase); |
||||||
|
|
||||||
|
int descriptorSize() const CV_OVERRIDE |
||||||
|
{ |
||||||
|
return backend_->descriptorSize(); |
||||||
|
} |
||||||
|
|
||||||
|
int descriptorType() const CV_OVERRIDE |
||||||
|
{ |
||||||
|
return backend_->descriptorType(); |
||||||
|
} |
||||||
|
|
||||||
|
int defaultNorm() const CV_OVERRIDE |
||||||
|
{ |
||||||
|
return backend_->defaultNorm(); |
||||||
|
} |
||||||
|
|
||||||
|
void detectAndCompute(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints, |
||||||
|
OutputArray descriptors, bool useProvidedKeypoints=false) CV_OVERRIDE; |
||||||
|
|
||||||
|
void setViewParams(const std::vector<float>& tilts, const std::vector<float>& rolls) CV_OVERRIDE; |
||||||
|
void getViewParams(std::vector<float>& tilts, std::vector<float>& rolls) const CV_OVERRIDE; |
||||||
|
|
||||||
|
protected: |
||||||
|
void splitKeypointsByView(const std::vector<KeyPoint>& keypoints_, |
||||||
|
std::vector< std::vector<KeyPoint> >& keypointsByView) const; |
||||||
|
|
||||||
|
const Ptr<Feature2D> backend_; |
||||||
|
int maxTilt_; |
||||||
|
int minTilt_; |
||||||
|
float tiltStep_; |
||||||
|
float rotateStepBase_; |
||||||
|
|
||||||
|
// Tilt factors.
|
||||||
|
std::vector<float> tilts_; |
||||||
|
// Roll factors.
|
||||||
|
std::vector<float> rolls_; |
||||||
|
|
||||||
|
private: |
||||||
|
AffineFeature_Impl(const AffineFeature_Impl &); // copy disabled
|
||||||
|
AffineFeature_Impl& operator=(const AffineFeature_Impl &); // assign disabled
|
||||||
|
}; |
||||||
|
|
||||||
|
AffineFeature_Impl::AffineFeature_Impl(const Ptr<FeatureDetector>& backend, |
||||||
|
int maxTilt, int minTilt, float tiltStep, float rotateStepBase) |
||||||
|
: backend_(backend), maxTilt_(maxTilt), minTilt_(minTilt), tiltStep_(tiltStep), rotateStepBase_(rotateStepBase) |
||||||
|
{ |
||||||
|
int i = minTilt_; |
||||||
|
if( i == 0 ) |
||||||
|
{ |
||||||
|
tilts_.push_back(1); |
||||||
|
rolls_.push_back(0); |
||||||
|
i++; |
||||||
|
} |
||||||
|
float tilt = 1; |
||||||
|
for( ; i <= maxTilt_; i++ ) |
||||||
|
{ |
||||||
|
tilt *= tiltStep_; |
||||||
|
float rotateStep = rotateStepBase_ / tilt; |
||||||
|
int rollN = cvFloor(180.0f / rotateStep); |
||||||
|
if( rollN * rotateStep == 180.0f ) |
||||||
|
rollN--; |
||||||
|
for( int j = 0; j <= rollN; j++ ) |
||||||
|
{ |
||||||
|
tilts_.push_back(tilt); |
||||||
|
rolls_.push_back(rotateStep * j); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void AffineFeature_Impl::setViewParams(const std::vector<float>& tilts, |
||||||
|
const std::vector<float>& rolls) |
||||||
|
{ |
||||||
|
CV_Assert(tilts.size() == rolls.size()); |
||||||
|
tilts_ = tilts; |
||||||
|
rolls_ = rolls; |
||||||
|
} |
||||||
|
|
||||||
|
void AffineFeature_Impl::getViewParams(std::vector<float>& tilts, |
||||||
|
std::vector<float>& rolls) const |
||||||
|
{ |
||||||
|
tilts = tilts_; |
||||||
|
rolls = rolls_; |
||||||
|
} |
||||||
|
|
||||||
|
void AffineFeature_Impl::splitKeypointsByView(const std::vector<KeyPoint>& keypoints_, |
||||||
|
std::vector< std::vector<KeyPoint> >& keypointsByView) const |
||||||
|
{ |
||||||
|
for( size_t i = 0; i < keypoints_.size(); i++ ) |
||||||
|
{ |
||||||
|
const KeyPoint& kp = keypoints_[i]; |
||||||
|
CV_Assert( kp.class_id >= 0 && kp.class_id < (int)tilts_.size() ); |
||||||
|
keypointsByView[kp.class_id].push_back(kp); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
class skewedDetectAndCompute : public ParallelLoopBody |
||||||
|
{ |
||||||
|
public: |
||||||
|
skewedDetectAndCompute( |
||||||
|
const std::vector<float>& _tilts, |
||||||
|
const std::vector<float>& _rolls, |
||||||
|
std::vector< std::vector<KeyPoint> >& _keypointsCollection, |
||||||
|
std::vector<Mat>& _descriptorCollection, |
||||||
|
const Mat& _image, |
||||||
|
const Mat& _mask, |
||||||
|
const bool _do_keypoints, |
||||||
|
const bool _do_descriptors, |
||||||
|
const Ptr<Feature2D>& _backend) |
||||||
|
: tilts(_tilts), |
||||||
|
rolls(_rolls), |
||||||
|
keypointsCollection(_keypointsCollection), |
||||||
|
descriptorCollection(_descriptorCollection), |
||||||
|
image(_image), |
||||||
|
mask(_mask), |
||||||
|
do_keypoints(_do_keypoints), |
||||||
|
do_descriptors(_do_descriptors), |
||||||
|
backend(_backend) {} |
||||||
|
|
||||||
|
void operator()( const cv::Range& range ) const CV_OVERRIDE |
||||||
|
{ |
||||||
|
CV_TRACE_FUNCTION(); |
||||||
|
|
||||||
|
const int begin = range.start; |
||||||
|
const int end = range.end; |
||||||
|
|
||||||
|
for( int a = begin; a < end; a++ ) |
||||||
|
{ |
||||||
|
Mat warpedImage, warpedMask; |
||||||
|
Matx23f pose, invPose; |
||||||
|
affineSkew(tilts[a], rolls[a], warpedImage, warpedMask, pose); |
||||||
|
invertAffineTransform(pose, invPose); |
||||||
|
|
||||||
|
std::vector<KeyPoint> wKeypoints; |
||||||
|
Mat wDescriptors; |
||||||
|
if( !do_keypoints ) |
||||||
|
{ |
||||||
|
const std::vector<KeyPoint>& keypointsInView = keypointsCollection[a]; |
||||||
|
if( keypointsInView.size() == 0 ) // when there are no keypoints in this affine view
|
||||||
|
continue; |
||||||
|
|
||||||
|
std::vector<Point2f> pts_, pts; |
||||||
|
KeyPoint::convert(keypointsInView, pts_); |
||||||
|
transform(pts_, pts, pose); |
||||||
|
wKeypoints.resize(keypointsInView.size()); |
||||||
|
for( size_t wi = 0; wi < wKeypoints.size(); wi++ ) |
||||||
|
{ |
||||||
|
wKeypoints[wi] = keypointsInView[wi]; |
||||||
|
wKeypoints[wi].pt = pts[wi]; |
||||||
|
} |
||||||
|
} |
||||||
|
backend->detectAndCompute(warpedImage, warpedMask, wKeypoints, wDescriptors, !do_keypoints); |
||||||
|
if( do_keypoints ) |
||||||
|
{ |
||||||
|
// KeyPointsFilter::runByPixelsMask( wKeypoints, warpedMask );
|
||||||
|
if( wKeypoints.size() == 0 ) |
||||||
|
{ |
||||||
|
keypointsCollection[a].clear(); |
||||||
|
continue; |
||||||
|
} |
||||||
|
std::vector<Point2f> pts_, pts; |
||||||
|
KeyPoint::convert(wKeypoints, pts_); |
||||||
|
transform(pts_, pts, invPose); |
||||||
|
|
||||||
|
keypointsCollection[a].resize(wKeypoints.size()); |
||||||
|
for( size_t wi = 0; wi < wKeypoints.size(); wi++ ) |
||||||
|
{ |
||||||
|
keypointsCollection[a][wi] = wKeypoints[wi]; |
||||||
|
keypointsCollection[a][wi].pt = pts[wi]; |
||||||
|
keypointsCollection[a][wi].class_id = a; |
||||||
|
} |
||||||
|
} |
||||||
|
if( do_descriptors ) |
||||||
|
wDescriptors.copyTo(descriptorCollection[a]); |
||||||
|
} |
||||||
|
} |
||||||
|
private: |
||||||
|
void affineSkew(float tilt, float phi, |
||||||
|
Mat& warpedImage, Mat& warpedMask, Matx23f& pose) const |
||||||
|
{ |
||||||
|
int h = image.size().height; |
||||||
|
int w = image.size().width; |
||||||
|
Mat rotImage; |
||||||
|
|
||||||
|
Mat mask0; |
||||||
|
if( mask.empty() ) |
||||||
|
mask0 = Mat(h, w, CV_8UC1, 255); |
||||||
|
else |
||||||
|
mask0 = mask; |
||||||
|
pose = Matx23f(1,0,0, |
||||||
|
0,1,0); |
||||||
|
|
||||||
|
if( phi == 0 ) |
||||||
|
image.copyTo(rotImage); |
||||||
|
else |
||||||
|
{ |
||||||
|
phi = phi * (float)CV_PI / 180; |
||||||
|
float s = std::sin(phi); |
||||||
|
float c = std::cos(phi); |
||||||
|
Matx22f A(c, -s, s, c); |
||||||
|
Matx<float, 4, 2> corners(0, 0, (float)w, 0, (float)w,(float)h, 0, (float)h); |
||||||
|
Mat tf(corners * A.t()); |
||||||
|
Mat tcorners; |
||||||
|
tf.convertTo(tcorners, CV_32S); |
||||||
|
Rect rect = boundingRect(tcorners); |
||||||
|
h = rect.height; w = rect.width; |
||||||
|
pose = Matx23f(c, -s, -(float)rect.x, |
||||||
|
s, c, -(float)rect.y); |
||||||
|
warpAffine(image, rotImage, pose, Size(w, h), INTER_LINEAR, BORDER_REPLICATE); |
||||||
|
} |
||||||
|
if( tilt == 1 ) |
||||||
|
warpedImage = rotImage; |
||||||
|
else |
||||||
|
{ |
||||||
|
float s = 0.8f * sqrt(tilt * tilt - 1); |
||||||
|
GaussianBlur(rotImage, rotImage, Size(0, 0), s, 0.01); |
||||||
|
resize(rotImage, warpedImage, Size(0, 0), 1.0/tilt, 1.0, INTER_NEAREST); |
||||||
|
pose(0, 0) /= tilt; |
||||||
|
pose(0, 1) /= tilt; |
||||||
|
pose(0, 2) /= tilt; |
||||||
|
} |
||||||
|
if( phi != 0 || tilt != 1 ) |
||||||
|
warpAffine(mask0, warpedMask, pose, warpedImage.size(), INTER_NEAREST); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
const std::vector<float>& tilts; |
||||||
|
const std::vector<float>& rolls; |
||||||
|
std::vector< std::vector<KeyPoint> >& keypointsCollection; |
||||||
|
std::vector<Mat>& descriptorCollection; |
||||||
|
const Mat& image; |
||||||
|
const Mat& mask; |
||||||
|
const bool do_keypoints; |
||||||
|
const bool do_descriptors; |
||||||
|
const Ptr<Feature2D>& backend; |
||||||
|
}; |
||||||
|
|
||||||
|
void AffineFeature_Impl::detectAndCompute(InputArray _image, InputArray _mask, |
||||||
|
std::vector<KeyPoint>& keypoints, |
||||||
|
OutputArray _descriptors, |
||||||
|
bool useProvidedKeypoints) |
||||||
|
{ |
||||||
|
CV_TRACE_FUNCTION(); |
||||||
|
|
||||||
|
bool do_keypoints = !useProvidedKeypoints; |
||||||
|
bool do_descriptors = _descriptors.needed(); |
||||||
|
Mat image = _image.getMat(), mask = _mask.getMat(); |
||||||
|
Mat descriptors; |
||||||
|
|
||||||
|
if( (!do_keypoints && !do_descriptors) || _image.empty() ) |
||||||
|
return; |
||||||
|
|
||||||
|
std::vector< std::vector<KeyPoint> > keypointsCollection(tilts_.size()); |
||||||
|
std::vector< Mat > descriptorCollection(tilts_.size()); |
||||||
|
|
||||||
|
if( do_keypoints ) |
||||||
|
keypoints.clear(); |
||||||
|
else |
||||||
|
splitKeypointsByView(keypoints, keypointsCollection); |
||||||
|
|
||||||
|
parallel_for_(Range(0, (int)tilts_.size()), skewedDetectAndCompute(tilts_, rolls_, keypointsCollection, descriptorCollection, |
||||||
|
image, mask, do_keypoints, do_descriptors, backend_)); |
||||||
|
|
||||||
|
if( do_keypoints ) |
||||||
|
for( size_t i = 0; i < keypointsCollection.size(); i++ ) |
||||||
|
{ |
||||||
|
const std::vector<KeyPoint>& keys = keypointsCollection[i]; |
||||||
|
keypoints.insert(keypoints.end(), keys.begin(), keys.end()); |
||||||
|
} |
||||||
|
|
||||||
|
if( do_descriptors ) |
||||||
|
{ |
||||||
|
_descriptors.create((int)keypoints.size(), backend_->descriptorSize(), backend_->descriptorType()); |
||||||
|
descriptors = _descriptors.getMat(); |
||||||
|
int iter = 0; |
||||||
|
for( size_t i = 0; i < descriptorCollection.size(); i++ ) |
||||||
|
{ |
||||||
|
const Mat& descs = descriptorCollection[i]; |
||||||
|
if( descs.empty() ) |
||||||
|
continue; |
||||||
|
Mat roi(descriptors, Rect(0, iter, descriptors.cols, descs.rows)); |
||||||
|
descs.copyTo(roi); |
||||||
|
iter += descs.rows; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
Ptr<AffineFeature> AffineFeature::create(const Ptr<Feature2D>& backend, |
||||||
|
int maxTilt, int minTilt, float tiltStep, float rotateStepBase) |
||||||
|
{ |
||||||
|
CV_Assert(minTilt < maxTilt); |
||||||
|
CV_Assert(tiltStep > 0); |
||||||
|
CV_Assert(rotateStepBase > 0); |
||||||
|
return makePtr<AffineFeature_Impl>(backend, maxTilt, minTilt, tiltStep, rotateStepBase); |
||||||
|
} |
||||||
|
|
||||||
|
String AffineFeature::getDefaultName() const |
||||||
|
{ |
||||||
|
return (Feature2D::getDefaultName() + ".AffineFeature"); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace
|
||||||
@ -0,0 +1,185 @@ |
|||||||
|
// 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" |
||||||
|
|
||||||
|
// #define GENERATE_DATA // generate data in debug mode
|
||||||
|
|
||||||
|
namespace opencv_test { namespace { |
||||||
|
|
||||||
|
#ifndef GENERATE_DATA |
||||||
|
static bool isSimilarKeypoints( const KeyPoint& p1, const KeyPoint& p2 ) |
||||||
|
{ |
||||||
|
const float maxPtDif = 1.f; |
||||||
|
const float maxSizeDif = 1.f; |
||||||
|
const float maxAngleDif = 2.f; |
||||||
|
const float maxResponseDif = 0.1f; |
||||||
|
|
||||||
|
float dist = (float)cv::norm( p1.pt - p2.pt ); |
||||||
|
return (dist < maxPtDif && |
||||||
|
fabs(p1.size - p2.size) < maxSizeDif && |
||||||
|
abs(p1.angle - p2.angle) < maxAngleDif && |
||||||
|
abs(p1.response - p2.response) < maxResponseDif && |
||||||
|
(p1.octave & 0xffff) == (p2.octave & 0xffff) // do not care about sublayers and class_id
|
||||||
|
); |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
TEST(Features2d_AFFINE_FEATURE, regression) |
||||||
|
{ |
||||||
|
Mat image = imread(cvtest::findDataFile("features2d/tsukuba.png")); |
||||||
|
string xml = cvtest::TS::ptr()->get_data_path() + "asift/regression_cpp.xml.gz"; |
||||||
|
ASSERT_FALSE(image.empty()); |
||||||
|
|
||||||
|
Mat gray; |
||||||
|
cvtColor(image, gray, COLOR_BGR2GRAY); |
||||||
|
|
||||||
|
// Default ASIFT generates too large descriptors. This test uses small maxTilt to suppress the size of testdata.
|
||||||
|
Ptr<AffineFeature> ext = AffineFeature::create(SIFT::create(), 2, 0, 1.4142135623730951f, 144.0f); |
||||||
|
Mat mpt, msize, mangle, mresponse, moctave, mclass_id; |
||||||
|
#ifdef GENERATE_DATA |
||||||
|
// calculate
|
||||||
|
vector<KeyPoint> calcKeypoints; |
||||||
|
Mat calcDescriptors; |
||||||
|
ext->detectAndCompute(gray, Mat(), calcKeypoints, calcDescriptors, false); |
||||||
|
|
||||||
|
// create keypoints XML
|
||||||
|
FileStorage fs(xml, FileStorage::WRITE); |
||||||
|
ASSERT_TRUE(fs.isOpened()) << xml; |
||||||
|
std::cout << "Creating keypoints XML..." << std::endl; |
||||||
|
|
||||||
|
mpt = Mat(calcKeypoints.size(), 2, CV_32F); |
||||||
|
msize = Mat(calcKeypoints.size(), 1, CV_32F); |
||||||
|
mangle = Mat(calcKeypoints.size(), 1, CV_32F); |
||||||
|
mresponse = Mat(calcKeypoints.size(), 1, CV_32F); |
||||||
|
moctave = Mat(calcKeypoints.size(), 1, CV_32S); |
||||||
|
mclass_id = Mat(calcKeypoints.size(), 1, CV_32S); |
||||||
|
|
||||||
|
for( size_t i = 0; i < calcKeypoints.size(); i++ ) |
||||||
|
{ |
||||||
|
const KeyPoint& key = calcKeypoints[i]; |
||||||
|
mpt.at<float>(i, 0) = key.pt.x; |
||||||
|
mpt.at<float>(i, 1) = key.pt.y; |
||||||
|
msize.at<float>(i, 0) = key.size; |
||||||
|
mangle.at<float>(i, 0) = key.angle; |
||||||
|
mresponse.at<float>(i, 0) = key.response; |
||||||
|
moctave.at<int>(i, 0) = key.octave; |
||||||
|
mclass_id.at<int>(i, 0) = key.class_id; |
||||||
|
} |
||||||
|
|
||||||
|
fs << "keypoints_pt" << mpt; |
||||||
|
fs << "keypoints_size" << msize; |
||||||
|
fs << "keypoints_angle" << mangle; |
||||||
|
fs << "keypoints_response" << mresponse; |
||||||
|
fs << "keypoints_octave" << moctave; |
||||||
|
fs << "keypoints_class_id" << mclass_id; |
||||||
|
|
||||||
|
// create descriptor XML
|
||||||
|
fs << "descriptors" << calcDescriptors; |
||||||
|
fs.release(); |
||||||
|
#else |
||||||
|
const float badCountsRatio = 0.01f; |
||||||
|
const float badDescriptorDist = 1.0f; |
||||||
|
const float maxBadKeypointsRatio = 0.15f; |
||||||
|
const float maxBadDescriptorRatio = 0.15f; |
||||||
|
|
||||||
|
// read keypoints
|
||||||
|
vector<KeyPoint> validKeypoints; |
||||||
|
Mat validDescriptors; |
||||||
|
FileStorage fs(xml, FileStorage::READ); |
||||||
|
ASSERT_TRUE(fs.isOpened()) << xml; |
||||||
|
|
||||||
|
fs["keypoints_pt"] >> mpt; |
||||||
|
ASSERT_EQ(mpt.type(), CV_32F); |
||||||
|
fs["keypoints_size"] >> msize; |
||||||
|
ASSERT_EQ(msize.type(), CV_32F); |
||||||
|
fs["keypoints_angle"] >> mangle; |
||||||
|
ASSERT_EQ(mangle.type(), CV_32F); |
||||||
|
fs["keypoints_response"] >> mresponse; |
||||||
|
ASSERT_EQ(mresponse.type(), CV_32F); |
||||||
|
fs["keypoints_octave"] >> moctave; |
||||||
|
ASSERT_EQ(moctave.type(), CV_32S); |
||||||
|
fs["keypoints_class_id"] >> mclass_id; |
||||||
|
ASSERT_EQ(mclass_id.type(), CV_32S); |
||||||
|
|
||||||
|
validKeypoints.resize(mpt.rows); |
||||||
|
for( int i = 0; i < (int)validKeypoints.size(); i++ ) |
||||||
|
{ |
||||||
|
validKeypoints[i].pt.x = mpt.at<float>(i, 0); |
||||||
|
validKeypoints[i].pt.y = mpt.at<float>(i, 1); |
||||||
|
validKeypoints[i].size = msize.at<float>(i, 0); |
||||||
|
validKeypoints[i].angle = mangle.at<float>(i, 0); |
||||||
|
validKeypoints[i].response = mresponse.at<float>(i, 0); |
||||||
|
validKeypoints[i].octave = moctave.at<int>(i, 0); |
||||||
|
validKeypoints[i].class_id = mclass_id.at<int>(i, 0); |
||||||
|
} |
||||||
|
|
||||||
|
// read descriptors
|
||||||
|
fs["descriptors"] >> validDescriptors; |
||||||
|
fs.release(); |
||||||
|
|
||||||
|
// calc and compare keypoints
|
||||||
|
vector<KeyPoint> calcKeypoints; |
||||||
|
ext->detectAndCompute(gray, Mat(), calcKeypoints, noArray(), false); |
||||||
|
|
||||||
|
float countRatio = (float)validKeypoints.size() / (float)calcKeypoints.size(); |
||||||
|
ASSERT_LT(countRatio, 1 + badCountsRatio) << "Bad keypoints count ratio."; |
||||||
|
ASSERT_GT(countRatio, 1 - badCountsRatio) << "Bad keypoints count ratio."; |
||||||
|
|
||||||
|
int badPointCount = 0, commonPointCount = max((int)validKeypoints.size(), (int)calcKeypoints.size()); |
||||||
|
for( size_t v = 0; v < validKeypoints.size(); v++ ) |
||||||
|
{ |
||||||
|
int nearestIdx = -1; |
||||||
|
float minDist = std::numeric_limits<float>::max(); |
||||||
|
float angleDistOfNearest = std::numeric_limits<float>::max(); |
||||||
|
|
||||||
|
for( size_t c = 0; c < calcKeypoints.size(); c++ ) |
||||||
|
{ |
||||||
|
if( validKeypoints[v].class_id != calcKeypoints[c].class_id ) |
||||||
|
continue; |
||||||
|
float curDist = (float)cv::norm( calcKeypoints[c].pt - validKeypoints[v].pt ); |
||||||
|
if( curDist < minDist ) |
||||||
|
{ |
||||||
|
minDist = curDist; |
||||||
|
nearestIdx = (int)c; |
||||||
|
angleDistOfNearest = abs( calcKeypoints[c].angle - validKeypoints[v].angle ); |
||||||
|
} |
||||||
|
else if( curDist == minDist ) // the keypoints whose positions are same but angles are different
|
||||||
|
{ |
||||||
|
float angleDist = abs( calcKeypoints[c].angle - validKeypoints[v].angle ); |
||||||
|
if( angleDist < angleDistOfNearest ) |
||||||
|
{ |
||||||
|
nearestIdx = (int)c; |
||||||
|
angleDistOfNearest = angleDist; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
if( nearestIdx == -1 || !isSimilarKeypoints( validKeypoints[v], calcKeypoints[nearestIdx] ) ) |
||||||
|
badPointCount++; |
||||||
|
} |
||||||
|
float badKeypointsRatio = (float)badPointCount / (float)commonPointCount; |
||||||
|
std::cout << "badKeypointsRatio: " << badKeypointsRatio << std::endl; |
||||||
|
ASSERT_LT( badKeypointsRatio , maxBadKeypointsRatio ) << "Bad accuracy!"; |
||||||
|
|
||||||
|
// Calc and compare descriptors. This uses validKeypoints for extraction.
|
||||||
|
Mat calcDescriptors; |
||||||
|
ext->detectAndCompute(gray, Mat(), validKeypoints, calcDescriptors, true); |
||||||
|
|
||||||
|
int dim = validDescriptors.cols; |
||||||
|
int badDescriptorCount = 0; |
||||||
|
L1<float> distance; |
||||||
|
|
||||||
|
for( int i = 0; i < (int)validKeypoints.size(); i++ ) |
||||||
|
{ |
||||||
|
float dist = distance( validDescriptors.ptr<float>(i), calcDescriptors.ptr<float>(i), dim ); |
||||||
|
if( dist > badDescriptorDist ) |
||||||
|
badDescriptorCount++; |
||||||
|
} |
||||||
|
float badDescriptorRatio = (float)badDescriptorCount / (float)validKeypoints.size(); |
||||||
|
std::cout << "badDescriptorRatio: " << badDescriptorRatio << std::endl; |
||||||
|
ASSERT_LT( badDescriptorRatio, maxBadDescriptorRatio ) << "Too many descriptors mismatched."; |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
}} // namespace
|
||||||
@ -0,0 +1,199 @@ |
|||||||
|
#include <opencv2/core.hpp> |
||||||
|
#include <opencv2/imgproc.hpp> |
||||||
|
#include <opencv2/features2d.hpp> |
||||||
|
#include <opencv2/highgui.hpp> |
||||||
|
#include <opencv2/calib3d.hpp> |
||||||
|
#include <iostream> |
||||||
|
#include <iomanip> |
||||||
|
|
||||||
|
using namespace std; |
||||||
|
using namespace cv; |
||||||
|
|
||||||
|
static void help(char** argv) |
||||||
|
{ |
||||||
|
cout |
||||||
|
<< "This is a sample usage of AffineFeature detector/extractor.\n" |
||||||
|
<< "And this is a C++ version of samples/python/asift.py\n" |
||||||
|
<< "Usage: " << argv[0] << "\n" |
||||||
|
<< " [ --feature=<sift|orb|brisk> ] # Feature to use.\n" |
||||||
|
<< " [ --flann ] # use Flann-based matcher instead of bruteforce.\n" |
||||||
|
<< " [ --maxlines=<number(50 as default)> ] # The maximum number of lines in visualizing the matching result.\n" |
||||||
|
<< " [ --image1=<image1(aero1.jpg as default)> ]\n" |
||||||
|
<< " [ --image2=<image2(aero3.jpg as default)> ] # Path to images to compare." |
||||||
|
<< endl; |
||||||
|
} |
||||||
|
|
||||||
|
static double timer() |
||||||
|
{ |
||||||
|
return getTickCount() / getTickFrequency(); |
||||||
|
} |
||||||
|
|
||||||
|
int main(int argc, char** argv) |
||||||
|
{ |
||||||
|
vector<String> fileName; |
||||||
|
cv::CommandLineParser parser(argc, argv, |
||||||
|
"{help h ||}" |
||||||
|
"{feature|brisk|}" |
||||||
|
"{flann||}" |
||||||
|
"{maxlines|50|}" |
||||||
|
"{image1|aero1.jpg|}{image2|aero3.jpg|}"); |
||||||
|
if (parser.has("help")) |
||||||
|
{ |
||||||
|
help(argv); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
string feature = parser.get<string>("feature"); |
||||||
|
bool useFlann = parser.has("flann"); |
||||||
|
int maxlines = parser.get<int>("maxlines"); |
||||||
|
fileName.push_back(samples::findFile(parser.get<string>("image1"))); |
||||||
|
fileName.push_back(samples::findFile(parser.get<string>("image2"))); |
||||||
|
if (!parser.check()) |
||||||
|
{ |
||||||
|
parser.printErrors(); |
||||||
|
cout << "See --help (or missing '=' between argument name and value?)" << endl; |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
Mat img1 = imread(fileName[0], IMREAD_GRAYSCALE); |
||||||
|
Mat img2 = imread(fileName[1], IMREAD_GRAYSCALE); |
||||||
|
if (img1.empty()) |
||||||
|
{ |
||||||
|
cerr << "Image " << fileName[0] << " is empty or cannot be found" << endl; |
||||||
|
return 1; |
||||||
|
} |
||||||
|
if (img2.empty()) |
||||||
|
{ |
||||||
|
cerr << "Image " << fileName[1] << " is empty or cannot be found" << endl; |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
Ptr<Feature2D> backend; |
||||||
|
Ptr<DescriptorMatcher> matcher; |
||||||
|
|
||||||
|
if (feature == "sift") |
||||||
|
{ |
||||||
|
backend = SIFT::create(); |
||||||
|
if (useFlann) |
||||||
|
matcher = DescriptorMatcher::create("FlannBased"); |
||||||
|
else |
||||||
|
matcher = DescriptorMatcher::create("BruteForce"); |
||||||
|
} |
||||||
|
else if (feature == "orb") |
||||||
|
{ |
||||||
|
backend = ORB::create(); |
||||||
|
if (useFlann) |
||||||
|
matcher = makePtr<FlannBasedMatcher>(makePtr<flann::LshIndexParams>(6, 12, 1)); |
||||||
|
else |
||||||
|
matcher = DescriptorMatcher::create("BruteForce-Hamming"); |
||||||
|
} |
||||||
|
else if (feature == "brisk") |
||||||
|
{ |
||||||
|
backend = BRISK::create(); |
||||||
|
if (useFlann) |
||||||
|
matcher = makePtr<FlannBasedMatcher>(makePtr<flann::LshIndexParams>(6, 12, 1)); |
||||||
|
else |
||||||
|
matcher = DescriptorMatcher::create("BruteForce-Hamming"); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
cerr << feature << " is not supported. See --help" << endl; |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
cout << "extracting with " << feature << "..." << endl; |
||||||
|
Ptr<AffineFeature> ext = AffineFeature::create(backend); |
||||||
|
vector<KeyPoint> kp1, kp2; |
||||||
|
Mat desc1, desc2; |
||||||
|
|
||||||
|
ext->detectAndCompute(img1, Mat(), kp1, desc1); |
||||||
|
ext->detectAndCompute(img2, Mat(), kp2, desc2); |
||||||
|
cout << "img1 - " << kp1.size() << " features, " |
||||||
|
<< "img2 - " << kp2.size() << " features" |
||||||
|
<< endl; |
||||||
|
|
||||||
|
cout << "matching with " << (useFlann ? "flann" : "bruteforce") << "..." << endl; |
||||||
|
double start = timer(); |
||||||
|
// match and draw
|
||||||
|
vector< vector<DMatch> > rawMatches; |
||||||
|
vector<Point2f> p1, p2; |
||||||
|
vector<float> distances; |
||||||
|
matcher->knnMatch(desc1, desc2, rawMatches, 2); |
||||||
|
// filter_matches
|
||||||
|
for (size_t i = 0; i < rawMatches.size(); i++) |
||||||
|
{ |
||||||
|
const vector<DMatch>& m = rawMatches[i]; |
||||||
|
if (m.size() == 2 && m[0].distance < m[1].distance * 0.75) |
||||||
|
{ |
||||||
|
p1.push_back(kp1[m[0].queryIdx].pt); |
||||||
|
p2.push_back(kp2[m[0].trainIdx].pt); |
||||||
|
distances.push_back(m[0].distance); |
||||||
|
} |
||||||
|
} |
||||||
|
vector<uchar> status; |
||||||
|
vector< pair<Point2f, Point2f> > pointPairs; |
||||||
|
Mat H = findHomography(p1, p2, status, RANSAC); |
||||||
|
int inliers = 0; |
||||||
|
for (size_t i = 0; i < status.size(); i++) |
||||||
|
{ |
||||||
|
if (status[i]) |
||||||
|
{ |
||||||
|
pointPairs.push_back(make_pair(p1[i], p2[i])); |
||||||
|
distances[inliers] = distances[i]; |
||||||
|
// CV_Assert(inliers <= (int)i);
|
||||||
|
inliers++; |
||||||
|
} |
||||||
|
} |
||||||
|
distances.resize(inliers); |
||||||
|
|
||||||
|
cout << "execution time: " << fixed << setprecision(2) << (timer()-start)*1000 << " ms" << endl; |
||||||
|
cout << inliers << " / " << status.size() << " inliers/matched" << endl; |
||||||
|
|
||||||
|
cout << "visualizing..." << endl; |
||||||
|
vector<int> indices(inliers); |
||||||
|
cv::sortIdx(distances, indices, SORT_EVERY_ROW+SORT_ASCENDING); |
||||||
|
|
||||||
|
// explore_match
|
||||||
|
int h1 = img1.size().height; |
||||||
|
int w1 = img1.size().width; |
||||||
|
int h2 = img2.size().height; |
||||||
|
int w2 = img2.size().width; |
||||||
|
Mat vis = Mat::zeros(max(h1, h2), w1+w2, CV_8U); |
||||||
|
img1.copyTo(Mat(vis, Rect(0, 0, w1, h1))); |
||||||
|
img2.copyTo(Mat(vis, Rect(w1, 0, w2, h2))); |
||||||
|
cvtColor(vis, vis, COLOR_GRAY2BGR); |
||||||
|
|
||||||
|
vector<Point2f> corners(4); |
||||||
|
corners[0] = Point2f(0, 0); |
||||||
|
corners[1] = Point2f((float)w1, 0); |
||||||
|
corners[2] = Point2f((float)w1, (float)h1); |
||||||
|
corners[3] = Point2f(0, (float)h1); |
||||||
|
vector<Point2i> icorners; |
||||||
|
perspectiveTransform(corners, corners, H); |
||||||
|
transform(corners, corners, Matx23f(1,0,(float)w1,0,1,0)); |
||||||
|
Mat(corners).convertTo(icorners, CV_32S); |
||||||
|
polylines(vis, icorners, true, Scalar(255,255,255)); |
||||||
|
|
||||||
|
for (int i = 0; i < min(inliers, maxlines); i++) |
||||||
|
{ |
||||||
|
int idx = indices[i]; |
||||||
|
const Point2f& pi1 = pointPairs[idx].first; |
||||||
|
const Point2f& pi2 = pointPairs[idx].second; |
||||||
|
circle(vis, pi1, 2, Scalar(0,255,0), -1); |
||||||
|
circle(vis, pi2 + Point2f((float)w1,0), 2, Scalar(0,255,0), -1); |
||||||
|
line(vis, pi1, pi2 + Point2f((float)w1,0), Scalar(0,255,0)); |
||||||
|
} |
||||||
|
if (inliers > maxlines) |
||||||
|
cout << "only " << maxlines << " inliers are visualized" << endl; |
||||||
|
imshow("affine find_obj", vis); |
||||||
|
|
||||||
|
// Mat vis2 = Mat::zeros(max(h1, h2), w1+w2, CV_8U);
|
||||||
|
// Mat warp1;
|
||||||
|
// warpPerspective(img1, warp1, H, Size(w1, h1));
|
||||||
|
// warp1.copyTo(Mat(vis2, Rect(0, 0, w1, h1)));
|
||||||
|
// img2.copyTo(Mat(vis2, Rect(w1, 0, w2, h2)));
|
||||||
|
// imshow("warped", vis2);
|
||||||
|
|
||||||
|
waitKey(); |
||||||
|
cout << "done" << endl; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
Before Width: | Height: | Size: 7.9 KiB After Width: | Height: | Size: 9.5 KiB |
|
Before Width: | Height: | Size: 24 KiB After Width: | Height: | Size: 39 KiB |
|
Before Width: | Height: | Size: 1.4 KiB After Width: | Height: | Size: 2.2 KiB |
|
Before Width: | Height: | Size: 4.5 KiB After Width: | Height: | Size: 5.1 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.2 KiB |
|
Before Width: | Height: | Size: 1.4 KiB After Width: | Height: | Size: 2.2 KiB |
|
Before Width: | Height: | Size: 4.5 KiB After Width: | Height: | Size: 5.1 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.4 KiB |
|
Before Width: | Height: | Size: 1.4 KiB After Width: | Height: | Size: 2.2 KiB |
|
Before Width: | Height: | Size: 4.5 KiB After Width: | Height: | Size: 5.1 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.2 KiB |
|
Before Width: | Height: | Size: 1.4 KiB After Width: | Height: | Size: 2.2 KiB |
Loading…
Reference in new issue