OpenCV 4.5.3(日本語機械翻訳)
motion_estimators.hpp
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 #ifndef OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
44 #define OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
45
46 #include "opencv2/core.hpp"
47 #include "matchers.hpp"
48 #include "util.hpp"
49 #include "camera.hpp"
50
51 namespace cv {
52 namespace detail {
53
56
65 class CV_EXPORTS_W Estimator
66{
67 public:
68 virtual ~Estimator() {}
69
77 CV_WRAP_AS(apply) bool operator ()(const std::vector<ImageFeatures> &features,
78 const std::vector<MatchesInfo> &pairwise_matches,
79 CV_OUT CV_IN_OUT std::vector<CameraParams> &cameras)
80 {
81 return estimate(features, pairwise_matches, cameras);
82 }
83
84 protected:
93 virtual bool estimate(const std::vector<ImageFeatures> &features,
94 const std::vector<MatchesInfo> &pairwise_matches,
95 CV_OUT std::vector<CameraParams> &cameras) = 0;
96};
97
100 class CV_EXPORTS_W HomographyBasedEstimator : public Estimator
101{
102 public:
103 CV_WRAP HomographyBasedEstimator(bool is_focals_estimated = false)
104 : is_focals_estimated_(is_focals_estimated) {}
105
106 private:
107 virtual bool estimate(const std::vector<ImageFeatures> &features,
108 const std::vector<MatchesInfo> &pairwise_matches,
109 std::vector<CameraParams> &cameras) CV_OVERRIDE;
110
111 bool is_focals_estimated_;
112};
113
121 class CV_EXPORTS_W AffineBasedEstimator : public Estimator
122{
123 public:
124 CV_WRAP AffineBasedEstimator(){}
125 private:
126 virtual bool estimate(const std::vector<ImageFeatures> &features,
127 const std::vector<MatchesInfo> &pairwise_matches,
128 std::vector<CameraParams> &cameras) CV_OVERRIDE;
129};
130
133 class CV_EXPORTS_W BundleAdjusterBase : public Estimator
134{
135 public:
136 CV_WRAP const Mat refinementMask() const { return refinement_mask_.clone(); }
137 CV_WRAP void setRefinementMask(const Mat &mask)
138 {
139 CV_Assert(mask.type() == CV_8U && mask.size() == Size(3, 3));
140 refinement_mask_ = mask.clone();
141 }
142
143 CV_WRAP double confThresh() const { return conf_thresh_; }
144 CV_WRAP void setConfThresh(double conf_thresh) { conf_thresh_ = conf_thresh; }
145
146 CV_WRAP TermCriteria termCriteria() { return term_criteria_; }
147 CV_WRAP void setTermCriteria(const TermCriteria& term_criteria) { term_criteria_ = term_criteria; }
148
149 protected:
155 BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement)
156 : num_images_(0), total_num_matches_(0),
157 num_params_per_cam_(num_params_per_cam),
158 num_errs_per_measurement_(num_errs_per_measurement),
159 features_(0), pairwise_matches_(0), conf_thresh_(0)
160 {
161 setRefinementMask(Mat::ones(3, 3, CV_8U));
162 setConfThresh(1.);
163 setTermCriteria(TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 1000, DBL_EPSILON));
164 }
165
166 // Runs bundle adjustment
167 virtual bool estimate(const std::vector<ImageFeatures> &features,
168 const std::vector<MatchesInfo> &pairwise_matches,
169 std::vector<CameraParams> &cameras) CV_OVERRIDE;
170
175 virtual void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) = 0;
180 virtual void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const = 0;
185 virtual void calcError(Mat &err) = 0;
191 virtual void calcJacobian(Mat &jac) = 0;
192
193 // 3x3 8U mask, where 0 means don't refine respective parameter, != 0 means refine
194 Mat refinement_mask_;
195
196 int num_images_;
197 int total_num_matches_;
198
199 int num_params_per_cam_;
200 int num_errs_per_measurement_;
201
202 const ImageFeatures *features_;
203 const MatchesInfo *pairwise_matches_;
204
205 // Threshold to filter out poorly matched image pairs
206 double conf_thresh_;
207
208 //Levenberg-Marquardt algorithm termination criteria
209 TermCriteria term_criteria_;
210
211 // Camera parameters matrix (CV_64F)
212 Mat cam_params_;
213
214 // Connected images pairs
215 std::vector<std::pair<int,int> > edges_;
216};
217
218
221 class CV_EXPORTS_W NoBundleAdjuster : public BundleAdjusterBase
222{
223 public:
224 CV_WRAP NoBundleAdjuster() : BundleAdjusterBase(0, 0) {}
225
226 private:
227 bool estimate(const std::vector<ImageFeatures> &, const std::vector<MatchesInfo> &,
228 std::vector<CameraParams> &) CV_OVERRIDE
229 {
230 return true;
231 }
232 void setUpInitialCameraParams(const std::vector<CameraParams> &) CV_OVERRIDE {}
233 void obtainRefinedCameraParams(std::vector<CameraParams> &) const CV_OVERRIDE {}
234 void calcError(Mat &) CV_OVERRIDE {}
235 void calcJacobian(Mat &) CV_OVERRIDE {}
236};
237
238
245 class CV_EXPORTS_W BundleAdjusterReproj : public BundleAdjusterBase
246{
247 public:
248 CV_WRAP BundleAdjusterReproj() : BundleAdjusterBase(7, 2) {}
249
250 private:
251 void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
252 void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
253 void calcError(Mat &err) CV_OVERRIDE;
254 void calcJacobian(Mat &jac) CV_OVERRIDE;
255
256 Mat err1_, err2_;
257};
258
259
265 class CV_EXPORTS_W BundleAdjusterRay : public BundleAdjusterBase
266{
267 public:
268 CV_WRAP BundleAdjusterRay() : BundleAdjusterBase(4, 3) {}
269
270 private:
271 void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
272 void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
273 void calcError(Mat &err) CV_OVERRIDE;
274 void calcJacobian(Mat &jac) CV_OVERRIDE;
275
276 Mat err1_, err2_;
277};
278
279
289 class CV_EXPORTS_W BundleAdjusterAffine : public BundleAdjusterBase
290{
291 public:
292 CV_WRAP BundleAdjusterAffine() : BundleAdjusterBase(6, 2) {}
293
294 private:
295 void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
296 void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
297 void calcError(Mat &err) CV_OVERRIDE;
298 void calcJacobian(Mat &jac) CV_OVERRIDE;
299
300 Mat err1_, err2_;
301};
302
303
313 class CV_EXPORTS_W BundleAdjusterAffinePartial : public BundleAdjusterBase
314{
315 public:
316 CV_WRAP BundleAdjusterAffinePartial() : BundleAdjusterBase(4, 2) {}
317
318 private:
319 void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
320 void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
321 void calcError(Mat &err) CV_OVERRIDE;
322 void calcJacobian(Mat &jac) CV_OVERRIDE;
323
324 Mat err1_, err2_;
325};
326
327
328 enum WaveCorrectKind
329{
330 WAVE_CORRECT_HORIZ,
331 WAVE_CORRECT_VERT,
332 WAVE_CORRECT_AUTO
333};
334
341CV_EXPORTS
342 WaveCorrectKind autoDetectWaveCorrectKind(const std::vector<Mat> &rmats);
343
349 void CV_EXPORTS_W waveCorrect(CV_IN_OUT std::vector<Mat> &rmats, WaveCorrectKind kind);
350
351
353 // Auxiliary functions
354
355 // Returns matches graph representation in DOT language
356String CV_EXPORTS_W matchesGraphAsString(std::vector<String> &pathes, std::vector<MatchesInfo> &pairwise_matches,
357 float conf_threshold);
358
359CV_EXPORTS_W std::vector<int> leaveBiggestComponent(
360 std::vector<ImageFeatures> &features,
361 std::vector<MatchesInfo> &pairwise_matches,
362 float conf_threshold);
363
364 void CV_EXPORTS findMaxSpanningTree(
365 int num_images, const std::vector<MatchesInfo> &pairwise_matches,
366 Graph &span_tree, std::vector<int> &centers);
367
369
370} // namespace detail
371} // namespace cv
372
373 #endif // OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Mat::ones
static MatExpr ones(int rows, int cols, int type)
Returns an array of all 1's of the specified size and type.
cv::Mat::clone
Mat clone() const CV_NODISCARD
Creates a full copy of the array and the underlying data.
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::TermCriteria::EPS
@ EPS
the desired accuracy or change in parameters at which the iterative algorithm stops
Definition: core/types.hpp:862
cv::TermCriteria::COUNT
@ COUNT
the maximum number of iterations or elements to compute
Definition: core/types.hpp:860
cv::detail::AffineBasedEstimator
Affine transformation based estimator.
Definition: motion_estimators.hpp:122
cv::detail::BundleAdjusterAffine
Bundle adjuster that expects affine transformation represented in homogeneous coordinates in R for ea...
Definition: motion_estimators.hpp:290
cv::detail::BundleAdjusterAffinePartial
Bundle adjuster that expects affine transformation with 4 DOF represented in homogeneous coordinates ...
Definition: motion_estimators.hpp:314
cv::detail::BundleAdjusterBase
Base class for all camera parameters refinement methods.
Definition: motion_estimators.hpp:134
cv::detail::BundleAdjusterBase::calcJacobian
virtual void calcJacobian(Mat &jac)=0
Calculates the cost function jacobian.
cv::detail::BundleAdjusterBase::BundleAdjusterBase
BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement)
Construct a bundle adjuster base instance.
Definition: motion_estimators.hpp:155
cv::detail::BundleAdjusterBase::setUpInitialCameraParams
virtual void setUpInitialCameraParams(const std::vector< CameraParams > &cameras)=0
Sets initial camera parameter to refine.
cv::detail::BundleAdjusterBase::calcError
virtual void calcError(Mat &err)=0
Calculates error vector.
cv::detail::BundleAdjusterBase::obtainRefinedCameraParams
virtual void obtainRefinedCameraParams(std::vector< CameraParams > &cameras) const =0
Gets the refined camera parameters.
cv::detail::BundleAdjusterRay
Implementation of the camera parameters refinement algorithm which minimizes sum of the distances bet...
Definition: motion_estimators.hpp:266
cv::detail::BundleAdjusterReproj
Implementation of the camera parameters refinement algorithm which minimizes sum of the reprojection ...
Definition: motion_estimators.hpp:246
cv::detail::Estimator
Rotation estimator base class.
Definition: motion_estimators.hpp:66
cv::detail::Estimator::estimate
virtual bool estimate(const std::vector< ImageFeatures > &features, const std::vector< MatchesInfo > &pairwise_matches, CV_OUT std::vector< CameraParams > &cameras)=0
This method must implement camera parameters estimation logic in order to make the wrapper detail::Es...
cv::detail::Estimator::CV_WRAP_AS
CV_WRAP_AS(apply) bool operator()(const std
Estimates camera parameters.
Definition: motion_estimators.hpp:77
cv::detail::Graph
Definition: util.hpp:86
cv::detail::HomographyBasedEstimator
Homography based rotation estimator.
Definition: motion_estimators.hpp:101
cv::detail::NoBundleAdjuster
Stub bundle adjuster that does nothing.
Definition: motion_estimators.hpp:222
CV_Assert
#define CV_Assert(expr)
Checks a condition at runtime and throws exception if it fails
Definition: base.hpp:342
cv::detail::autoDetectWaveCorrectKind
CV_EXPORTS WaveCorrectKind autoDetectWaveCorrectKind(const std::vector< Mat > &rmats)
Tries to detect the wave correction kind depending on whether a panorama spans horizontally or vertic...
cv::detail::waveCorrect
void CV_EXPORTS_W waveCorrect(CV_IN_OUT std::vector< Mat > &rmats, WaveCorrectKind kind)
Tries to make panorama more horizontal (or vertical).
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::detail::ImageFeatures
Structure containing image keypoints and descriptors.
Definition: matchers.hpp:59
cv::detail::MatchesInfo
Structure containing information about matches between two images.
Definition: matchers.hpp:100
構築: doxygen 1.9.2