1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Third party copyrights are property of their respective owners.
16 //
17 // Redistribution and use in source and binary forms, with or without modification,
18 // are permitted provided that the following conditions are met:
19 //
20 // * Redistribution's of source code must retain the above copyright notice,
21 // this list of conditions and the following disclaimer.
22 //
23 // * Redistribution's in binary form must reproduce the above copyright notice,
24 // this list of conditions and the following disclaimer in the documentation
25 // and/or other materials provided with the distribution.
26 //
27 // * The name of the copyright holders may not be used to endorse or promote products
28 // derived from this software without specific prior written permission.
29 //
30 // This software is provided by the copyright holders and contributors "as is" and
31 // any express or implied warranties, including, but not limited to, the implied
32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
33 // In no event shall the Intel Corporation or contributors be liable for any direct,
34 // indirect, incidental, special, exemplary, or consequential damages
35 // (including, but not limited to, procurement of substitute goods or services;
36 // loss of use, data, or profits; or business interruption) however caused
37 // and on any theory of liability, whether in contract, strict liability,
38 // or tort (including negligence or otherwise) arising in any way out of
39 // the use of this software, even if advised of the possibility of such damage.
40 //
41 //M*/
42
43 #include "precomp.hpp"
44
45 using namespace cv;
46 using namespace cv::detail;
47 using namespace cv::cuda;
48
49 #ifdef HAVE_OPENCV_XFEATURES2D
50 #include "opencv2/xfeatures2d.hpp"
51 using xfeatures2d::SURF;
52 #endif
53
54 namespace {
55
56 struct DistIdxPair
57 {
operator <__anon0431e8210111::DistIdxPair58 bool operator<(const DistIdxPair &other) const { return dist < other.dist; }
59 double dist;
60 int idx;
61 };
62
63
64 struct MatchPairsBody : ParallelLoopBody
65 {
MatchPairsBody__anon0431e8210111::MatchPairsBody66 MatchPairsBody(FeaturesMatcher &_matcher, const std::vector<ImageFeatures> &_features,
67 std::vector<MatchesInfo> &_pairwise_matches, std::vector<std::pair<int,int> > &_near_pairs)
68 : matcher(_matcher), features(_features),
69 pairwise_matches(_pairwise_matches), near_pairs(_near_pairs) {}
70
operator ()__anon0431e8210111::MatchPairsBody71 void operator ()(const Range &r) const
72 {
73 const int num_images = static_cast<int>(features.size());
74 for (int i = r.start; i < r.end; ++i)
75 {
76 int from = near_pairs[i].first;
77 int to = near_pairs[i].second;
78 int pair_idx = from*num_images + to;
79
80 matcher(features[from], features[to], pairwise_matches[pair_idx]);
81 pairwise_matches[pair_idx].src_img_idx = from;
82 pairwise_matches[pair_idx].dst_img_idx = to;
83
84 size_t dual_pair_idx = to*num_images + from;
85
86 pairwise_matches[dual_pair_idx] = pairwise_matches[pair_idx];
87 pairwise_matches[dual_pair_idx].src_img_idx = to;
88 pairwise_matches[dual_pair_idx].dst_img_idx = from;
89
90 if (!pairwise_matches[pair_idx].H.empty())
91 pairwise_matches[dual_pair_idx].H = pairwise_matches[pair_idx].H.inv();
92
93 for (size_t j = 0; j < pairwise_matches[dual_pair_idx].matches.size(); ++j)
94 std::swap(pairwise_matches[dual_pair_idx].matches[j].queryIdx,
95 pairwise_matches[dual_pair_idx].matches[j].trainIdx);
96 LOG(".");
97 }
98 }
99
100 FeaturesMatcher &matcher;
101 const std::vector<ImageFeatures> &features;
102 std::vector<MatchesInfo> &pairwise_matches;
103 std::vector<std::pair<int,int> > &near_pairs;
104
105 private:
106 void operator =(const MatchPairsBody&);
107 };
108
109
110 //////////////////////////////////////////////////////////////////////////////
111
112 typedef std::set<std::pair<int,int> > MatchesSet;
113
114 // These two classes are aimed to find features matches only, not to
115 // estimate homography
116
117 class CpuMatcher : public FeaturesMatcher
118 {
119 public:
CpuMatcher(float match_conf)120 CpuMatcher(float match_conf) : FeaturesMatcher(true), match_conf_(match_conf) {}
121 void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info);
122
123 private:
124 float match_conf_;
125 };
126
127 #ifdef HAVE_OPENCV_CUDAFEATURES2D
128 class GpuMatcher : public FeaturesMatcher
129 {
130 public:
GpuMatcher(float match_conf)131 GpuMatcher(float match_conf) : match_conf_(match_conf) {}
132 void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info);
133
134 void collectGarbage();
135
136 private:
137 float match_conf_;
138 GpuMat descriptors1_, descriptors2_;
139 GpuMat train_idx_, distance_, all_dist_;
140 std::vector< std::vector<DMatch> > pair_matches;
141 };
142 #endif
143
144
match(const ImageFeatures & features1,const ImageFeatures & features2,MatchesInfo & matches_info)145 void CpuMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info)
146 {
147 CV_Assert(features1.descriptors.type() == features2.descriptors.type());
148 CV_Assert(features2.descriptors.depth() == CV_8U || features2.descriptors.depth() == CV_32F);
149
150 #ifdef HAVE_TEGRA_OPTIMIZATION
151 if (tegra::useTegra() && tegra::match2nearest(features1, features2, matches_info, match_conf_))
152 return;
153 #endif
154
155 matches_info.matches.clear();
156
157 Ptr<cv::DescriptorMatcher> matcher;
158 #if 0 // TODO check this
159 if (ocl::useOpenCL())
160 {
161 matcher = makePtr<BFMatcher>((int)NORM_L2);
162 }
163 else
164 #endif
165 {
166 Ptr<flann::IndexParams> indexParams = makePtr<flann::KDTreeIndexParams>();
167 Ptr<flann::SearchParams> searchParams = makePtr<flann::SearchParams>();
168
169 if (features2.descriptors.depth() == CV_8U)
170 {
171 indexParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
172 searchParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
173 }
174
175 matcher = makePtr<FlannBasedMatcher>(indexParams, searchParams);
176 }
177 std::vector< std::vector<DMatch> > pair_matches;
178 MatchesSet matches;
179
180 // Find 1->2 matches
181 matcher->knnMatch(features1.descriptors, features2.descriptors, pair_matches, 2);
182 for (size_t i = 0; i < pair_matches.size(); ++i)
183 {
184 if (pair_matches[i].size() < 2)
185 continue;
186 const DMatch& m0 = pair_matches[i][0];
187 const DMatch& m1 = pair_matches[i][1];
188 if (m0.distance < (1.f - match_conf_) * m1.distance)
189 {
190 matches_info.matches.push_back(m0);
191 matches.insert(std::make_pair(m0.queryIdx, m0.trainIdx));
192 }
193 }
194 LOG("\n1->2 matches: " << matches_info.matches.size() << endl);
195
196 // Find 2->1 matches
197 pair_matches.clear();
198 matcher->knnMatch(features2.descriptors, features1.descriptors, pair_matches, 2);
199 for (size_t i = 0; i < pair_matches.size(); ++i)
200 {
201 if (pair_matches[i].size() < 2)
202 continue;
203 const DMatch& m0 = pair_matches[i][0];
204 const DMatch& m1 = pair_matches[i][1];
205 if (m0.distance < (1.f - match_conf_) * m1.distance)
206 if (matches.find(std::make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
207 matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
208 }
209 LOG("1->2 & 2->1 matches: " << matches_info.matches.size() << endl);
210 }
211
212 #ifdef HAVE_OPENCV_CUDAFEATURES2D
match(const ImageFeatures & features1,const ImageFeatures & features2,MatchesInfo & matches_info)213 void GpuMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info)
214 {
215 matches_info.matches.clear();
216
217 ensureSizeIsEnough(features1.descriptors.size(), features1.descriptors.type(), descriptors1_);
218 ensureSizeIsEnough(features2.descriptors.size(), features2.descriptors.type(), descriptors2_);
219
220 descriptors1_.upload(features1.descriptors);
221 descriptors2_.upload(features2.descriptors);
222
223 Ptr<cuda::DescriptorMatcher> matcher = cuda::DescriptorMatcher::createBFMatcher(NORM_L2);
224
225 MatchesSet matches;
226
227 // Find 1->2 matches
228 pair_matches.clear();
229 matcher->knnMatch(descriptors1_, descriptors2_, pair_matches, 2);
230 for (size_t i = 0; i < pair_matches.size(); ++i)
231 {
232 if (pair_matches[i].size() < 2)
233 continue;
234 const DMatch& m0 = pair_matches[i][0];
235 const DMatch& m1 = pair_matches[i][1];
236 if (m0.distance < (1.f - match_conf_) * m1.distance)
237 {
238 matches_info.matches.push_back(m0);
239 matches.insert(std::make_pair(m0.queryIdx, m0.trainIdx));
240 }
241 }
242
243 // Find 2->1 matches
244 pair_matches.clear();
245 matcher->knnMatch(descriptors2_, descriptors1_, pair_matches, 2);
246 for (size_t i = 0; i < pair_matches.size(); ++i)
247 {
248 if (pair_matches[i].size() < 2)
249 continue;
250 const DMatch& m0 = pair_matches[i][0];
251 const DMatch& m1 = pair_matches[i][1];
252 if (m0.distance < (1.f - match_conf_) * m1.distance)
253 if (matches.find(std::make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
254 matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
255 }
256 }
257
collectGarbage()258 void GpuMatcher::collectGarbage()
259 {
260 descriptors1_.release();
261 descriptors2_.release();
262 train_idx_.release();
263 distance_.release();
264 all_dist_.release();
265 std::vector< std::vector<DMatch> >().swap(pair_matches);
266 }
267 #endif
268
269 } // namespace
270
271
272 namespace cv {
273 namespace detail {
274
operator ()(InputArray image,ImageFeatures & features)275 void FeaturesFinder::operator ()(InputArray image, ImageFeatures &features)
276 {
277 find(image, features);
278 features.img_size = image.size();
279 }
280
281
operator ()(InputArray image,ImageFeatures & features,const std::vector<Rect> & rois)282 void FeaturesFinder::operator ()(InputArray image, ImageFeatures &features, const std::vector<Rect> &rois)
283 {
284 std::vector<ImageFeatures> roi_features(rois.size());
285 size_t total_kps_count = 0;
286 int total_descriptors_height = 0;
287
288 for (size_t i = 0; i < rois.size(); ++i)
289 {
290 find(image.getUMat()(rois[i]), roi_features[i]);
291 total_kps_count += roi_features[i].keypoints.size();
292 total_descriptors_height += roi_features[i].descriptors.rows;
293 }
294
295 features.img_size = image.size();
296 features.keypoints.resize(total_kps_count);
297 features.descriptors.create(total_descriptors_height,
298 roi_features[0].descriptors.cols,
299 roi_features[0].descriptors.type());
300
301 int kp_idx = 0;
302 int descr_offset = 0;
303 for (size_t i = 0; i < rois.size(); ++i)
304 {
305 for (size_t j = 0; j < roi_features[i].keypoints.size(); ++j, ++kp_idx)
306 {
307 features.keypoints[kp_idx] = roi_features[i].keypoints[j];
308 features.keypoints[kp_idx].pt.x += (float)rois[i].x;
309 features.keypoints[kp_idx].pt.y += (float)rois[i].y;
310 }
311 UMat subdescr = features.descriptors.rowRange(
312 descr_offset, descr_offset + roi_features[i].descriptors.rows);
313 roi_features[i].descriptors.copyTo(subdescr);
314 descr_offset += roi_features[i].descriptors.rows;
315 }
316 }
317
318
SurfFeaturesFinder(double hess_thresh,int num_octaves,int num_layers,int num_octaves_descr,int num_layers_descr)319 SurfFeaturesFinder::SurfFeaturesFinder(double hess_thresh, int num_octaves, int num_layers,
320 int num_octaves_descr, int num_layers_descr)
321 {
322 #ifdef HAVE_OPENCV_XFEATURES2D
323 if (num_octaves_descr == num_octaves && num_layers_descr == num_layers)
324 {
325 Ptr<SURF> surf_ = SURF::create();
326 if( !surf_ )
327 CV_Error( Error::StsNotImplemented, "OpenCV was built without SURF support" );
328 surf_->setHessianThreshold(hess_thresh);
329 surf_->setNOctaves(num_octaves);
330 surf_->setNOctaveLayers(num_layers);
331 surf = surf_;
332 }
333 else
334 {
335 Ptr<SURF> sdetector_ = SURF::create();
336 Ptr<SURF> sextractor_ = SURF::create();
337
338 if( !sdetector_ || !sextractor_ )
339 CV_Error( Error::StsNotImplemented, "OpenCV was built without SURF support" );
340
341 sdetector_->setHessianThreshold(hess_thresh);
342 sdetector_->setNOctaves(num_octaves);
343 sdetector_->setNOctaveLayers(num_layers);
344
345 sextractor_->setNOctaves(num_octaves_descr);
346 sextractor_->setNOctaveLayers(num_layers_descr);
347
348 detector_ = sdetector_;
349 extractor_ = sextractor_;
350 }
351 #else
352 (void)hess_thresh;
353 (void)num_octaves;
354 (void)num_layers;
355 (void)num_octaves_descr;
356 (void)num_layers_descr;
357 CV_Error( Error::StsNotImplemented, "OpenCV was built without SURF support" );
358 #endif
359 }
360
find(InputArray image,ImageFeatures & features)361 void SurfFeaturesFinder::find(InputArray image, ImageFeatures &features)
362 {
363 UMat gray_image;
364 CV_Assert((image.type() == CV_8UC3) || (image.type() == CV_8UC1));
365 if(image.type() == CV_8UC3)
366 {
367 cvtColor(image, gray_image, COLOR_BGR2GRAY);
368 }
369 else
370 {
371 gray_image = image.getUMat();
372 }
373 if (!surf)
374 {
375 detector_->detect(gray_image, features.keypoints);
376 extractor_->compute(gray_image, features.keypoints, features.descriptors);
377 }
378 else
379 {
380 UMat descriptors;
381 surf->detectAndCompute(gray_image, Mat(), features.keypoints, descriptors);
382 features.descriptors = descriptors.reshape(1, (int)features.keypoints.size());
383 }
384 }
385
OrbFeaturesFinder(Size _grid_size,int n_features,float scaleFactor,int nlevels)386 OrbFeaturesFinder::OrbFeaturesFinder(Size _grid_size, int n_features, float scaleFactor, int nlevels)
387 {
388 grid_size = _grid_size;
389 orb = ORB::create(n_features * (99 + grid_size.area())/100/grid_size.area(), scaleFactor, nlevels);
390 }
391
find(InputArray image,ImageFeatures & features)392 void OrbFeaturesFinder::find(InputArray image, ImageFeatures &features)
393 {
394 UMat gray_image;
395
396 CV_Assert((image.type() == CV_8UC3) || (image.type() == CV_8UC4) || (image.type() == CV_8UC1));
397
398 if (image.type() == CV_8UC3) {
399 cvtColor(image, gray_image, COLOR_BGR2GRAY);
400 } else if (image.type() == CV_8UC4) {
401 cvtColor(image, gray_image, COLOR_BGRA2GRAY);
402 } else if (image.type() == CV_8UC1) {
403 gray_image = image.getUMat();
404 } else {
405 CV_Error(Error::StsUnsupportedFormat, "");
406 }
407
408 if (grid_size.area() == 1)
409 orb->detectAndCompute(gray_image, Mat(), features.keypoints, features.descriptors);
410 else
411 {
412 features.keypoints.clear();
413 features.descriptors.release();
414
415 std::vector<KeyPoint> points;
416 Mat _descriptors;
417 UMat descriptors;
418
419 for (int r = 0; r < grid_size.height; ++r)
420 for (int c = 0; c < grid_size.width; ++c)
421 {
422 int xl = c * gray_image.cols / grid_size.width;
423 int yl = r * gray_image.rows / grid_size.height;
424 int xr = (c+1) * gray_image.cols / grid_size.width;
425 int yr = (r+1) * gray_image.rows / grid_size.height;
426
427 // LOGLN("OrbFeaturesFinder::find: gray_image.empty=" << (gray_image.empty()?"true":"false") << ", "
428 // << " gray_image.size()=(" << gray_image.size().width << "x" << gray_image.size().height << "), "
429 // << " yl=" << yl << ", yr=" << yr << ", "
430 // << " xl=" << xl << ", xr=" << xr << ", gray_image.data=" << ((size_t)gray_image.data) << ", "
431 // << "gray_image.dims=" << gray_image.dims << "\n");
432
433 UMat gray_image_part=gray_image(Range(yl, yr), Range(xl, xr));
434 // LOGLN("OrbFeaturesFinder::find: gray_image_part.empty=" << (gray_image_part.empty()?"true":"false") << ", "
435 // << " gray_image_part.size()=(" << gray_image_part.size().width << "x" << gray_image_part.size().height << "), "
436 // << " gray_image_part.dims=" << gray_image_part.dims << ", "
437 // << " gray_image_part.data=" << ((size_t)gray_image_part.data) << "\n");
438
439 orb->detectAndCompute(gray_image_part, UMat(), points, descriptors);
440
441 features.keypoints.reserve(features.keypoints.size() + points.size());
442 for (std::vector<KeyPoint>::iterator kp = points.begin(); kp != points.end(); ++kp)
443 {
444 kp->pt.x += xl;
445 kp->pt.y += yl;
446 features.keypoints.push_back(*kp);
447 }
448 _descriptors.push_back(descriptors.getMat(ACCESS_READ));
449 }
450
451 // TODO optimize copyTo()
452 //features.descriptors = _descriptors.getUMat(ACCESS_READ);
453 _descriptors.copyTo(features.descriptors);
454 }
455 }
456
457 #ifdef HAVE_OPENCV_XFEATURES2D
SurfFeaturesFinderGpu(double hess_thresh,int num_octaves,int num_layers,int num_octaves_descr,int num_layers_descr)458 SurfFeaturesFinderGpu::SurfFeaturesFinderGpu(double hess_thresh, int num_octaves, int num_layers,
459 int num_octaves_descr, int num_layers_descr)
460 {
461 surf_.keypointsRatio = 0.1f;
462 surf_.hessianThreshold = hess_thresh;
463 surf_.extended = false;
464 num_octaves_ = num_octaves;
465 num_layers_ = num_layers;
466 num_octaves_descr_ = num_octaves_descr;
467 num_layers_descr_ = num_layers_descr;
468 }
469
470
find(InputArray image,ImageFeatures & features)471 void SurfFeaturesFinderGpu::find(InputArray image, ImageFeatures &features)
472 {
473 CV_Assert(image.depth() == CV_8U);
474
475 ensureSizeIsEnough(image.size(), image.type(), image_);
476 image_.upload(image);
477
478 ensureSizeIsEnough(image.size(), CV_8UC1, gray_image_);
479 cvtColor(image_, gray_image_, COLOR_BGR2GRAY);
480
481 surf_.nOctaves = num_octaves_;
482 surf_.nOctaveLayers = num_layers_;
483 surf_.upright = false;
484 surf_(gray_image_, GpuMat(), keypoints_);
485
486 surf_.nOctaves = num_octaves_descr_;
487 surf_.nOctaveLayers = num_layers_descr_;
488 surf_.upright = true;
489 surf_(gray_image_, GpuMat(), keypoints_, descriptors_, true);
490 surf_.downloadKeypoints(keypoints_, features.keypoints);
491
492 descriptors_.download(features.descriptors);
493 }
494
collectGarbage()495 void SurfFeaturesFinderGpu::collectGarbage()
496 {
497 surf_.releaseMemory();
498 image_.release();
499 gray_image_.release();
500 keypoints_.release();
501 descriptors_.release();
502 }
503 #endif
504
505
506 //////////////////////////////////////////////////////////////////////////////
507
MatchesInfo()508 MatchesInfo::MatchesInfo() : src_img_idx(-1), dst_img_idx(-1), num_inliers(0), confidence(0) {}
509
MatchesInfo(const MatchesInfo & other)510 MatchesInfo::MatchesInfo(const MatchesInfo &other) { *this = other; }
511
operator =(const MatchesInfo & other)512 const MatchesInfo& MatchesInfo::operator =(const MatchesInfo &other)
513 {
514 src_img_idx = other.src_img_idx;
515 dst_img_idx = other.dst_img_idx;
516 matches = other.matches;
517 inliers_mask = other.inliers_mask;
518 num_inliers = other.num_inliers;
519 H = other.H.clone();
520 confidence = other.confidence;
521 return *this;
522 }
523
524
525 //////////////////////////////////////////////////////////////////////////////
526
operator ()(const std::vector<ImageFeatures> & features,std::vector<MatchesInfo> & pairwise_matches,const UMat & mask)527 void FeaturesMatcher::operator ()(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
528 const UMat &mask)
529 {
530 const int num_images = static_cast<int>(features.size());
531
532 CV_Assert(mask.empty() || (mask.type() == CV_8U && mask.cols == num_images && mask.rows));
533 Mat_<uchar> mask_(mask.getMat(ACCESS_READ));
534 if (mask_.empty())
535 mask_ = Mat::ones(num_images, num_images, CV_8U);
536
537 std::vector<std::pair<int,int> > near_pairs;
538 for (int i = 0; i < num_images - 1; ++i)
539 for (int j = i + 1; j < num_images; ++j)
540 if (features[i].keypoints.size() > 0 && features[j].keypoints.size() > 0 && mask_(i, j))
541 near_pairs.push_back(std::make_pair(i, j));
542
543 pairwise_matches.resize(num_images * num_images);
544 MatchPairsBody body(*this, features, pairwise_matches, near_pairs);
545
546 if (is_thread_safe_)
547 parallel_for_(Range(0, static_cast<int>(near_pairs.size())), body);
548 else
549 body(Range(0, static_cast<int>(near_pairs.size())));
550 LOGLN_CHAT("");
551 }
552
553
554 //////////////////////////////////////////////////////////////////////////////
555
BestOf2NearestMatcher(bool try_use_gpu,float match_conf,int num_matches_thresh1,int num_matches_thresh2)556 BestOf2NearestMatcher::BestOf2NearestMatcher(bool try_use_gpu, float match_conf, int num_matches_thresh1, int num_matches_thresh2)
557 {
558 (void)try_use_gpu;
559
560 #ifdef HAVE_OPENCV_CUDAFEATURES2D
561 if (try_use_gpu && getCudaEnabledDeviceCount() > 0)
562 {
563 impl_ = makePtr<GpuMatcher>(match_conf);
564 }
565 else
566 #endif
567 {
568 impl_ = makePtr<CpuMatcher>(match_conf);
569 }
570
571 is_thread_safe_ = impl_->isThreadSafe();
572 num_matches_thresh1_ = num_matches_thresh1;
573 num_matches_thresh2_ = num_matches_thresh2;
574 }
575
576
match(const ImageFeatures & features1,const ImageFeatures & features2,MatchesInfo & matches_info)577 void BestOf2NearestMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2,
578 MatchesInfo &matches_info)
579 {
580 (*impl_)(features1, features2, matches_info);
581
582 // Check if it makes sense to find homography
583 if (matches_info.matches.size() < static_cast<size_t>(num_matches_thresh1_))
584 return;
585
586 // Construct point-point correspondences for homography estimation
587 Mat src_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
588 Mat dst_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
589 for (size_t i = 0; i < matches_info.matches.size(); ++i)
590 {
591 const DMatch& m = matches_info.matches[i];
592
593 Point2f p = features1.keypoints[m.queryIdx].pt;
594 p.x -= features1.img_size.width * 0.5f;
595 p.y -= features1.img_size.height * 0.5f;
596 src_points.at<Point2f>(0, static_cast<int>(i)) = p;
597
598 p = features2.keypoints[m.trainIdx].pt;
599 p.x -= features2.img_size.width * 0.5f;
600 p.y -= features2.img_size.height * 0.5f;
601 dst_points.at<Point2f>(0, static_cast<int>(i)) = p;
602 }
603
604 // Find pair-wise motion
605 matches_info.H = findHomography(src_points, dst_points, matches_info.inliers_mask, RANSAC);
606 if (matches_info.H.empty() || std::abs(determinant(matches_info.H)) < std::numeric_limits<double>::epsilon())
607 return;
608
609 // Find number of inliers
610 matches_info.num_inliers = 0;
611 for (size_t i = 0; i < matches_info.inliers_mask.size(); ++i)
612 if (matches_info.inliers_mask[i])
613 matches_info.num_inliers++;
614
615 // These coeffs are from paper M. Brown and D. Lowe. "Automatic Panoramic Image Stitching
616 // using Invariant Features"
617 matches_info.confidence = matches_info.num_inliers / (8 + 0.3 * matches_info.matches.size());
618
619 // Set zero confidence to remove matches between too close images, as they don't provide
620 // additional information anyway. The threshold was set experimentally.
621 matches_info.confidence = matches_info.confidence > 3. ? 0. : matches_info.confidence;
622
623 // Check if we should try to refine motion
624 if (matches_info.num_inliers < num_matches_thresh2_)
625 return;
626
627 // Construct point-point correspondences for inliers only
628 src_points.create(1, matches_info.num_inliers, CV_32FC2);
629 dst_points.create(1, matches_info.num_inliers, CV_32FC2);
630 int inlier_idx = 0;
631 for (size_t i = 0; i < matches_info.matches.size(); ++i)
632 {
633 if (!matches_info.inliers_mask[i])
634 continue;
635
636 const DMatch& m = matches_info.matches[i];
637
638 Point2f p = features1.keypoints[m.queryIdx].pt;
639 p.x -= features1.img_size.width * 0.5f;
640 p.y -= features1.img_size.height * 0.5f;
641 src_points.at<Point2f>(0, inlier_idx) = p;
642
643 p = features2.keypoints[m.trainIdx].pt;
644 p.x -= features2.img_size.width * 0.5f;
645 p.y -= features2.img_size.height * 0.5f;
646 dst_points.at<Point2f>(0, inlier_idx) = p;
647
648 inlier_idx++;
649 }
650
651 // Rerun motion estimation on inliers only
652 matches_info.H = findHomography(src_points, dst_points, RANSAC);
653 }
654
collectGarbage()655 void BestOf2NearestMatcher::collectGarbage()
656 {
657 impl_->collectGarbage();
658 }
659
660
BestOf2NearestRangeMatcher(int range_width,bool try_use_gpu,float match_conf,int num_matches_thresh1,int num_matches_thresh2)661 BestOf2NearestRangeMatcher::BestOf2NearestRangeMatcher(int range_width, bool try_use_gpu, float match_conf, int num_matches_thresh1, int num_matches_thresh2): BestOf2NearestMatcher(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2)
662 {
663 range_width_ = range_width;
664 }
665
666
operator ()(const std::vector<ImageFeatures> & features,std::vector<MatchesInfo> & pairwise_matches,const UMat & mask)667 void BestOf2NearestRangeMatcher::operator ()(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
668 const UMat &mask)
669 {
670 const int num_images = static_cast<int>(features.size());
671
672 CV_Assert(mask.empty() || (mask.type() == CV_8U && mask.cols == num_images && mask.rows));
673 Mat_<uchar> mask_(mask.getMat(ACCESS_READ));
674 if (mask_.empty())
675 mask_ = Mat::ones(num_images, num_images, CV_8U);
676
677 std::vector<std::pair<int,int> > near_pairs;
678 for (int i = 0; i < num_images - 1; ++i)
679 for (int j = i + 1; j < std::min(num_images, i + range_width_); ++j)
680 if (features[i].keypoints.size() > 0 && features[j].keypoints.size() > 0 && mask_(i, j))
681 near_pairs.push_back(std::make_pair(i, j));
682
683 pairwise_matches.resize(num_images * num_images);
684 MatchPairsBody body(*this, features, pairwise_matches, near_pairs);
685
686 if (is_thread_safe_)
687 parallel_for_(Range(0, static_cast<int>(near_pairs.size())), body);
688 else
689 body(Range(0, static_cast<int>(near_pairs.size())));
690 LOGLN_CHAT("");
691 }
692
693
694 } // namespace detail
695 } // namespace cv
696