OpenCV 4.5.3(日本語機械翻訳)
sparse_matching_gpc.hpp
[詳解]
1 /*
2 By downloading, copying, installing or using the software you agree to this
3 license. If you do not agree to this license, do not download, install,
4 copy or use the software.
5
6
7 License Agreement
8 For Open Source Computer Vision Library
9 (3-clause BSD License)
10
11 Copyright (C) 2016, OpenCV Foundation, all rights reserved.
12 Third party copyrights are property of their respective owners.
13
14 Redistribution and use in source and binary forms, with or without modification,
15 are permitted provided that the following conditions are met:
16
17 * Redistributions of source code must retain the above copyright notice,
18 this list of conditions and the following disclaimer.
19
20 * Redistributions in binary form must reproduce the above copyright notice,
21 this list of conditions and the following disclaimer in the documentation
22 and/or other materials provided with the distribution.
23
24 * Neither the names of the copyright holders nor the names of the contributors
25 may be used to endorse or promote products derived from this software
26 without specific prior written permission.
27
28 This software is provided by the copyright holders and contributors "as is" and
29 any express or implied warranties, including, but not limited to, the implied
30 warranties of merchantability and fitness for a particular purpose are
31 disclaimed. In no event shall copyright holders or contributors be liable for
32 any direct, indirect, incidental, special, exemplary, or consequential damages
33 (including, but not limited to, procurement of substitute goods or services;
34 loss of use, data, or profits; or business interruption) however caused
35 and on any theory of liability, whether in contract, strict liability,
36 or tort (including negligence or otherwise) arising in any way out of
37 the use of this software, even if advised of the possibility of such damage.
38 */
39
51 #ifndef __OPENCV_OPTFLOW_SPARSE_MATCHING_GPC_HPP__
52 #define __OPENCV_OPTFLOW_SPARSE_MATCHING_GPC_HPP__
53
54 #include "opencv2/core.hpp"
55 #include "opencv2/imgproc.hpp"
56
57 namespace cv
58{
59 namespace optflow
60{
61
64
65 struct CV_EXPORTS_W GPCPatchDescriptor
66{
67 static const unsigned nFeatures = 18;
68 Vec< double, nFeatures > feature;
69
70 double dot( const Vec< double, nFeatures > &coef ) const;
71
72 void markAsSeparated() { feature[0] = std::numeric_limits< double >::quiet_NaN(); }
73
74 bool isSeparated() const { return cvIsNaN( feature[0] ) != 0; }
75};
76
77 struct CV_EXPORTS_W GPCPatchSample
78{
79 GPCPatchDescriptor ref;
80 GPCPatchDescriptor pos;
81 GPCPatchDescriptor neg;
82
83 void getDirections( bool &refdir, bool &posdir, bool &negdir, const Vec< double, GPCPatchDescriptor::nFeatures > &coef, double rhs ) const;
84};
85
86 typedef std::vector< GPCPatchSample > GPCSamplesVector;
87
90 enum GPCDescType
91{
92 GPC_DESCRIPTOR_DCT = 0,
93 GPC_DESCRIPTOR_WHT
94 };
95
98 class CV_EXPORTS_W GPCTrainingSamples
99{
100 private:
101 GPCSamplesVector samples;
102 int descriptorType;
103
104 public:
108 static Ptr< GPCTrainingSamples > create( const std::vector< String > &imagesFrom, const std::vector< String > &imagesTo,
109 const std::vector< String > &gt, int descriptorType );
110
111 static Ptr< GPCTrainingSamples > create( InputArrayOfArrays imagesFrom, InputArrayOfArrays imagesTo, InputArrayOfArrays gt,
112 int descriptorType );
113
114 size_t size() const { return samples.size(); }
115
116 int type() const { return descriptorType; }
117
118 operator GPCSamplesVector &() { return samples; }
119};
120
123 struct GPCTrainingParams
124{
125 unsigned maxTreeDepth;
126 int minNumberOfSamples;
127 int descriptorType;
128 bool printProgress;
129
130 GPCTrainingParams( unsigned _maxTreeDepth = 20, int _minNumberOfSamples = 3, GPCDescType _descriptorType = GPC_DESCRIPTOR_DCT,
131 bool _printProgress = true )
132 : maxTreeDepth( _maxTreeDepth ), minNumberOfSamples( _minNumberOfSamples ), descriptorType( _descriptorType ),
133 printProgress( _printProgress )
134 {
135 CV_Assert( check() );
136 }
137
138 bool check() const { return maxTreeDepth > 1 && minNumberOfSamples > 1; }
139};
140
143 struct GPCMatchingParams
144{
145 bool useOpenCL;
146
147 GPCMatchingParams( bool _useOpenCL = false ) : useOpenCL( _useOpenCL ) {}
148
149 GPCMatchingParams( const GPCMatchingParams &params ) : useOpenCL( params.useOpenCL ) {}
150};
151
154 class CV_EXPORTS_W GPCTree : public Algorithm
155{
156 public:
157 struct Node
158 {
159 Vec< double, GPCPatchDescriptor::nFeatures > coef;
160 double rhs;
161 unsigned left;
162 unsigned right;
163
164 bool operator==( const Node &n ) const { return coef == n.coef && rhs == n.rhs && left == n.left && right == n.right; }
165 };
166
167 private:
168 typedef GPCSamplesVector::iterator SIter;
169
170 std::vector< Node > nodes;
171 GPCTrainingParams params;
172
173 bool trainNode( size_t nodeId, SIter begin, SIter end, unsigned depth );
174
175 public:
176 void train( GPCTrainingSamples &samples, const GPCTrainingParams params = GPCTrainingParams() );
177
178 void write( FileStorage &fs ) const CV_OVERRIDE;
179
180 void read( const FileNode &fn ) CV_OVERRIDE;
181
182 unsigned findLeafForPatch( const GPCPatchDescriptor &descr ) const;
183
184 static Ptr< GPCTree > create() { return makePtr< GPCTree >(); }
185
186 bool operator==( const GPCTree &t ) const { return nodes == t.nodes; }
187
188 int getDescriptorType() const { return params.descriptorType; }
189};
190
191 template < int T > class GPCForest : public Algorithm
192{
193 private:
194 struct Trail
195 {
196 unsigned leaf[T];
197 Point2i coord;
198
199 bool operator==( const Trail &trail ) const { return memcmp( leaf, trail.leaf, sizeof( leaf ) ) == 0; }
200
201 bool operator<( const Trail &trail ) const
202 {
203 for ( int i = 0; i < T - 1; ++i )
204 if ( leaf[i] != trail.leaf[i] )
205 return leaf[i] < trail.leaf[i];
206 return leaf[T - 1] < trail.leaf[T - 1];
207 }
208 };
209
210 class ParallelTrailsFilling : public ParallelLoopBody
211 {
212 private:
213 const GPCForest *forest;
214 const std::vector< GPCPatchDescriptor > *descr;
215 std::vector< Trail > *trails;
216
217 ParallelTrailsFilling &operator=( const ParallelTrailsFilling & );
218
219 public:
220 ParallelTrailsFilling( const GPCForest *_forest, const std::vector< GPCPatchDescriptor > *_descr, std::vector< Trail > *_trails )
221 : forest( _forest ), descr( _descr ), trails( _trails ){};
222
223 void operator()( const Range &range ) const CV_OVERRIDE
224 {
225 for ( int t = range.start; t < range.end; ++t )
226 for ( size_t i = 0; i < descr->size(); ++i )
227 trails->at( i ).leaf[t] = forest->tree[t].findLeafForPatch( descr->at( i ) );
228 }
229 };
230
231 GPCTree tree[T];
232
233 public:
237 void train( GPCTrainingSamples &samples, const GPCTrainingParams params = GPCTrainingParams() )
238 {
239 for ( int i = 0; i < T; ++i )
240 tree[i].train( samples, params );
241 }
242
246 void train( const std::vector< String > &imagesFrom, const std::vector< String > &imagesTo, const std::vector< String > &gt,
247 const GPCTrainingParams params = GPCTrainingParams() )
248 {
249 for ( int i = 0; i < T; ++i )
250 {
251 Ptr< GPCTrainingSamples > samples =
252 GPCTrainingSamples::create( imagesFrom, imagesTo, gt, params.descriptorType ); // Create training set for the tree
253 tree[i].train( *samples, params );
254 }
255 }
256
257 void train( InputArrayOfArrays imagesFrom, InputArrayOfArrays imagesTo, InputArrayOfArrays gt,
258 const GPCTrainingParams params = GPCTrainingParams() )
259 {
260 for ( int i = 0; i < T; ++i )
261 {
262 Ptr< GPCTrainingSamples > samples =
263 GPCTrainingSamples::create( imagesFrom, imagesTo, gt, params.descriptorType ); // Create training set for the tree
264 tree[i].train( *samples, params );
265 }
266 }
267
268 void write( FileStorage &fs ) const CV_OVERRIDE
269 {
270 fs << "ntrees" << T << "trees"
271 << "[";
272 for ( int i = 0; i < T; ++i )
273 {
274 fs << "{";
275 tree[i].write( fs );
276 fs << "}";
277 }
278 fs << "]";
279 }
280
281 void read( const FileNode &fn ) CV_OVERRIDE
282 {
283 CV_Assert( T <= (int)fn["ntrees"] );
284 FileNodeIterator it = fn["trees"].begin();
285 for ( int i = 0; i < T; ++i, ++it )
286 tree[i].read( *it );
287 }
288
295 void findCorrespondences( InputArray imgFrom, InputArray imgTo, std::vector< std::pair< Point2i, Point2i > > &corr,
296 const GPCMatchingParams params = GPCMatchingParams() ) const;
297
298 static Ptr< GPCForest > create() { return makePtr< GPCForest >(); }
299};
300
301 class CV_EXPORTS_W GPCDetails
302{
303 public:
304 static void dropOutliers( std::vector< std::pair< Point2i, Point2i > > &corr );
305
306 static void getAllDescriptorsForImage( const Mat *imgCh, std::vector< GPCPatchDescriptor > &descr, const GPCMatchingParams &mp,
307 int type );
308
309 static void getCoordinatesFromIndex( size_t index, Size sz, int &x, int &y );
310};
311
312 template < int T >
313 void GPCForest< T >::findCorrespondences( InputArray imgFrom, InputArray imgTo, std::vector< std::pair< Point2i, Point2i > > &corr,
314 const GPCMatchingParams params ) const
315 {
316 CV_Assert( imgFrom.channels() == 3 );
317 CV_Assert( imgTo.channels() == 3 );
318
319 Mat from, to;
320 imgFrom.getMat().convertTo( from, CV_32FC3 );
321 imgTo.getMat().convertTo( to, CV_32FC3 );
322 cvtColor( from, from, COLOR_BGR2YCrCb );
323 cvtColor( to, to, COLOR_BGR2YCrCb );
324
325 Mat fromCh[3], toCh[3];
326 split( from, fromCh );
327 split( to, toCh );
328
329 std::vector< GPCPatchDescriptor > descr;
330 GPCDetails::getAllDescriptorsForImage( fromCh, descr, params, tree[0].getDescriptorType() );
331 std::vector< Trail > trailsFrom( descr.size() ), trailsTo( descr.size() );
332
333 for ( size_t i = 0; i < descr.size(); ++i )
334 GPCDetails::getCoordinatesFromIndex( i, from.size(), trailsFrom[i].coord.x, trailsFrom[i].coord.y );
335 parallel_for_( Range( 0, T ), ParallelTrailsFilling( this, &descr, &trailsFrom ) );
336
337 descr.clear();
338 GPCDetails::getAllDescriptorsForImage( toCh, descr, params, tree[0].getDescriptorType() );
339
340 for ( size_t i = 0; i < descr.size(); ++i )
341 GPCDetails::getCoordinatesFromIndex( i, to.size(), trailsTo[i].coord.x, trailsTo[i].coord.y );
342 parallel_for_( Range( 0, T ), ParallelTrailsFilling( this, &descr, &trailsTo ) );
343
344 std::sort( trailsFrom.begin(), trailsFrom.end() );
345 std::sort( trailsTo.begin(), trailsTo.end() );
346
347 for ( size_t i = 0; i < trailsFrom.size(); ++i )
348 {
349 bool uniq = true;
350 while ( i + 1 < trailsFrom.size() && trailsFrom[i] == trailsFrom[i + 1] )
351 ++i, uniq = false;
352 if ( uniq )
353 {
354 typename std::vector< Trail >::const_iterator lb = std::lower_bound( trailsTo.begin(), trailsTo.end(), trailsFrom[i] );
355 if ( lb != trailsTo.end() && *lb == trailsFrom[i] && ( ( lb + 1 ) == trailsTo.end() || !( *lb == *( lb + 1 ) ) ) )
356 corr.push_back( std::make_pair( trailsFrom[i].coord, lb->coord ) );
357 }
358 }
359
360 GPCDetails::dropOutliers( corr );
361}
362
364
365} // namespace optflow
366
367CV_EXPORTS void write( FileStorage &fs, const String &name, const optflow::GPCTree::Node &node );
368
369CV_EXPORTS void read( const FileNode &fn, optflow::GPCTree::Node &node, optflow::GPCTree::Node );
370} // namespace cv
371
372 #endif
cv::Algorithm
This is a base class for all more or less complex algorithms in OpenCV
Definition: core.hpp:3091
cv::FileNode
File Storage Node class.
Definition: persistence.hpp:482
cv::FileNodeIterator
used to iterate through sequences and mappings.
Definition: persistence.hpp:634
cv::FileStorage
XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or readi...
Definition: persistence.hpp:304
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Mat::convertTo
void convertTo(OutputArray m, int rtype, double alpha=1, double beta=0) const
Converts an array to another data type with optional scaling.
cv::ParallelLoopBody
Base class for parallel data processors
Definition: utility.hpp:577
cv::Point_< int >
cv::Range
Template class specifying a continuous subsequence (slice) of a sequence.
Definition: core/types.hpp:590
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::Vec
Template class for short numerical vectors, a partial case of Matx
Definition: matx.hpp:342
cv::optflow::GPCDetails
Definition: sparse_matching_gpc.hpp:302
cv::optflow::GPCForest
Definition: sparse_matching_gpc.hpp:192
cv::optflow::GPCForest::write
void write(FileStorage &fs) const CV_OVERRIDE
Stores algorithm parameters in a file storage
Definition: sparse_matching_gpc.hpp:268
cv::optflow::GPCForest::train
void train(const std::vector< String > &imagesFrom, const std::vector< String > &imagesTo, const std::vector< String > &gt, const GPCTrainingParams params=GPCTrainingParams())
Train the forest using individual samples for each tree. It is generally better to use this instead o...
Definition: sparse_matching_gpc.hpp:246
cv::optflow::GPCForest::train
void train(GPCTrainingSamples &samples, const GPCTrainingParams params=GPCTrainingParams())
Train the forest using one sample set for every tree. Please, consider using the next method instead ...
Definition: sparse_matching_gpc.hpp:237
cv::optflow::GPCForest::read
void read(const FileNode &fn) CV_OVERRIDE
Reads algorithm parameters from a file storage
Definition: sparse_matching_gpc.hpp:281
cv::optflow::GPCTrainingSamples
Class encapsulating training samples.
Definition: sparse_matching_gpc.hpp:99
cv::optflow::GPCTrainingSamples::create
static Ptr< GPCTrainingSamples > create(const std::vector< String > &imagesFrom, const std::vector< String > &imagesTo, const std::vector< String > &gt, int descriptorType)
This function can be used to extract samples from a pair of images and a ground truth flow....
cv::optflow::GPCTree
Class for individual tree.
Definition: sparse_matching_gpc.hpp:155
cv::optflow::GPCTree::write
void write(FileStorage &fs) const CV_OVERRIDE
Stores algorithm parameters in a file storage
cv::optflow::GPCTree::read
void read(const FileNode &fn) CV_OVERRIDE
Reads algorithm parameters from a file storage
cv::split
CV_EXPORTS void split(const Mat &src, Mat *mvbegin)
Divides a multi-channel array into several single-channel arrays.
cv::sort
CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags)
Sorts each row or each column of a matrix.
cv::parallel_for_
CV_EXPORTS void parallel_for_(const Range &range, const ParallelLoopBody &body, double nstripes=-1.)
Parallel data processor
cvIsNaN
CV_INLINE int cvIsNaN(double value)
Determines if the argument is Not A Number.
Definition: fast_math.hpp:273
CV_Assert
#define CV_Assert(expr)
Checks a condition at runtime and throws exception if it fails
Definition: base.hpp:342
cv::cvtColor
CV_EXPORTS_W void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0)
Converts an image from one color space to another.
cv::COLOR_BGR2YCrCb
@ COLOR_BGR2YCrCb
convert RGB/BGR to luma-chroma (aka YCC), color conversions
Definition: imgproc.hpp:589
cv::optflow::GPCForest::findCorrespondences
void findCorrespondences(InputArray imgFrom, InputArray imgTo, std::vector< std::pair< Point2i, Point2i > > &corr, const GPCMatchingParams params=GPCMatchingParams()) const
Find correspondences between two images.
Definition: sparse_matching_gpc.hpp:313
cv::optflow::GPCDescType
GPCDescType
Descriptor types for the Global Patch Collider.
Definition: sparse_matching_gpc.hpp:91
cv::optflow::GPC_DESCRIPTOR_DCT
@ GPC_DESCRIPTOR_DCT
Better quality but slow
Definition: sparse_matching_gpc.hpp:92
cv::optflow::GPC_DESCRIPTOR_WHT
@ GPC_DESCRIPTOR_WHT
Worse quality but much faster
Definition: sparse_matching_gpc.hpp:93
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::Ptr
Definition: cvstd_wrapper.hpp:74
cv::optflow::GPCMatchingParams
Class encapsulating matching parameters.
Definition: sparse_matching_gpc.hpp:144
cv::optflow::GPCMatchingParams::useOpenCL
bool useOpenCL
Whether to use OpenCL to speed up the matching.
Definition: sparse_matching_gpc.hpp:145
cv::optflow::GPCPatchDescriptor
Definition: sparse_matching_gpc.hpp:66
cv::optflow::GPCPatchSample
Definition: sparse_matching_gpc.hpp:78
cv::optflow::GPCTrainingParams
Class encapsulating training parameters.
Definition: sparse_matching_gpc.hpp:124
cv::optflow::GPCTrainingParams::maxTreeDepth
unsigned maxTreeDepth
Maximum tree depth to stop partitioning.
Definition: sparse_matching_gpc.hpp:125
cv::optflow::GPCTrainingParams::minNumberOfSamples
int minNumberOfSamples
Minimum number of samples in the node to stop partitioning.
Definition: sparse_matching_gpc.hpp:126
cv::optflow::GPCTrainingParams::printProgress
bool printProgress
Print progress to stdout.
Definition: sparse_matching_gpc.hpp:128
cv::optflow::GPCTrainingParams::descriptorType
int descriptorType
Type of descriptors to use.
Definition: sparse_matching_gpc.hpp:127
cv::optflow::GPCTree::Node
Definition: sparse_matching_gpc.hpp:158
cv::optflow::GPCTree::Node::coef
Vec< double, GPCPatchDescriptor::nFeatures > coef
Hyperplane coefficients
Definition: sparse_matching_gpc.hpp:159
cv::optflow::GPCTree::Node::rhs
double rhs
Bias term of the hyperplane
Definition: sparse_matching_gpc.hpp:160
構築: doxygen 1.9.2