OpenCV 2.4.8 components for OpenCVgrabber.
[mmanager-3rdparty.git] / OpenCV2.4.8 / build / include / opencv2 / gpu / gpu.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_GPU_HPP__
44 #define __OPENCV_GPU_HPP__
45
46 #ifndef SKIP_INCLUDES
47 #include <vector>
48 #include <memory>
49 #include <iosfwd>
50 #endif
51
52 #include "opencv2/core/gpumat.hpp"
53 #include "opencv2/imgproc/imgproc.hpp"
54 #include "opencv2/objdetect/objdetect.hpp"
55 #include "opencv2/features2d/features2d.hpp"
56
57 namespace cv { namespace gpu {
58
59 //////////////////////////////// CudaMem ////////////////////////////////
60 // CudaMem is limited cv::Mat with page locked memory allocation.
61 // Page locked memory is only needed for async and faster coping to GPU.
62 // It is convertable to cv::Mat header without reference counting
63 // so you can use it with other opencv functions.
64
65 // Page-locks the matrix m memory and maps it for the device(s)
66 CV_EXPORTS void registerPageLocked(Mat& m);
67 // Unmaps the memory of matrix m, and makes it pageable again.
68 CV_EXPORTS void unregisterPageLocked(Mat& m);
69
70 class CV_EXPORTS CudaMem
71 {
72 public:
73     enum  { ALLOC_PAGE_LOCKED = 1, ALLOC_ZEROCOPY = 2, ALLOC_WRITE_COMBINED = 4 };
74
75     CudaMem();
76     CudaMem(const CudaMem& m);
77
78     CudaMem(int rows, int cols, int type, int _alloc_type = ALLOC_PAGE_LOCKED);
79     CudaMem(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED);
80
81
82     //! creates from cv::Mat with coping data
83     explicit CudaMem(const Mat& m, int alloc_type = ALLOC_PAGE_LOCKED);
84
85     ~CudaMem();
86
87     CudaMem& operator = (const CudaMem& m);
88
89     //! returns deep copy of the matrix, i.e. the data is copied
90     CudaMem clone() const;
91
92     //! allocates new matrix data unless the matrix already has specified size and type.
93     void create(int rows, int cols, int type, int alloc_type = ALLOC_PAGE_LOCKED);
94     void create(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED);
95
96     //! decrements reference counter and released memory if needed.
97     void release();
98
99     //! returns matrix header with disabled reference counting for CudaMem data.
100     Mat createMatHeader() const;
101     operator Mat() const;
102
103     //! maps host memory into device address space and returns GpuMat header for it. Throws exception if not supported by hardware.
104     GpuMat createGpuMatHeader() const;
105     operator GpuMat() const;
106
107     //returns if host memory can be mapperd to gpu address space;
108     static bool canMapHostMemory();
109
110     // Please see cv::Mat for descriptions
111     bool isContinuous() const;
112     size_t elemSize() const;
113     size_t elemSize1() const;
114     int type() const;
115     int depth() const;
116     int channels() const;
117     size_t step1() const;
118     Size size() const;
119     bool empty() const;
120
121
122     // Please see cv::Mat for descriptions
123     int flags;
124     int rows, cols;
125     size_t step;
126
127     uchar* data;
128     int* refcount;
129
130     uchar* datastart;
131     uchar* dataend;
132
133     int alloc_type;
134 };
135
136 //////////////////////////////// CudaStream ////////////////////////////////
137 // Encapculates Cuda Stream. Provides interface for async coping.
138 // Passed to each function that supports async kernel execution.
139 // Reference counting is enabled
140
141 class CV_EXPORTS Stream
142 {
143 public:
144     Stream();
145     ~Stream();
146
147     Stream(const Stream&);
148     Stream& operator =(const Stream&);
149
150     bool queryIfComplete();
151     void waitForCompletion();
152
153     //! downloads asynchronously
154     // Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its subMat)
155     void enqueueDownload(const GpuMat& src, CudaMem& dst);
156     void enqueueDownload(const GpuMat& src, Mat& dst);
157
158     //! uploads asynchronously
159     // Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its ROI)
160     void enqueueUpload(const CudaMem& src, GpuMat& dst);
161     void enqueueUpload(const Mat& src, GpuMat& dst);
162
163     //! copy asynchronously
164     void enqueueCopy(const GpuMat& src, GpuMat& dst);
165
166     //! memory set asynchronously
167     void enqueueMemSet(GpuMat& src, Scalar val);
168     void enqueueMemSet(GpuMat& src, Scalar val, const GpuMat& mask);
169
170     //! converts matrix type, ex from float to uchar depending on type
171     void enqueueConvert(const GpuMat& src, GpuMat& dst, int dtype, double a = 1, double b = 0);
172
173     //! adds a callback to be called on the host after all currently enqueued items in the stream have completed
174     typedef void (*StreamCallback)(Stream& stream, int status, void* userData);
175     void enqueueHostCallback(StreamCallback callback, void* userData);
176
177     static Stream& Null();
178
179     operator bool() const;
180
181 private:
182     struct Impl;
183
184     explicit Stream(Impl* impl);
185     void create();
186     void release();
187
188     Impl *impl;
189
190     friend struct StreamAccessor;
191 };
192
193
194 //////////////////////////////// Filter Engine ////////////////////////////////
195
196 /*!
197 The Base Class for 1D or Row-wise Filters
198
199 This is the base class for linear or non-linear filters that process 1D data.
200 In particular, such filters are used for the "horizontal" filtering parts in separable filters.
201 */
202 class CV_EXPORTS BaseRowFilter_GPU
203 {
204 public:
205     BaseRowFilter_GPU(int ksize_, int anchor_) : ksize(ksize_), anchor(anchor_) {}
206     virtual ~BaseRowFilter_GPU() {}
207     virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
208     int ksize, anchor;
209 };
210
211 /*!
212 The Base Class for Column-wise Filters
213
214 This is the base class for linear or non-linear filters that process columns of 2D arrays.
215 Such filters are used for the "vertical" filtering parts in separable filters.
216 */
217 class CV_EXPORTS BaseColumnFilter_GPU
218 {
219 public:
220     BaseColumnFilter_GPU(int ksize_, int anchor_) : ksize(ksize_), anchor(anchor_) {}
221     virtual ~BaseColumnFilter_GPU() {}
222     virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
223     int ksize, anchor;
224 };
225
226 /*!
227 The Base Class for Non-Separable 2D Filters.
228
229 This is the base class for linear or non-linear 2D filters.
230 */
231 class CV_EXPORTS BaseFilter_GPU
232 {
233 public:
234     BaseFilter_GPU(const Size& ksize_, const Point& anchor_) : ksize(ksize_), anchor(anchor_) {}
235     virtual ~BaseFilter_GPU() {}
236     virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null()) = 0;
237     Size ksize;
238     Point anchor;
239 };
240
241 /*!
242 The Base Class for Filter Engine.
243
244 The class can be used to apply an arbitrary filtering operation to an image.
245 It contains all the necessary intermediate buffers.
246 */
247 class CV_EXPORTS FilterEngine_GPU
248 {
249 public:
250     virtual ~FilterEngine_GPU() {}
251
252     virtual void apply(const GpuMat& src, GpuMat& dst, Rect roi = Rect(0,0,-1,-1), Stream& stream = Stream::Null()) = 0;
253 };
254
255 //! returns the non-separable filter engine with the specified filter
256 CV_EXPORTS Ptr<FilterEngine_GPU> createFilter2D_GPU(const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType);
257
258 //! returns the separable filter engine with the specified filters
259 CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU>& rowFilter,
260     const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType);
261 CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU>& rowFilter,
262     const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType, GpuMat& buf);
263
264 //! returns horizontal 1D box filter
265 //! supports only CV_8UC1 source type and CV_32FC1 sum type
266 CV_EXPORTS Ptr<BaseRowFilter_GPU> getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1);
267
268 //! returns vertical 1D box filter
269 //! supports only CV_8UC1 sum type and CV_32FC1 dst type
270 CV_EXPORTS Ptr<BaseColumnFilter_GPU> getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1);
271
272 //! returns 2D box filter
273 //! supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type
274 CV_EXPORTS Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1));
275
276 //! returns box filter engine
277 CV_EXPORTS Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size& ksize,
278     const Point& anchor = Point(-1,-1));
279
280 //! returns 2D morphological filter
281 //! only MORPH_ERODE and MORPH_DILATE are supported
282 //! supports CV_8UC1 and CV_8UC4 types
283 //! kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
284 CV_EXPORTS Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize,
285     Point anchor=Point(-1,-1));
286
287 //! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
288 CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat& kernel,
289     const Point& anchor = Point(-1,-1), int iterations = 1);
290 CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat& kernel, GpuMat& buf,
291     const Point& anchor = Point(-1,-1), int iterations = 1);
292
293 //! returns 2D filter with the specified kernel
294 //! supports CV_8U, CV_16U and CV_32F one and four channel image
295 CV_EXPORTS Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
296
297 //! returns the non-separable linear filter engine
298 CV_EXPORTS Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel,
299     Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT);
300
301 //! returns the primitive row filter with the specified kernel.
302 //! supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 source type.
303 //! there are two version of algorithm: NPP and OpenCV.
304 //! NPP calls when srcType == CV_8UC1 or srcType == CV_8UC4 and bufType == srcType,
305 //! otherwise calls OpenCV version.
306 //! NPP supports only BORDER_CONSTANT border type.
307 //! OpenCV version supports only CV_32F as buffer depth and
308 //! BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.
309 CV_EXPORTS Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel,
310     int anchor = -1, int borderType = BORDER_DEFAULT);
311
312 //! returns the primitive column filter with the specified kernel.
313 //! supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 dst type.
314 //! there are two version of algorithm: NPP and OpenCV.
315 //! NPP calls when dstType == CV_8UC1 or dstType == CV_8UC4 and bufType == dstType,
316 //! otherwise calls OpenCV version.
317 //! NPP supports only BORDER_CONSTANT border type.
318 //! OpenCV version supports only CV_32F as buffer depth and
319 //! BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.
320 CV_EXPORTS Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel,
321     int anchor = -1, int borderType = BORDER_DEFAULT);
322
323 //! returns the separable linear filter engine
324 CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel,
325     const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT,
326     int columnBorderType = -1);
327 CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel,
328     const Mat& columnKernel, GpuMat& buf, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT,
329     int columnBorderType = -1);
330
331 //! returns filter engine for the generalized Sobel operator
332 CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize,
333                                                        int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
334 CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, GpuMat& buf,
335                                                        int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
336
337 //! returns the Gaussian filter engine
338 CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigma1, double sigma2 = 0,
339                                                           int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
340 CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, GpuMat& buf, double sigma1, double sigma2 = 0,
341                                                           int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
342
343 //! returns maximum filter
344 CV_EXPORTS Ptr<BaseFilter_GPU> getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1));
345
346 //! returns minimum filter
347 CV_EXPORTS Ptr<BaseFilter_GPU> getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1));
348
349 //! smooths the image using the normalized box filter
350 //! supports CV_8UC1, CV_8UC4 types
351 CV_EXPORTS void boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), Stream& stream = Stream::Null());
352
353 //! a synonym for normalized box filter
354 static inline void blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1), Stream& stream = Stream::Null())
355 {
356     boxFilter(src, dst, -1, ksize, anchor, stream);
357 }
358
359 //! erodes the image (applies the local minimum operator)
360 CV_EXPORTS void erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
361 CV_EXPORTS void erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, GpuMat& buf,
362                       Point anchor = Point(-1, -1), int iterations = 1,
363                       Stream& stream = Stream::Null());
364
365 //! dilates the image (applies the local maximum operator)
366 CV_EXPORTS void dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
367 CV_EXPORTS void dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, GpuMat& buf,
368                        Point anchor = Point(-1, -1), int iterations = 1,
369                        Stream& stream = Stream::Null());
370
371 //! applies an advanced morphological operation to the image
372 CV_EXPORTS void morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1);
373 CV_EXPORTS void morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, GpuMat& buf1, GpuMat& buf2,
374                              Point anchor = Point(-1, -1), int iterations = 1, Stream& stream = Stream::Null());
375
376 //! applies non-separable 2D linear filter to the image
377 CV_EXPORTS void filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1), int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null());
378
379 //! applies separable 2D linear filter to the image
380 CV_EXPORTS void sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY,
381                             Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
382 CV_EXPORTS void sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, GpuMat& buf,
383                             Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1,
384                             Stream& stream = Stream::Null());
385
386 //! applies generalized Sobel operator to the image
387 CV_EXPORTS void Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1,
388                       int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
389 CV_EXPORTS void Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, int ksize = 3, double scale = 1,
390                       int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
391
392 //! applies the vertical or horizontal Scharr operator to the image
393 CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1,
394                        int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
395 CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, double scale = 1,
396                        int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
397
398 //! smooths the image using Gaussian filter.
399 CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigma1, double sigma2 = 0,
400                              int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1);
401 CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, GpuMat& buf, double sigma1, double sigma2 = 0,
402                              int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1, Stream& stream = Stream::Null());
403
404 //! applies Laplacian operator to the image
405 //! supports only ksize = 1 and ksize = 3
406 CV_EXPORTS void Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1, int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null());
407
408
409 ////////////////////////////// Arithmetics ///////////////////////////////////
410
411 //! implements generalized matrix product algorithm GEMM from BLAS
412 CV_EXPORTS void gemm(const GpuMat& src1, const GpuMat& src2, double alpha,
413     const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null());
414
415 //! transposes the matrix
416 //! supports matrix with element size = 1, 4 and 8 bytes (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc)
417 CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst, Stream& stream = Stream::Null());
418
419 //! reverses the order of the rows, columns or both in a matrix
420 //! supports 1, 3 and 4 channels images with CV_8U, CV_16U, CV_32S or CV_32F depth
421 CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode, Stream& stream = Stream::Null());
422
423 //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
424 //! destination array will have the depth type as lut and the same channels number as source
425 //! supports CV_8UC1, CV_8UC3 types
426 CV_EXPORTS void LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null());
427
428 //! makes multi-channel array out of several single-channel arrays
429 CV_EXPORTS void merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null());
430
431 //! makes multi-channel array out of several single-channel arrays
432 CV_EXPORTS void merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());
433
434 //! copies each plane of a multi-channel array to a dedicated array
435 CV_EXPORTS void split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null());
436
437 //! copies each plane of a multi-channel array to a dedicated array
438 CV_EXPORTS void split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null());
439
440 //! computes magnitude of complex (x(i).re, x(i).im) vector
441 //! supports only CV_32FC2 type
442 CV_EXPORTS void magnitude(const GpuMat& xy, GpuMat& magnitude, Stream& stream = Stream::Null());
443
444 //! computes squared magnitude of complex (x(i).re, x(i).im) vector
445 //! supports only CV_32FC2 type
446 CV_EXPORTS void magnitudeSqr(const GpuMat& xy, GpuMat& magnitude, Stream& stream = Stream::Null());
447
448 //! computes magnitude of each (x(i), y(i)) vector
449 //! supports only floating-point source
450 CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
451
452 //! computes squared magnitude of each (x(i), y(i)) vector
453 //! supports only floating-point source
454 CV_EXPORTS void magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
455
456 //! computes angle (angle(i)) of each (x(i), y(i)) vector
457 //! supports only floating-point source
458 CV_EXPORTS void phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
459
460 //! converts Cartesian coordinates to polar
461 //! supports only floating-point source
462 CV_EXPORTS void cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
463
464 //! converts polar coordinates to Cartesian
465 //! supports only floating-point source
466 CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees = false, Stream& stream = Stream::Null());
467
468 //! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
469 CV_EXPORTS void normalize(const GpuMat& src, GpuMat& dst, double alpha = 1, double beta = 0,
470                           int norm_type = NORM_L2, int dtype = -1, const GpuMat& mask = GpuMat());
471 CV_EXPORTS void normalize(const GpuMat& src, GpuMat& dst, double a, double b,
472                           int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf);
473
474
475 //////////////////////////// Per-element operations ////////////////////////////////////
476
477 //! adds one matrix to another (c = a + b)
478 CV_EXPORTS void add(const GpuMat& a, const GpuMat& b, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
479 //! adds scalar to a matrix (c = a + s)
480 CV_EXPORTS void add(const GpuMat& a, const Scalar& sc, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
481
482 //! subtracts one matrix from another (c = a - b)
483 CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
484 //! subtracts scalar from a matrix (c = a - s)
485 CV_EXPORTS void subtract(const GpuMat& a, const Scalar& sc, GpuMat& c, const GpuMat& mask = GpuMat(), int dtype = -1, Stream& stream = Stream::Null());
486
487 //! computes element-wise weighted product of the two arrays (c = scale * a * b)
488 CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
489 //! weighted multiplies matrix to a scalar (c = scale * a * s)
490 CV_EXPORTS void multiply(const GpuMat& a, const Scalar& sc, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
491
492 //! computes element-wise weighted quotient of the two arrays (c = a / b)
493 CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
494 //! computes element-wise weighted quotient of matrix and scalar (c = a / s)
495 CV_EXPORTS void divide(const GpuMat& a, const Scalar& sc, GpuMat& c, double scale = 1, int dtype = -1, Stream& stream = Stream::Null());
496 //! computes element-wise weighted reciprocal of an array (dst = scale/src2)
497 CV_EXPORTS void divide(double scale, const GpuMat& b, GpuMat& c, int dtype = -1, Stream& stream = Stream::Null());
498
499 //! computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
500 CV_EXPORTS void addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2, double beta, double gamma, GpuMat& dst,
501                             int dtype = -1, Stream& stream = Stream::Null());
502
503 //! adds scaled array to another one (dst = alpha*src1 + src2)
504 static inline void scaleAdd(const GpuMat& src1, double alpha, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null())
505 {
506     addWeighted(src1, alpha, src2, 1.0, 0.0, dst, -1, stream);
507 }
508
509 //! computes element-wise absolute difference of two arrays (c = abs(a - b))
510 CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
511 //! computes element-wise absolute difference of array and scalar (c = abs(a - s))
512 CV_EXPORTS void absdiff(const GpuMat& a, const Scalar& s, GpuMat& c, Stream& stream = Stream::Null());
513
514 //! computes absolute value of each matrix element
515 //! supports CV_16S and CV_32F depth
516 CV_EXPORTS void abs(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
517
518 //! computes square of each pixel in an image
519 //! supports CV_8U, CV_16U, CV_16S and CV_32F depth
520 CV_EXPORTS void sqr(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
521
522 //! computes square root of each pixel in an image
523 //! supports CV_8U, CV_16U, CV_16S and CV_32F depth
524 CV_EXPORTS void sqrt(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
525
526 //! computes exponent of each matrix element (b = e**a)
527 //! supports CV_8U, CV_16U, CV_16S and CV_32F depth
528 CV_EXPORTS void exp(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
529
530 //! computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
531 //! supports CV_8U, CV_16U, CV_16S and CV_32F depth
532 CV_EXPORTS void log(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
533
534 //! computes power of each matrix element:
535 //    (dst(i,j) = pow(     src(i,j) , power), if src.type() is integer
536 //    (dst(i,j) = pow(fabs(src(i,j)), power), otherwise
537 //! supports all, except depth == CV_64F
538 CV_EXPORTS void pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream = Stream::Null());
539
540 //! compares elements of two arrays (c = a <cmpop> b)
541 CV_EXPORTS void compare(const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
542 CV_EXPORTS void compare(const GpuMat& a, Scalar sc, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
543
544 //! performs per-elements bit-wise inversion
545 CV_EXPORTS void bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
546
547 //! calculates per-element bit-wise disjunction of two arrays
548 CV_EXPORTS void bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
549 //! calculates per-element bit-wise disjunction of array and scalar
550 //! supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth
551 CV_EXPORTS void bitwise_or(const GpuMat& src1, const Scalar& sc, GpuMat& dst, Stream& stream = Stream::Null());
552
553 //! calculates per-element bit-wise conjunction of two arrays
554 CV_EXPORTS void bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
555 //! calculates per-element bit-wise conjunction of array and scalar
556 //! supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth
557 CV_EXPORTS void bitwise_and(const GpuMat& src1, const Scalar& sc, GpuMat& dst, Stream& stream = Stream::Null());
558
559 //! calculates per-element bit-wise "exclusive or" operation
560 CV_EXPORTS void bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
561 //! calculates per-element bit-wise "exclusive or" of array and scalar
562 //! supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth
563 CV_EXPORTS void bitwise_xor(const GpuMat& src1, const Scalar& sc, GpuMat& dst, Stream& stream = Stream::Null());
564
565 //! pixel by pixel right shift of an image by a constant value
566 //! supports 1, 3 and 4 channels images with integers elements
567 CV_EXPORTS void rshift(const GpuMat& src, Scalar_<int> sc, GpuMat& dst, Stream& stream = Stream::Null());
568
569 //! pixel by pixel left shift of an image by a constant value
570 //! supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth
571 CV_EXPORTS void lshift(const GpuMat& src, Scalar_<int> sc, GpuMat& dst, Stream& stream = Stream::Null());
572
573 //! computes per-element minimum of two arrays (dst = min(src1, src2))
574 CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
575
576 //! computes per-element minimum of array and scalar (dst = min(src1, src2))
577 CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
578
579 //! computes per-element maximum of two arrays (dst = max(src1, src2))
580 CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
581
582 //! computes per-element maximum of array and scalar (dst = max(src1, src2))
583 CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
584
585 enum { ALPHA_OVER, ALPHA_IN, ALPHA_OUT, ALPHA_ATOP, ALPHA_XOR, ALPHA_PLUS, ALPHA_OVER_PREMUL, ALPHA_IN_PREMUL, ALPHA_OUT_PREMUL,
586        ALPHA_ATOP_PREMUL, ALPHA_XOR_PREMUL, ALPHA_PLUS_PREMUL, ALPHA_PREMUL};
587
588 //! Composite two images using alpha opacity values contained in each image
589 //! Supports CV_8UC4, CV_16UC4, CV_32SC4 and CV_32FC4 types
590 CV_EXPORTS void alphaComp(const GpuMat& img1, const GpuMat& img2, GpuMat& dst, int alpha_op, Stream& stream = Stream::Null());
591
592
593 ////////////////////////////// Image processing //////////////////////////////
594
595 //! DST[x,y] = SRC[xmap[x,y],ymap[x,y]]
596 //! supports only CV_32FC1 map type
597 CV_EXPORTS void remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap,
598                       int interpolation, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar(),
599                       Stream& stream = Stream::Null());
600
601 //! Does mean shift filtering on GPU.
602 CV_EXPORTS void meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
603                                    TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1),
604                                    Stream& stream = Stream::Null());
605
606 //! Does mean shift procedure on GPU.
607 CV_EXPORTS void meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr,
608                               TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1),
609                               Stream& stream = Stream::Null());
610
611 //! Does mean shift segmentation with elimination of small regions.
612 CV_EXPORTS void meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize,
613                                       TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
614
615 //! Does coloring of disparity image: [0..ndisp) -> [0..240, 1, 1] in HSV.
616 //! Supported types of input disparity: CV_8U, CV_16S.
617 //! Output disparity has CV_8UC4 type in BGRA format (alpha = 255).
618 CV_EXPORTS void drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, Stream& stream = Stream::Null());
619
620 //! Reprojects disparity image to 3D space.
621 //! Supports CV_8U and CV_16S types of input disparity.
622 //! The output is a 3- or 4-channel floating-point matrix.
623 //! Each element of this matrix will contain the 3D coordinates of the point (x,y,z,1), computed from the disparity map.
624 //! Q is the 4x4 perspective transformation matrix that can be obtained with cvStereoRectify.
625 CV_EXPORTS void reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, int dst_cn = 4, Stream& stream = Stream::Null());
626
627 //! converts image from one color space to another
628 CV_EXPORTS void cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0, Stream& stream = Stream::Null());
629
630 enum
631 {
632     // Bayer Demosaicing (Malvar, He, and Cutler)
633     COLOR_BayerBG2BGR_MHT = 256,
634     COLOR_BayerGB2BGR_MHT = 257,
635     COLOR_BayerRG2BGR_MHT = 258,
636     COLOR_BayerGR2BGR_MHT = 259,
637
638     COLOR_BayerBG2RGB_MHT = COLOR_BayerRG2BGR_MHT,
639     COLOR_BayerGB2RGB_MHT = COLOR_BayerGR2BGR_MHT,
640     COLOR_BayerRG2RGB_MHT = COLOR_BayerBG2BGR_MHT,
641     COLOR_BayerGR2RGB_MHT = COLOR_BayerGB2BGR_MHT,
642
643     COLOR_BayerBG2GRAY_MHT = 260,
644     COLOR_BayerGB2GRAY_MHT = 261,
645     COLOR_BayerRG2GRAY_MHT = 262,
646     COLOR_BayerGR2GRAY_MHT = 263
647 };
648 CV_EXPORTS void demosaicing(const GpuMat& src, GpuMat& dst, int code, int dcn = -1, Stream& stream = Stream::Null());
649
650 //! swap channels
651 //! dstOrder - Integer array describing how channel values are permutated. The n-th entry
652 //!            of the array contains the number of the channel that is stored in the n-th channel of
653 //!            the output image. E.g. Given an RGBA image, aDstOrder = [3,2,1,0] converts this to ABGR
654 //!            channel order.
655 CV_EXPORTS void swapChannels(GpuMat& image, const int dstOrder[4], Stream& stream = Stream::Null());
656
657 //! Routines for correcting image color gamma
658 CV_EXPORTS void gammaCorrection(const GpuMat& src, GpuMat& dst, bool forward = true, Stream& stream = Stream::Null());
659
660 //! applies fixed threshold to the image
661 CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
662
663 //! resizes the image
664 //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_AREA
665 CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
666
667 //! warps the image using affine transformation
668 //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
669 CV_EXPORTS void warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR,
670     int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar(), Stream& stream = Stream::Null());
671
672 CV_EXPORTS void buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null());
673
674 //! warps the image using perspective transformation
675 //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
676 CV_EXPORTS void warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR,
677     int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar(), Stream& stream = Stream::Null());
678
679 CV_EXPORTS void buildWarpPerspectiveMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null());
680
681 //! builds plane warping maps
682 CV_EXPORTS void buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, const Mat &T, float scale,
683                                    GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
684
685 //! builds cylindrical warping maps
686 CV_EXPORTS void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
687                                          GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
688
689 //! builds spherical warping maps
690 CV_EXPORTS void buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat& R, float scale,
691                                        GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
692
693 //! rotates an image around the origin (0,0) and then shifts it
694 //! supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
695 //! supports 1, 3 or 4 channels images with CV_8U, CV_16U or CV_32F depth
696 CV_EXPORTS void rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0,
697                        int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
698
699 //! copies 2D array to a larger destination array and pads borders with user-specifiable constant
700 CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, int borderType,
701                                const Scalar& value = Scalar(), Stream& stream = Stream::Null());
702
703 //! computes the integral image
704 //! sum will have CV_32S type, but will contain unsigned int values
705 //! supports only CV_8UC1 source type
706 CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, Stream& stream = Stream::Null());
707 //! buffered version
708 CV_EXPORTS void integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, Stream& stream = Stream::Null());
709
710 //! computes squared integral image
711 //! result matrix will have 64F type, but will contain 64U values
712 //! supports source images of 8UC1 type only
713 CV_EXPORTS void sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& stream = Stream::Null());
714
715 //! computes vertical sum, supports only CV_32FC1 images
716 CV_EXPORTS void columnSum(const GpuMat& src, GpuMat& sum);
717
718 //! computes the standard deviation of integral images
719 //! supports only CV_32SC1 source type and CV_32FC1 sqr type
720 //! output will have CV_32FC1 type
721 CV_EXPORTS void rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& stream = Stream::Null());
722
723 //! computes Harris cornerness criteria at each image pixel
724 CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType = BORDER_REFLECT101);
725 CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, double k, int borderType = BORDER_REFLECT101);
726 CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, double k,
727                              int borderType = BORDER_REFLECT101, Stream& stream = Stream::Null());
728
729 //! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
730 CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
731 CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
732 CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize,
733     int borderType=BORDER_REFLECT101, Stream& stream = Stream::Null());
734
735 //! performs per-element multiplication of two full (not packed) Fourier spectrums
736 //! supports 32FC2 matrixes only (interleaved format)
737 CV_EXPORTS void mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false, Stream& stream = Stream::Null());
738
739 //! performs per-element multiplication of two full (not packed) Fourier spectrums
740 //! supports 32FC2 matrixes only (interleaved format)
741 CV_EXPORTS void mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false, Stream& stream = Stream::Null());
742
743 //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
744 //! Param dft_size is the size of DFT transform.
745 //!
746 //! If the source matrix is not continous, then additional copy will be done,
747 //! so to avoid copying ensure the source matrix is continous one. If you want to use
748 //! preallocated output ensure it is continuous too, otherwise it will be reallocated.
749 //!
750 //! Being implemented via CUFFT real-to-complex transform result contains only non-redundant values
751 //! in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.
752 //!
753 //! For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.
754 CV_EXPORTS void dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0, Stream& stream = Stream::Null());
755
756 struct CV_EXPORTS ConvolveBuf
757 {
758     Size result_size;
759     Size block_size;
760     Size user_block_size;
761     Size dft_size;
762     int spect_len;
763
764     GpuMat image_spect, templ_spect, result_spect;
765     GpuMat image_block, templ_block, result_data;
766
767     void create(Size image_size, Size templ_size);
768     static Size estimateBlockSize(Size result_size, Size templ_size);
769 };
770
771
772 //! computes convolution (or cross-correlation) of two images using discrete Fourier transform
773 //! supports source images of 32FC1 type only
774 //! result matrix will have 32FC1 type
775 CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr = false);
776 CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream = Stream::Null());
777
778 struct CV_EXPORTS MatchTemplateBuf
779 {
780     Size user_block_size;
781     GpuMat imagef, templf;
782     std::vector<GpuMat> images;
783     std::vector<GpuMat> image_sums;
784     std::vector<GpuMat> image_sqsums;
785 };
786
787 //! computes the proximity map for the raster template and the image where the template is searched for
788 CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, Stream &stream = Stream::Null());
789
790 //! computes the proximity map for the raster template and the image where the template is searched for
791 CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method, MatchTemplateBuf &buf, Stream& stream = Stream::Null());
792
793 //! smoothes the source image and downsamples it
794 CV_EXPORTS void pyrDown(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
795
796 //! upsamples the source image and then smoothes it
797 CV_EXPORTS void pyrUp(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
798
799 //! performs linear blending of two images
800 //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
801 CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2,
802                             GpuMat& result, Stream& stream = Stream::Null());
803
804 //! Performa bilateral filtering of passsed image
805 CV_EXPORTS void bilateralFilter(const GpuMat& src, GpuMat& dst, int kernel_size, float sigma_color, float sigma_spatial,
806                                 int borderMode = BORDER_DEFAULT, Stream& stream = Stream::Null());
807
808 //! Brute force non-local means algorith (slow but universal)
809 CV_EXPORTS void nonLocalMeans(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, int borderMode = BORDER_DEFAULT, Stream& s = Stream::Null());
810
811 //! Fast (but approximate)version of non-local means algorith similar to CPU function (running sums technique)
812 class CV_EXPORTS FastNonLocalMeansDenoising
813 {
814 public:
815     //! Simple method, recommended for grayscale images (though it supports multichannel images)
816     void simpleMethod(const GpuMat& src, GpuMat& dst, float h, int search_window = 21, int block_size = 7, Stream& s = Stream::Null());
817
818     //! Processes luminance and color components separatelly
819     void labMethod(const GpuMat& src, GpuMat& dst, float h_luminance, float h_color, int search_window = 21, int block_size = 7, Stream& s = Stream::Null());
820
821 private:
822
823     GpuMat buffer, extended_src_buffer;
824     GpuMat lab, l, ab;
825 };
826
827 struct CV_EXPORTS CannyBuf
828 {
829     void create(const Size& image_size, int apperture_size = 3);
830     void release();
831
832     GpuMat dx, dy;
833     GpuMat mag;
834     GpuMat map;
835     GpuMat st1, st2;
836     GpuMat unused;
837     Ptr<FilterEngine_GPU> filterDX, filterDY;
838
839     CannyBuf() {}
840     explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);}
841     CannyBuf(const GpuMat& dx_, const GpuMat& dy_);
842 };
843
844 CV_EXPORTS void Canny(const GpuMat& image, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
845 CV_EXPORTS void Canny(const GpuMat& image, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
846 CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false);
847 CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false);
848
849 class CV_EXPORTS ImagePyramid
850 {
851 public:
852     inline ImagePyramid() : nLayers_(0) {}
853     inline ImagePyramid(const GpuMat& img, int nLayers, Stream& stream = Stream::Null())
854     {
855         build(img, nLayers, stream);
856     }
857
858     void build(const GpuMat& img, int nLayers, Stream& stream = Stream::Null());
859
860     void getLayer(GpuMat& outImg, Size outRoi, Stream& stream = Stream::Null()) const;
861
862     inline void release()
863     {
864         layer0_.release();
865         pyramid_.clear();
866         nLayers_ = 0;
867     }
868
869 private:
870     GpuMat layer0_;
871     std::vector<GpuMat> pyramid_;
872     int nLayers_;
873 };
874
875 //! HoughLines
876
877 struct HoughLinesBuf
878 {
879     GpuMat accum;
880     GpuMat list;
881 };
882
883 CV_EXPORTS void HoughLines(const GpuMat& src, GpuMat& lines, float rho, float theta, int threshold, bool doSort = false, int maxLines = 4096);
884 CV_EXPORTS void HoughLines(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int threshold, bool doSort = false, int maxLines = 4096);
885 CV_EXPORTS void HoughLinesDownload(const GpuMat& d_lines, OutputArray h_lines, OutputArray h_votes = noArray());
886
887 //! HoughLinesP
888
889 //! finds line segments in the black-n-white image using probabalistic Hough transform
890 CV_EXPORTS void HoughLinesP(const GpuMat& image, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int minLineLength, int maxLineGap, int maxLines = 4096);
891
892 //! HoughCircles
893
894 struct HoughCirclesBuf
895 {
896     GpuMat edges;
897     GpuMat accum;
898     GpuMat list;
899     CannyBuf cannyBuf;
900 };
901
902 CV_EXPORTS void HoughCircles(const GpuMat& src, GpuMat& circles, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles = 4096);
903 CV_EXPORTS void HoughCircles(const GpuMat& src, GpuMat& circles, HoughCirclesBuf& buf, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles = 4096);
904 CV_EXPORTS void HoughCirclesDownload(const GpuMat& d_circles, OutputArray h_circles);
905
906 //! finds arbitrary template in the grayscale image using Generalized Hough Transform
907 //! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
908 //! Guil, N., Gonz├ílez-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038.
909 class CV_EXPORTS GeneralizedHough_GPU : public Algorithm
910 {
911 public:
912     static Ptr<GeneralizedHough_GPU> create(int method);
913
914     virtual ~GeneralizedHough_GPU();
915
916     //! set template to search
917     void setTemplate(const GpuMat& templ, int cannyThreshold = 100, Point templCenter = Point(-1, -1));
918     void setTemplate(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy, Point templCenter = Point(-1, -1));
919
920     //! find template on image
921     void detect(const GpuMat& image, GpuMat& positions, int cannyThreshold = 100);
922     void detect(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy, GpuMat& positions);
923
924     void download(const GpuMat& d_positions, OutputArray h_positions, OutputArray h_votes = noArray());
925
926     void release();
927
928 protected:
929     virtual void setTemplateImpl(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy, Point templCenter) = 0;
930     virtual void detectImpl(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy, GpuMat& positions) = 0;
931     virtual void releaseImpl() = 0;
932
933 private:
934     GpuMat edges_;
935     CannyBuf cannyBuf_;
936 };
937
938 ////////////////////////////// Matrix reductions //////////////////////////////
939
940 //! computes mean value and standard deviation of all or selected array elements
941 //! supports only CV_8UC1 type
942 CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
943 //! buffered version
944 CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev, GpuMat& buf);
945
946 //! computes norm of array
947 //! supports NORM_INF, NORM_L1, NORM_L2
948 //! supports all matrices except 64F
949 CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
950 CV_EXPORTS double norm(const GpuMat& src1, int normType, GpuMat& buf);
951 CV_EXPORTS double norm(const GpuMat& src1, int normType, const GpuMat& mask, GpuMat& buf);
952
953 //! computes norm of the difference between two arrays
954 //! supports NORM_INF, NORM_L1, NORM_L2
955 //! supports only CV_8UC1 type
956 CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
957
958 //! computes sum of array elements
959 //! supports only single channel images
960 CV_EXPORTS Scalar sum(const GpuMat& src);
961 CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
962 CV_EXPORTS Scalar sum(const GpuMat& src, const GpuMat& mask, GpuMat& buf);
963
964 //! computes sum of array elements absolute values
965 //! supports only single channel images
966 CV_EXPORTS Scalar absSum(const GpuMat& src);
967 CV_EXPORTS Scalar absSum(const GpuMat& src, GpuMat& buf);
968 CV_EXPORTS Scalar absSum(const GpuMat& src, const GpuMat& mask, GpuMat& buf);
969
970 //! computes squared sum of array elements
971 //! supports only single channel images
972 CV_EXPORTS Scalar sqrSum(const GpuMat& src);
973 CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
974 CV_EXPORTS Scalar sqrSum(const GpuMat& src, const GpuMat& mask, GpuMat& buf);
975
976 //! finds global minimum and maximum array elements and returns their values
977 CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
978 CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
979
980 //! finds global minimum and maximum array elements and returns their values with locations
981 CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
982                           const GpuMat& mask=GpuMat());
983 CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
984                           const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
985
986 //! counts non-zero array elements
987 CV_EXPORTS int countNonZero(const GpuMat& src);
988 CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
989
990 //! reduces a matrix to a vector
991 CV_EXPORTS void reduce(const GpuMat& mtx, GpuMat& vec, int dim, int reduceOp, int dtype = -1, Stream& stream = Stream::Null());
992
993
994 ///////////////////////////// Calibration 3D //////////////////////////////////
995
996 CV_EXPORTS void transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
997                                 GpuMat& dst, Stream& stream = Stream::Null());
998
999 CV_EXPORTS void projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
1000                               const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst,
1001                               Stream& stream = Stream::Null());
1002
1003 CV_EXPORTS void solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat,
1004                                const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false,
1005                                int num_iters=100, float max_dist=8.0, int min_inlier_count=100,
1006                                std::vector<int>* inliers=NULL);
1007
1008 //////////////////////////////// Image Labeling ////////////////////////////////
1009
1010 //!performs labeling via graph cuts of a 2D regular 4-connected graph.
1011 CV_EXPORTS void graphcut(GpuMat& terminals, GpuMat& leftTransp, GpuMat& rightTransp, GpuMat& top, GpuMat& bottom, GpuMat& labels,
1012                          GpuMat& buf, Stream& stream = Stream::Null());
1013
1014 //!performs labeling via graph cuts of a 2D regular 8-connected graph.
1015 CV_EXPORTS void graphcut(GpuMat& terminals, GpuMat& leftTransp, GpuMat& rightTransp, GpuMat& top, GpuMat& topLeft, GpuMat& topRight,
1016                          GpuMat& bottom, GpuMat& bottomLeft, GpuMat& bottomRight,
1017                          GpuMat& labels,
1018                          GpuMat& buf, Stream& stream = Stream::Null());
1019
1020 //! compute mask for Generalized Flood fill componetns labeling.
1021 CV_EXPORTS void connectivityMask(const GpuMat& image, GpuMat& mask, const cv::Scalar& lo, const cv::Scalar& hi, Stream& stream = Stream::Null());
1022
1023 //! performs connected componnents labeling.
1024 CV_EXPORTS void labelComponents(const GpuMat& mask, GpuMat& components, int flags = 0, Stream& stream = Stream::Null());
1025
1026 ////////////////////////////////// Histograms //////////////////////////////////
1027
1028 //! Compute levels with even distribution. levels will have 1 row and nLevels cols and CV_32SC1 type.
1029 CV_EXPORTS void evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel);
1030 //! Calculates histogram with evenly distributed bins for signle channel source.
1031 //! Supports CV_8UC1, CV_16UC1 and CV_16SC1 source types.
1032 //! Output hist will have one row and histSize cols and CV_32SC1 type.
1033 CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
1034 CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, GpuMat& buf, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
1035 //! Calculates histogram with evenly distributed bins for four-channel source.
1036 //! All channels of source are processed separately.
1037 //! Supports CV_8UC4, CV_16UC4 and CV_16SC4 source types.
1038 //! Output hist[i] will have one row and histSize[i] cols and CV_32SC1 type.
1039 CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
1040 CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], GpuMat& buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
1041 //! Calculates histogram with bins determined by levels array.
1042 //! levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
1043 //! Supports CV_8UC1, CV_16UC1, CV_16SC1 and CV_32FC1 source types.
1044 //! Output hist will have one row and (levels.cols-1) cols and CV_32SC1 type.
1045 CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, Stream& stream = Stream::Null());
1046 CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, Stream& stream = Stream::Null());
1047 //! Calculates histogram with bins determined by levels array.
1048 //! All levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
1049 //! All channels of source are processed separately.
1050 //! Supports CV_8UC4, CV_16UC4, CV_16SC4 and CV_32FC4 source types.
1051 //! Output hist[i] will have one row and (levels[i].cols-1) cols and CV_32SC1 type.
1052 CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], Stream& stream = Stream::Null());
1053 CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buf, Stream& stream = Stream::Null());
1054
1055 //! Calculates histogram for 8u one channel image
1056 //! Output hist will have one row, 256 cols and CV32SC1 type.
1057 CV_EXPORTS void calcHist(const GpuMat& src, GpuMat& hist, Stream& stream = Stream::Null());
1058 CV_EXPORTS void calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null());
1059
1060 //! normalizes the grayscale image brightness and contrast by normalizing its histogram
1061 CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
1062 CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream& stream = Stream::Null());
1063 CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null());
1064
1065 class CV_EXPORTS CLAHE : public cv::CLAHE
1066 {
1067 public:
1068     using cv::CLAHE::apply;
1069     virtual void apply(InputArray src, OutputArray dst, Stream& stream) = 0;
1070 };
1071 CV_EXPORTS Ptr<cv::gpu::CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));
1072
1073 //////////////////////////////// StereoBM_GPU ////////////////////////////////
1074
1075 class CV_EXPORTS StereoBM_GPU
1076 {
1077 public:
1078     enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 };
1079
1080     enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 };
1081
1082     //! the default constructor
1083     StereoBM_GPU();
1084     //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8.
1085     StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ);
1086
1087     //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
1088     //! Output disparity has CV_8U type.
1089     void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
1090
1091     //! Some heuristics that tries to estmate
1092     // if current GPU will be faster than CPU in this algorithm.
1093     // It queries current active device.
1094     static bool checkIfGpuCallReasonable();
1095
1096     int preset;
1097     int ndisp;
1098     int winSize;
1099
1100     // If avergeTexThreshold  == 0 => post procesing is disabled
1101     // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image
1102     // SumOfHorizontalGradiensInWindow(x, y, winSize) < (winSize * winSize) * avergeTexThreshold
1103     // i.e. input left image is low textured.
1104     float avergeTexThreshold;
1105
1106 private:
1107     GpuMat minSSD, leBuf, riBuf;
1108 };
1109
1110 ////////////////////////// StereoBeliefPropagation ///////////////////////////
1111 // "Efficient Belief Propagation for Early Vision"
1112 // P.Felzenszwalb
1113
1114 class CV_EXPORTS StereoBeliefPropagation
1115 {
1116 public:
1117     enum { DEFAULT_NDISP  = 64 };
1118     enum { DEFAULT_ITERS  = 5  };
1119     enum { DEFAULT_LEVELS = 5  };
1120
1121     static void estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels);
1122
1123     //! the default constructor
1124     explicit StereoBeliefPropagation(int ndisp  = DEFAULT_NDISP,
1125                                      int iters  = DEFAULT_ITERS,
1126                                      int levels = DEFAULT_LEVELS,
1127                                      int msg_type = CV_32F);
1128
1129     //! the full constructor taking the number of disparities, number of BP iterations on each level,
1130     //! number of levels, truncation of data cost, data weight,
1131     //! truncation of discontinuity cost and discontinuity single jump
1132     //! DataTerm = data_weight * min(fabs(I2-I1), max_data_term)
1133     //! DiscTerm = min(disc_single_jump * fabs(f1-f2), max_disc_term)
1134     //! please see paper for more details
1135     StereoBeliefPropagation(int ndisp, int iters, int levels,
1136         float max_data_term, float data_weight,
1137         float max_disc_term, float disc_single_jump,
1138         int msg_type = CV_32F);
1139
1140     //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair,
1141     //! if disparity is empty output type will be CV_16S else output type will be disparity.type().
1142     void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
1143
1144
1145     //! version for user specified data term
1146     void operator()(const GpuMat& data, GpuMat& disparity, Stream& stream = Stream::Null());
1147
1148     int ndisp;
1149
1150     int iters;
1151     int levels;
1152
1153     float max_data_term;
1154     float data_weight;
1155     float max_disc_term;
1156     float disc_single_jump;
1157
1158     int msg_type;
1159 private:
1160     GpuMat u, d, l, r, u2, d2, l2, r2;
1161     std::vector<GpuMat> datas;
1162     GpuMat out;
1163 };
1164
1165 /////////////////////////// StereoConstantSpaceBP ///////////////////////////
1166 // "A Constant-Space Belief Propagation Algorithm for Stereo Matching"
1167 // Qingxiong Yang, Liang Wang, Narendra Ahuja
1168 // http://vision.ai.uiuc.edu/~qyang6/
1169
1170 class CV_EXPORTS StereoConstantSpaceBP
1171 {
1172 public:
1173     enum { DEFAULT_NDISP    = 128 };
1174     enum { DEFAULT_ITERS    = 8   };
1175     enum { DEFAULT_LEVELS   = 4   };
1176     enum { DEFAULT_NR_PLANE = 4   };
1177
1178     static void estimateRecommendedParams(int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane);
1179
1180     //! the default constructor
1181     explicit StereoConstantSpaceBP(int ndisp    = DEFAULT_NDISP,
1182                                    int iters    = DEFAULT_ITERS,
1183                                    int levels   = DEFAULT_LEVELS,
1184                                    int nr_plane = DEFAULT_NR_PLANE,
1185                                    int msg_type = CV_32F);
1186
1187     //! the full constructor taking the number of disparities, number of BP iterations on each level,
1188     //! number of levels, number of active disparity on the first level, truncation of data cost, data weight,
1189     //! truncation of discontinuity cost, discontinuity single jump and minimum disparity threshold
1190     StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane,
1191         float max_data_term, float data_weight, float max_disc_term, float disc_single_jump,
1192         int min_disp_th = 0,
1193         int msg_type = CV_32F);
1194
1195     //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair,
1196     //! if disparity is empty output type will be CV_16S else output type will be disparity.type().
1197     void operator()(const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream = Stream::Null());
1198
1199     int ndisp;
1200
1201     int iters;
1202     int levels;
1203
1204     int nr_plane;
1205
1206     float max_data_term;
1207     float data_weight;
1208     float max_disc_term;
1209     float disc_single_jump;
1210
1211     int min_disp_th;
1212
1213     int msg_type;
1214
1215     bool use_local_init_data_cost;
1216 private:
1217     GpuMat messages_buffers;
1218
1219     GpuMat temp;
1220     GpuMat out;
1221 };
1222
1223 /////////////////////////// DisparityBilateralFilter ///////////////////////////
1224 // Disparity map refinement using joint bilateral filtering given a single color image.
1225 // Qingxiong Yang, Liang Wang, Narendra Ahuja
1226 // http://vision.ai.uiuc.edu/~qyang6/
1227
1228 class CV_EXPORTS DisparityBilateralFilter
1229 {
1230 public:
1231     enum { DEFAULT_NDISP  = 64 };
1232     enum { DEFAULT_RADIUS = 3 };
1233     enum { DEFAULT_ITERS  = 1 };
1234
1235     //! the default constructor
1236     explicit DisparityBilateralFilter(int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS);
1237
1238     //! the full constructor taking the number of disparities, filter radius,
1239     //! number of iterations, truncation of data continuity, truncation of disparity continuity
1240     //! and filter range sigma
1241     DisparityBilateralFilter(int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range);
1242
1243     //! the disparity map refinement operator. Refine disparity map using joint bilateral filtering given a single color image.
1244     //! disparity must have CV_8U or CV_16S type, image must have CV_8UC1 or CV_8UC3 type.
1245     void operator()(const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream = Stream::Null());
1246
1247 private:
1248     int ndisp;
1249     int radius;
1250     int iters;
1251
1252     float edge_threshold;
1253     float max_disc_threshold;
1254     float sigma_range;
1255
1256     GpuMat table_color;
1257     GpuMat table_space;
1258 };
1259
1260
1261 //////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
1262 struct CV_EXPORTS HOGConfidence
1263 {
1264    double scale;
1265    vector<Point> locations;
1266    vector<double> confidences;
1267    vector<double> part_scores[4];
1268 };
1269
1270 struct CV_EXPORTS HOGDescriptor
1271 {
1272     enum { DEFAULT_WIN_SIGMA = -1 };
1273     enum { DEFAULT_NLEVELS = 64 };
1274     enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };
1275
1276     HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16),
1277                   Size block_stride=Size(8, 8), Size cell_size=Size(8, 8),
1278                   int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA,
1279                   double threshold_L2hys=0.2, bool gamma_correction=true,
1280                   int nlevels=DEFAULT_NLEVELS);
1281
1282     size_t getDescriptorSize() const;
1283     size_t getBlockHistogramSize() const;
1284
1285     void setSVMDetector(const vector<float>& detector);
1286
1287     static vector<float> getDefaultPeopleDetector();
1288     static vector<float> getPeopleDetector48x96();
1289     static vector<float> getPeopleDetector64x128();
1290
1291     void detect(const GpuMat& img, vector<Point>& found_locations,
1292                 double hit_threshold=0, Size win_stride=Size(),
1293                 Size padding=Size());
1294
1295     void detectMultiScale(const GpuMat& img, vector<Rect>& found_locations,
1296                           double hit_threshold=0, Size win_stride=Size(),
1297                           Size padding=Size(), double scale0=1.05,
1298                           int group_threshold=2);
1299
1300     void computeConfidence(const GpuMat& img, vector<Point>& hits, double hit_threshold,
1301                                                 Size win_stride, Size padding, vector<Point>& locations, vector<double>& confidences);
1302
1303     void computeConfidenceMultiScale(const GpuMat& img, vector<Rect>& found_locations,
1304                                                                     double hit_threshold, Size win_stride, Size padding,
1305                                                                     vector<HOGConfidence> &conf_out, int group_threshold);
1306
1307     void getDescriptors(const GpuMat& img, Size win_stride,
1308                         GpuMat& descriptors,
1309                         int descr_format=DESCR_FORMAT_COL_BY_COL);
1310
1311     Size win_size;
1312     Size block_size;
1313     Size block_stride;
1314     Size cell_size;
1315     int nbins;
1316     double win_sigma;
1317     double threshold_L2hys;
1318     bool gamma_correction;
1319     int nlevels;
1320
1321 protected:
1322     void computeBlockHistograms(const GpuMat& img);
1323     void computeGradient(const GpuMat& img, GpuMat& grad, GpuMat& qangle);
1324
1325     double getWinSigma() const;
1326     bool checkDetectorSize() const;
1327
1328     static int numPartsWithin(int size, int part_size, int stride);
1329     static Size numPartsWithin(Size size, Size part_size, Size stride);
1330
1331     // Coefficients of the separating plane
1332     float free_coef;
1333     GpuMat detector;
1334
1335     // Results of the last classification step
1336     GpuMat labels, labels_buf;
1337     Mat labels_host;
1338
1339     // Results of the last histogram evaluation step
1340     GpuMat block_hists, block_hists_buf;
1341
1342     // Gradients conputation results
1343     GpuMat grad, qangle, grad_buf, qangle_buf;
1344
1345     // returns subbuffer with required size, reallocates buffer if nessesary.
1346     static GpuMat getBuffer(const Size& sz, int type, GpuMat& buf);
1347     static GpuMat getBuffer(int rows, int cols, int type, GpuMat& buf);
1348
1349     std::vector<GpuMat> image_scales;
1350 };
1351
1352
1353 ////////////////////////////////// BruteForceMatcher //////////////////////////////////
1354
1355 class CV_EXPORTS BruteForceMatcher_GPU_base
1356 {
1357 public:
1358     enum DistType {L1Dist = 0, L2Dist, HammingDist};
1359
1360     explicit BruteForceMatcher_GPU_base(DistType distType = L2Dist);
1361
1362     // Add descriptors to train descriptor collection
1363     void add(const std::vector<GpuMat>& descCollection);
1364
1365     // Get train descriptors collection
1366     const std::vector<GpuMat>& getTrainDescriptors() const;
1367
1368     // Clear train descriptors collection
1369     void clear();
1370
1371     // Return true if there are not train descriptors in collection
1372     bool empty() const;
1373
1374     // Return true if the matcher supports mask in match methods
1375     bool isMaskSupported() const;
1376
1377     // Find one best match for each query descriptor
1378     void matchSingle(const GpuMat& query, const GpuMat& train,
1379         GpuMat& trainIdx, GpuMat& distance,
1380         const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
1381
1382     // Download trainIdx and distance and convert it to CPU vector with DMatch
1383     static void matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>& matches);
1384     // Convert trainIdx and distance to vector with DMatch
1385     static void matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches);
1386
1387     // Find one best match for each query descriptor
1388     void match(const GpuMat& query, const GpuMat& train, std::vector<DMatch>& matches, const GpuMat& mask = GpuMat());
1389
1390     // Make gpu collection of trains and masks in suitable format for matchCollection function
1391     void makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
1392
1393     // Find one best match from train collection for each query descriptor
1394     void matchCollection(const GpuMat& query, const GpuMat& trainCollection,
1395         GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
1396         const GpuMat& masks = GpuMat(), Stream& stream = Stream::Null());
1397
1398     // Download trainIdx, imgIdx and distance and convert it to vector with DMatch
1399     static void matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>& matches);
1400     // Convert trainIdx, imgIdx and distance to vector with DMatch
1401     static void matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches);
1402
1403     // Find one best match from train collection for each query descriptor.
1404     void match(const GpuMat& query, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
1405
1406     // Find k best matches for each query descriptor (in increasing order of distances)
1407     void knnMatchSingle(const GpuMat& query, const GpuMat& train,
1408         GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k,
1409         const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
1410
1411     // Download trainIdx and distance and convert it to vector with DMatch
1412     // compactResult is used when mask is not empty. If compactResult is false matches
1413     // vector will have the same size as queryDescriptors rows. If compactResult is true
1414     // matches vector will not contain matches for fully masked out query descriptors.
1415     static void knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
1416         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1417     // Convert trainIdx and distance to vector with DMatch
1418     static void knnMatchConvert(const Mat& trainIdx, const Mat& distance,
1419         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1420
1421     // Find k best matches for each query descriptor (in increasing order of distances).
1422     // compactResult is used when mask is not empty. If compactResult is false matches
1423     // vector will have the same size as queryDescriptors rows. If compactResult is true
1424     // matches vector will not contain matches for fully masked out query descriptors.
1425     void knnMatch(const GpuMat& query, const GpuMat& train,
1426         std::vector< std::vector<DMatch> >& matches, int k, const GpuMat& mask = GpuMat(),
1427         bool compactResult = false);
1428
1429     // Find k best matches from train collection for each query descriptor (in increasing order of distances)
1430     void knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection,
1431         GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
1432         const GpuMat& maskCollection = GpuMat(), Stream& stream = Stream::Null());
1433
1434     // Download trainIdx and distance and convert it to vector with DMatch
1435     // compactResult is used when mask is not empty. If compactResult is false matches
1436     // vector will have the same size as queryDescriptors rows. If compactResult is true
1437     // matches vector will not contain matches for fully masked out query descriptors.
1438     static void knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
1439         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1440     // Convert trainIdx and distance to vector with DMatch
1441     static void knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance,
1442         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1443
1444     // Find k best matches  for each query descriptor (in increasing order of distances).
1445     // compactResult is used when mask is not empty. If compactResult is false matches
1446     // vector will have the same size as queryDescriptors rows. If compactResult is true
1447     // matches vector will not contain matches for fully masked out query descriptors.
1448     void knnMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, int k,
1449         const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
1450
1451     // Find best matches for each query descriptor which have distance less than maxDistance.
1452     // nMatches.at<int>(0, queryIdx) will contain matches count for queryIdx.
1453     // carefully nMatches can be greater than trainIdx.cols - it means that matcher didn't find all matches,
1454     // because it didn't have enough memory.
1455     // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nTrain / 100), 10),
1456     // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
1457     // Matches doesn't sorted.
1458     void radiusMatchSingle(const GpuMat& query, const GpuMat& train,
1459         GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
1460         const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
1461
1462     // Download trainIdx, nMatches and distance and convert it to vector with DMatch.
1463     // matches will be sorted in increasing order of distances.
1464     // compactResult is used when mask is not empty. If compactResult is false matches
1465     // vector will have the same size as queryDescriptors rows. If compactResult is true
1466     // matches vector will not contain matches for fully masked out query descriptors.
1467     static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches,
1468         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1469     // Convert trainIdx, nMatches and distance to vector with DMatch.
1470     static void radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches,
1471         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1472
1473     // Find best matches for each query descriptor which have distance less than maxDistance
1474     // in increasing order of distances).
1475     void radiusMatch(const GpuMat& query, const GpuMat& train,
1476         std::vector< std::vector<DMatch> >& matches, float maxDistance,
1477         const GpuMat& mask = GpuMat(), bool compactResult = false);
1478
1479     // Find best matches for each query descriptor which have distance less than maxDistance.
1480     // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nQuery / 100), 10),
1481     // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
1482     // Matches doesn't sorted.
1483     void radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
1484         const std::vector<GpuMat>& masks = std::vector<GpuMat>(), Stream& stream = Stream::Null());
1485
1486     // Download trainIdx, imgIdx, nMatches and distance and convert it to vector with DMatch.
1487     // matches will be sorted in increasing order of distances.
1488     // compactResult is used when mask is not empty. If compactResult is false matches
1489     // vector will have the same size as queryDescriptors rows. If compactResult is true
1490     // matches vector will not contain matches for fully masked out query descriptors.
1491     static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches,
1492         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1493     // Convert trainIdx, nMatches and distance to vector with DMatch.
1494     static void radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches,
1495         std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
1496
1497     // Find best matches from train collection for each query descriptor which have distance less than
1498     // maxDistance (in increasing order of distances).
1499     void radiusMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, float maxDistance,
1500         const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
1501
1502     DistType distType;
1503
1504 private:
1505     std::vector<GpuMat> trainDescCollection;
1506 };
1507
1508 template <class Distance>
1509 class CV_EXPORTS BruteForceMatcher_GPU;
1510
1511 template <typename T>
1512 class CV_EXPORTS BruteForceMatcher_GPU< L1<T> > : public BruteForceMatcher_GPU_base
1513 {
1514 public:
1515     explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(L1Dist) {}
1516     explicit BruteForceMatcher_GPU(L1<T> /*d*/) : BruteForceMatcher_GPU_base(L1Dist) {}
1517 };
1518 template <typename T>
1519 class CV_EXPORTS BruteForceMatcher_GPU< L2<T> > : public BruteForceMatcher_GPU_base
1520 {
1521 public:
1522     explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(L2Dist) {}
1523     explicit BruteForceMatcher_GPU(L2<T> /*d*/) : BruteForceMatcher_GPU_base(L2Dist) {}
1524 };
1525 template <> class CV_EXPORTS BruteForceMatcher_GPU< Hamming > : public BruteForceMatcher_GPU_base
1526 {
1527 public:
1528     explicit BruteForceMatcher_GPU() : BruteForceMatcher_GPU_base(HammingDist) {}
1529     explicit BruteForceMatcher_GPU(Hamming /*d*/) : BruteForceMatcher_GPU_base(HammingDist) {}
1530 };
1531
1532 class CV_EXPORTS BFMatcher_GPU : public BruteForceMatcher_GPU_base
1533 {
1534 public:
1535     explicit BFMatcher_GPU(int norm = NORM_L2) : BruteForceMatcher_GPU_base(norm == NORM_L1 ? L1Dist : norm == NORM_L2 ? L2Dist : HammingDist) {}
1536 };
1537
1538 ////////////////////////////////// CascadeClassifier_GPU //////////////////////////////////////////
1539 // The cascade classifier class for object detection: supports old haar and new lbp xlm formats and nvbin for haar cascades olny.
1540 class CV_EXPORTS CascadeClassifier_GPU
1541 {
1542 public:
1543     CascadeClassifier_GPU();
1544     CascadeClassifier_GPU(const std::string& filename);
1545     ~CascadeClassifier_GPU();
1546
1547     bool empty() const;
1548     bool load(const std::string& filename);
1549     void release();
1550
1551     /* returns number of detected objects */
1552     int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor = 1.2, int minNeighbors = 4, Size minSize = Size());
1553     int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4);
1554
1555     bool findLargestObject;
1556     bool visualizeInPlace;
1557
1558     Size getClassifierSize() const;
1559
1560 private:
1561     struct CascadeClassifierImpl;
1562     CascadeClassifierImpl* impl;
1563     struct HaarCascade;
1564     struct LbpCascade;
1565     friend class CascadeClassifier_GPU_LBP;
1566 };
1567
1568 ////////////////////////////////// FAST //////////////////////////////////////////
1569
1570 class CV_EXPORTS FAST_GPU
1571 {
1572 public:
1573     enum
1574     {
1575         LOCATION_ROW = 0,
1576         RESPONSE_ROW,
1577         ROWS_COUNT
1578     };
1579
1580     // all features have same size
1581     static const int FEATURE_SIZE = 7;
1582
1583     explicit FAST_GPU(int threshold, bool nonmaxSupression = true, double keypointsRatio = 0.05);
1584
1585     //! finds the keypoints using FAST detector
1586     //! supports only CV_8UC1 images
1587     void operator ()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints);
1588     void operator ()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints);
1589
1590     //! download keypoints from device to host memory
1591     void downloadKeypoints(const GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints);
1592
1593     //! convert keypoints to KeyPoint vector
1594     void convertKeypoints(const Mat& h_keypoints, std::vector<KeyPoint>& keypoints);
1595
1596     //! release temporary buffer's memory
1597     void release();
1598
1599     bool nonmaxSupression;
1600
1601     int threshold;
1602
1603     //! max keypoints = keypointsRatio * img.size().area()
1604     double keypointsRatio;
1605
1606     //! find keypoints and compute it's response if nonmaxSupression is true
1607     //! return count of detected keypoints
1608     int calcKeyPointsLocation(const GpuMat& image, const GpuMat& mask);
1609
1610     //! get final array of keypoints
1611     //! performs nonmax supression if needed
1612     //! return final count of keypoints
1613     int getKeyPoints(GpuMat& keypoints);
1614
1615 private:
1616     GpuMat kpLoc_;
1617     int count_;
1618
1619     GpuMat score_;
1620
1621     GpuMat d_keypoints_;
1622 };
1623
1624 ////////////////////////////////// ORB //////////////////////////////////////////
1625
1626 class CV_EXPORTS ORB_GPU
1627 {
1628 public:
1629     enum
1630     {
1631         X_ROW = 0,
1632         Y_ROW,
1633         RESPONSE_ROW,
1634         ANGLE_ROW,
1635         OCTAVE_ROW,
1636         SIZE_ROW,
1637         ROWS_COUNT
1638     };
1639
1640     enum
1641     {
1642         DEFAULT_FAST_THRESHOLD = 20
1643     };
1644
1645     //! Constructor
1646     explicit ORB_GPU(int nFeatures = 500, float scaleFactor = 1.2f, int nLevels = 8, int edgeThreshold = 31,
1647                      int firstLevel = 0, int WTA_K = 2, int scoreType = 0, int patchSize = 31);
1648
1649     //! Compute the ORB features on an image
1650     //! image - the image to compute the features (supports only CV_8UC1 images)
1651     //! mask - the mask to apply
1652     //! keypoints - the resulting keypoints
1653     void operator()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints);
1654     void operator()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints);
1655
1656     //! Compute the ORB features and descriptors on an image
1657     //! image - the image to compute the features (supports only CV_8UC1 images)
1658     //! mask - the mask to apply
1659     //! keypoints - the resulting keypoints
1660     //! descriptors - descriptors array
1661     void operator()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints, GpuMat& descriptors);
1662     void operator()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors);
1663
1664     //! download keypoints from device to host memory
1665     void downloadKeyPoints(GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints);
1666
1667     //! convert keypoints to KeyPoint vector
1668     void convertKeyPoints(Mat& d_keypoints, std::vector<KeyPoint>& keypoints);
1669
1670     //! returns the descriptor size in bytes
1671     inline int descriptorSize() const { return kBytes; }
1672
1673     inline void setFastParams(int threshold, bool nonmaxSupression = true)
1674     {
1675         fastDetector_.threshold = threshold;
1676         fastDetector_.nonmaxSupression = nonmaxSupression;
1677     }
1678
1679     //! release temporary buffer's memory
1680     void release();
1681
1682     //! if true, image will be blurred before descriptors calculation
1683     bool blurForDescriptor;
1684
1685 private:
1686     enum { kBytes = 32 };
1687
1688     void buildScalePyramids(const GpuMat& image, const GpuMat& mask);
1689
1690     void computeKeyPointsPyramid();
1691
1692     void computeDescriptors(GpuMat& descriptors);
1693
1694     void mergeKeyPoints(GpuMat& keypoints);
1695
1696     int nFeatures_;
1697     float scaleFactor_;
1698     int nLevels_;
1699     int edgeThreshold_;
1700     int firstLevel_;
1701     int WTA_K_;
1702     int scoreType_;
1703     int patchSize_;
1704
1705     // The number of desired features per scale
1706     std::vector<size_t> n_features_per_level_;
1707
1708     // Points to compute BRIEF descriptors from
1709     GpuMat pattern_;
1710
1711     std::vector<GpuMat> imagePyr_;
1712     std::vector<GpuMat> maskPyr_;
1713
1714     GpuMat buf_;
1715
1716     std::vector<GpuMat> keyPointsPyr_;
1717     std::vector<int> keyPointsCount_;
1718
1719     FAST_GPU fastDetector_;
1720
1721     Ptr<FilterEngine_GPU> blurFilter;
1722
1723     GpuMat d_keypoints_;
1724 };
1725
1726 ////////////////////////////////// Optical Flow //////////////////////////////////////////
1727
1728 class CV_EXPORTS BroxOpticalFlow
1729 {
1730 public:
1731     BroxOpticalFlow(float alpha_, float gamma_, float scale_factor_, int inner_iterations_, int outer_iterations_, int solver_iterations_) :
1732         alpha(alpha_), gamma(gamma_), scale_factor(scale_factor_),
1733         inner_iterations(inner_iterations_), outer_iterations(outer_iterations_), solver_iterations(solver_iterations_)
1734     {
1735     }
1736
1737     //! Compute optical flow
1738     //! frame0 - source frame (supports only CV_32FC1 type)
1739     //! frame1 - frame to track (with the same size and type as frame0)
1740     //! u      - flow horizontal component (along x axis)
1741     //! v      - flow vertical component (along y axis)
1742     void operator ()(const GpuMat& frame0, const GpuMat& frame1, GpuMat& u, GpuMat& v, Stream& stream = Stream::Null());
1743
1744     //! flow smoothness
1745     float alpha;
1746
1747     //! gradient constancy importance
1748     float gamma;
1749
1750     //! pyramid scale factor
1751     float scale_factor;
1752
1753     //! number of lagged non-linearity iterations (inner loop)
1754     int inner_iterations;
1755
1756     //! number of warping iterations (number of pyramid levels)
1757     int outer_iterations;
1758
1759     //! number of linear system solver iterations
1760     int solver_iterations;
1761
1762     GpuMat buf;
1763 };
1764
1765 class CV_EXPORTS GoodFeaturesToTrackDetector_GPU
1766 {
1767 public:
1768     explicit GoodFeaturesToTrackDetector_GPU(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0,
1769         int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04);
1770
1771     //! return 1 rows matrix with CV_32FC2 type
1772     void operator ()(const GpuMat& image, GpuMat& corners, const GpuMat& mask = GpuMat());
1773
1774     int maxCorners;
1775     double qualityLevel;
1776     double minDistance;
1777
1778     int blockSize;
1779     bool useHarrisDetector;
1780     double harrisK;
1781
1782     void releaseMemory()
1783     {
1784         Dx_.release();
1785         Dy_.release();
1786         buf_.release();
1787         eig_.release();
1788         minMaxbuf_.release();
1789         tmpCorners_.release();
1790     }
1791
1792 private:
1793     GpuMat Dx_;
1794     GpuMat Dy_;
1795     GpuMat buf_;
1796     GpuMat eig_;
1797     GpuMat minMaxbuf_;
1798     GpuMat tmpCorners_;
1799 };
1800
1801 inline GoodFeaturesToTrackDetector_GPU::GoodFeaturesToTrackDetector_GPU(int maxCorners_, double qualityLevel_, double minDistance_,
1802         int blockSize_, bool useHarrisDetector_, double harrisK_)
1803 {
1804     maxCorners = maxCorners_;
1805     qualityLevel = qualityLevel_;
1806     minDistance = minDistance_;
1807     blockSize = blockSize_;
1808     useHarrisDetector = useHarrisDetector_;
1809     harrisK = harrisK_;
1810 }
1811
1812
1813 class CV_EXPORTS PyrLKOpticalFlow
1814 {
1815 public:
1816     PyrLKOpticalFlow();
1817
1818     void sparse(const GpuMat& prevImg, const GpuMat& nextImg, const GpuMat& prevPts, GpuMat& nextPts,
1819         GpuMat& status, GpuMat* err = 0);
1820
1821     void dense(const GpuMat& prevImg, const GpuMat& nextImg, GpuMat& u, GpuMat& v, GpuMat* err = 0);
1822
1823     void releaseMemory();
1824
1825     Size winSize;
1826     int maxLevel;
1827     int iters;
1828     double derivLambda; //unused
1829     bool useInitialFlow;
1830     float minEigThreshold; //unused
1831     bool getMinEigenVals;  //unused
1832
1833 private:
1834     GpuMat uPyr_[2];
1835     vector<GpuMat> prevPyr_;
1836     vector<GpuMat> nextPyr_;
1837     GpuMat vPyr_[2];
1838     vector<GpuMat> buf_;
1839     vector<GpuMat> unused;
1840     bool isDeviceArch11_;
1841 };
1842
1843
1844 class CV_EXPORTS FarnebackOpticalFlow
1845 {
1846 public:
1847     FarnebackOpticalFlow()
1848     {
1849         numLevels = 5;
1850         pyrScale = 0.5;
1851         fastPyramids = false;
1852         winSize = 13;
1853         numIters = 10;
1854         polyN = 5;
1855         polySigma = 1.1;
1856         flags = 0;
1857         isDeviceArch11_ = !DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
1858     }
1859
1860     int numLevels;
1861     double pyrScale;
1862     bool fastPyramids;
1863     int winSize;
1864     int numIters;
1865     int polyN;
1866     double polySigma;
1867     int flags;
1868
1869     void operator ()(const GpuMat &frame0, const GpuMat &frame1, GpuMat &flowx, GpuMat &flowy, Stream &s = Stream::Null());
1870
1871     void releaseMemory()
1872     {
1873         frames_[0].release();
1874         frames_[1].release();
1875         pyrLevel_[0].release();
1876         pyrLevel_[1].release();
1877         M_.release();
1878         bufM_.release();
1879         R_[0].release();
1880         R_[1].release();
1881         blurredFrame_[0].release();
1882         blurredFrame_[1].release();
1883         pyramid0_.clear();
1884         pyramid1_.clear();
1885     }
1886
1887 private:
1888     void prepareGaussian(
1889             int n, double sigma, float *g, float *xg, float *xxg,
1890             double &ig11, double &ig03, double &ig33, double &ig55);
1891
1892     void setPolynomialExpansionConsts(int n, double sigma);
1893
1894     void updateFlow_boxFilter(
1895             const GpuMat& R0, const GpuMat& R1, GpuMat& flowx, GpuMat &flowy,
1896             GpuMat& M, GpuMat &bufM, int blockSize, bool updateMatrices, Stream streams[]);
1897
1898     void updateFlow_gaussianBlur(
1899             const GpuMat& R0, const GpuMat& R1, GpuMat& flowx, GpuMat& flowy,
1900             GpuMat& M, GpuMat &bufM, int blockSize, bool updateMatrices, Stream streams[]);
1901
1902     GpuMat frames_[2];
1903     GpuMat pyrLevel_[2], M_, bufM_, R_[2], blurredFrame_[2];
1904     std::vector<GpuMat> pyramid0_, pyramid1_;
1905
1906     bool isDeviceArch11_;
1907 };
1908
1909
1910 // Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
1911 //
1912 // see reference:
1913 //   [1] C. Zach, T. Pock and H. Bischof, "A Duality Based Approach for Realtime TV-L1 Optical Flow".
1914 //   [2] Javier Sanchez, Enric Meinhardt-Llopis and Gabriele Facciolo. "TV-L1 Optical Flow Estimation".
1915 class CV_EXPORTS OpticalFlowDual_TVL1_GPU
1916 {
1917 public:
1918     OpticalFlowDual_TVL1_GPU();
1919
1920     void operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy);
1921
1922     void collectGarbage();
1923
1924     /**
1925      * Time step of the numerical scheme.
1926      */
1927     double tau;
1928
1929     /**
1930      * Weight parameter for the data term, attachment parameter.
1931      * This is the most relevant parameter, which determines the smoothness of the output.
1932      * The smaller this parameter is, the smoother the solutions we obtain.
1933      * It depends on the range of motions of the images, so its value should be adapted to each image sequence.
1934      */
1935     double lambda;
1936
1937     /**
1938      * Weight parameter for (u - v)^2, tightness parameter.
1939      * It serves as a link between the attachment and the regularization terms.
1940      * In theory, it should have a small value in order to maintain both parts in correspondence.
1941      * The method is stable for a large range of values of this parameter.
1942      */
1943     double theta;
1944
1945     /**
1946      * Number of scales used to create the pyramid of images.
1947      */
1948     int nscales;
1949
1950     /**
1951      * Number of warpings per scale.
1952      * Represents the number of times that I1(x+u0) and grad( I1(x+u0) ) are computed per scale.
1953      * This is a parameter that assures the stability of the method.
1954      * It also affects the running time, so it is a compromise between speed and accuracy.
1955      */
1956     int warps;
1957
1958     /**
1959      * Stopping criterion threshold used in the numerical scheme, which is a trade-off between precision and running time.
1960      * A small value will yield more accurate solutions at the expense of a slower convergence.
1961      */
1962     double epsilon;
1963
1964     /**
1965      * Stopping criterion iterations number used in the numerical scheme.
1966      */
1967     int iterations;
1968
1969     bool useInitialFlow;
1970
1971 private:
1972     void procOneScale(const GpuMat& I0, const GpuMat& I1, GpuMat& u1, GpuMat& u2);
1973
1974     std::vector<GpuMat> I0s;
1975     std::vector<GpuMat> I1s;
1976     std::vector<GpuMat> u1s;
1977     std::vector<GpuMat> u2s;
1978
1979     GpuMat I1x_buf;
1980     GpuMat I1y_buf;
1981
1982     GpuMat I1w_buf;
1983     GpuMat I1wx_buf;
1984     GpuMat I1wy_buf;
1985
1986     GpuMat grad_buf;
1987     GpuMat rho_c_buf;
1988
1989     GpuMat p11_buf;
1990     GpuMat p12_buf;
1991     GpuMat p21_buf;
1992     GpuMat p22_buf;
1993
1994     GpuMat diff_buf;
1995     GpuMat norm_buf;
1996 };
1997
1998
1999 //! Calculates optical flow for 2 images using block matching algorithm */
2000 CV_EXPORTS void calcOpticalFlowBM(const GpuMat& prev, const GpuMat& curr,
2001                                   Size block_size, Size shift_size, Size max_range, bool use_previous,
2002                                   GpuMat& velx, GpuMat& vely, GpuMat& buf,
2003                                   Stream& stream = Stream::Null());
2004
2005 class CV_EXPORTS FastOpticalFlowBM
2006 {
2007 public:
2008     void operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy, int search_window = 21, int block_window = 7, Stream& s = Stream::Null());
2009
2010 private:
2011     GpuMat buffer;
2012     GpuMat extended_I0;
2013     GpuMat extended_I1;
2014 };
2015
2016
2017 //! Interpolate frames (images) using provided optical flow (displacement field).
2018 //! frame0   - frame 0 (32-bit floating point images, single channel)
2019 //! frame1   - frame 1 (the same type and size)
2020 //! fu       - forward horizontal displacement
2021 //! fv       - forward vertical displacement
2022 //! bu       - backward horizontal displacement
2023 //! bv       - backward vertical displacement
2024 //! pos      - new frame position
2025 //! newFrame - new frame
2026 //! buf      - temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 GpuMat;
2027 //!            occlusion masks            0, occlusion masks            1,
2028 //!            interpolated forward flow  0, interpolated forward flow  1,
2029 //!            interpolated backward flow 0, interpolated backward flow 1
2030 //!
2031 CV_EXPORTS void interpolateFrames(const GpuMat& frame0, const GpuMat& frame1,
2032                                   const GpuMat& fu, const GpuMat& fv,
2033                                   const GpuMat& bu, const GpuMat& bv,
2034                                   float pos, GpuMat& newFrame, GpuMat& buf,
2035                                   Stream& stream = Stream::Null());
2036
2037 CV_EXPORTS void createOpticalFlowNeedleMap(const GpuMat& u, const GpuMat& v, GpuMat& vertex, GpuMat& colors);
2038
2039
2040 //////////////////////// Background/foreground segmentation ////////////////////////
2041
2042 // Foreground Object Detection from Videos Containing Complex Background.
2043 // Liyuan Li, Weimin Huang, Irene Y.H. Gu, and Qi Tian.
2044 // ACM MM2003 9p
2045 class CV_EXPORTS FGDStatModel
2046 {
2047 public:
2048     struct CV_EXPORTS Params
2049     {
2050         int Lc;  // Quantized levels per 'color' component. Power of two, typically 32, 64 or 128.
2051         int N1c; // Number of color vectors used to model normal background color variation at a given pixel.
2052         int N2c; // Number of color vectors retained at given pixel.  Must be > N1c, typically ~ 5/3 of N1c.
2053         // Used to allow the first N1c vectors to adapt over time to changing background.
2054
2055         int Lcc;  // Quantized levels per 'color co-occurrence' component.  Power of two, typically 16, 32 or 64.
2056         int N1cc; // Number of color co-occurrence vectors used to model normal background color variation at a given pixel.
2057         int N2cc; // Number of color co-occurrence vectors retained at given pixel.  Must be > N1cc, typically ~ 5/3 of N1cc.
2058         // Used to allow the first N1cc vectors to adapt over time to changing background.
2059
2060         bool is_obj_without_holes; // If TRUE we ignore holes within foreground blobs. Defaults to TRUE.
2061         int perform_morphing;     // Number of erode-dilate-erode foreground-blob cleanup iterations.
2062         // These erase one-pixel junk blobs and merge almost-touching blobs. Default value is 1.
2063
2064         float alpha1; // How quickly we forget old background pixel values seen. Typically set to 0.1.
2065         float alpha2; // "Controls speed of feature learning". Depends on T. Typical value circa 0.005.
2066         float alpha3; // Alternate to alpha2, used (e.g.) for quicker initial convergence. Typical value 0.1.
2067
2068         float delta;   // Affects color and color co-occurrence quantization, typically set to 2.
2069         float T;       // A percentage value which determines when new features can be recognized as new background. (Typically 0.9).
2070         float minArea; // Discard foreground blobs whose bounding box is smaller than this threshold.
2071
2072         // default Params
2073         Params();
2074     };
2075
2076     // out_cn - channels count in output result (can be 3 or 4)
2077     // 4-channels require more memory, but a bit faster
2078     explicit FGDStatModel(int out_cn = 3);
2079     explicit FGDStatModel(const cv::gpu::GpuMat& firstFrame, const Params& params = Params(), int out_cn = 3);
2080
2081     ~FGDStatModel();
2082
2083     void create(const cv::gpu::GpuMat& firstFrame, const Params& params = Params());
2084     void release();
2085
2086     int update(const cv::gpu::GpuMat& curFrame);
2087
2088     //8UC3 or 8UC4 reference background image
2089     cv::gpu::GpuMat background;
2090
2091     //8UC1 foreground image
2092     cv::gpu::GpuMat foreground;
2093
2094     std::vector< std::vector<cv::Point> > foreground_regions;
2095
2096 private:
2097     FGDStatModel(const FGDStatModel&);
2098     FGDStatModel& operator=(const FGDStatModel&);
2099
2100     class Impl;
2101     std::auto_ptr<Impl> impl_;
2102 };
2103
2104 /*!
2105  Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm
2106
2107  The class implements the following algorithm:
2108  "An improved adaptive background mixture model for real-time tracking with shadow detection"
2109  P. KadewTraKuPong and R. Bowden,
2110  Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001."
2111  http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
2112 */
2113 class CV_EXPORTS MOG_GPU
2114 {
2115 public:
2116     //! the default constructor
2117     MOG_GPU(int nmixtures = -1);
2118
2119     //! re-initiaization method
2120     void initialize(Size frameSize, int frameType);
2121
2122     //! the update operator
2123     void operator()(const GpuMat& frame, GpuMat& fgmask, float learningRate = 0.0f, Stream& stream = Stream::Null());
2124
2125     //! computes a background image which are the mean of all background gaussians
2126     void getBackgroundImage(GpuMat& backgroundImage, Stream& stream = Stream::Null()) const;
2127
2128     //! releases all inner buffers
2129     void release();
2130
2131     int history;
2132     float varThreshold;
2133     float backgroundRatio;
2134     float noiseSigma;
2135
2136 private:
2137     int nmixtures_;
2138
2139     Size frameSize_;
2140     int frameType_;
2141     int nframes_;
2142
2143     GpuMat weight_;
2144     GpuMat sortKey_;
2145     GpuMat mean_;
2146     GpuMat var_;
2147 };
2148
2149 /*!
2150  The class implements the following algorithm:
2151  "Improved adaptive Gausian mixture model for background subtraction"
2152  Z.Zivkovic
2153  International Conference Pattern Recognition, UK, August, 2004.
2154  http://www.zoranz.net/Publications/zivkovic2004ICPR.pdf
2155 */
2156 class CV_EXPORTS MOG2_GPU
2157 {
2158 public:
2159     //! the default constructor
2160     MOG2_GPU(int nmixtures = -1);
2161
2162     //! re-initiaization method
2163     void initialize(Size frameSize, int frameType);
2164
2165     //! the update operator
2166     void operator()(const GpuMat& frame, GpuMat& fgmask, float learningRate = -1.0f, Stream& stream = Stream::Null());
2167
2168     //! computes a background image which are the mean of all background gaussians
2169     void getBackgroundImage(GpuMat& backgroundImage, Stream& stream = Stream::Null()) const;
2170
2171     //! releases all inner buffers
2172     void release();
2173
2174     // parameters
2175     // you should call initialize after parameters changes
2176
2177     int history;
2178
2179     //! here it is the maximum allowed number of mixture components.
2180     //! Actual number is determined dynamically per pixel
2181     float varThreshold;
2182     // threshold on the squared Mahalanobis distance to decide if it is well described
2183     // by the background model or not. Related to Cthr from the paper.
2184     // This does not influence the update of the background. A typical value could be 4 sigma
2185     // and that is varThreshold=4*4=16; Corresponds to Tb in the paper.
2186
2187     /////////////////////////
2188     // less important parameters - things you might change but be carefull
2189     ////////////////////////
2190
2191     float backgroundRatio;
2192     // corresponds to fTB=1-cf from the paper
2193     // TB - threshold when the component becomes significant enough to be included into
2194     // the background model. It is the TB=1-cf from the paper. So I use cf=0.1 => TB=0.
2195     // For alpha=0.001 it means that the mode should exist for approximately 105 frames before
2196     // it is considered foreground
2197     // float noiseSigma;
2198     float varThresholdGen;
2199
2200     //correspondts to Tg - threshold on the squared Mahalan. dist. to decide
2201     //when a sample is close to the existing components. If it is not close
2202     //to any a new component will be generated. I use 3 sigma => Tg=3*3=9.
2203     //Smaller Tg leads to more generated components and higher Tg might make
2204     //lead to small number of components but they can grow too large
2205     float fVarInit;
2206     float fVarMin;
2207     float fVarMax;
2208
2209     //initial variance  for the newly generated components.
2210     //It will will influence the speed of adaptation. A good guess should be made.
2211     //A simple way is to estimate the typical standard deviation from the images.
2212     //I used here 10 as a reasonable value
2213     // min and max can be used to further control the variance
2214     float fCT; //CT - complexity reduction prior
2215     //this is related to the number of samples needed to accept that a component
2216     //actually exists. We use CT=0.05 of all the samples. By setting CT=0 you get
2217     //the standard Stauffer&Grimson algorithm (maybe not exact but very similar)
2218
2219     //shadow detection parameters
2220     bool bShadowDetection; //default 1 - do shadow detection
2221     unsigned char nShadowDetection; //do shadow detection - insert this value as the detection result - 127 default value
2222     float fTau;
2223     // Tau - shadow threshold. The shadow is detected if the pixel is darker
2224     //version of the background. Tau is a threshold on how much darker the shadow can be.
2225     //Tau= 0.5 means that if pixel is more than 2 times darker then it is not shadow
2226     //See: Prati,Mikic,Trivedi,Cucchiarra,"Detecting Moving Shadows...",IEEE PAMI,2003.
2227
2228 private:
2229     int nmixtures_;
2230
2231     Size frameSize_;
2232     int frameType_;
2233     int nframes_;
2234
2235     GpuMat weight_;
2236     GpuMat variance_;
2237     GpuMat mean_;
2238
2239     GpuMat bgmodelUsedModes_; //keep track of number of modes per pixel
2240 };
2241
2242 /**
2243  * Background Subtractor module. Takes a series of images and returns a sequence of mask (8UC1)
2244  * images of the same size, where 255 indicates Foreground and 0 represents Background.
2245  * This class implements an algorithm described in "Visual Tracking of Human Visitors under
2246  * Variable-Lighting Conditions for a Responsive Audio Art Installation," A. Godbehere,
2247  * A. Matsukawa, K. Goldberg, American Control Conference, Montreal, June 2012.
2248  */
2249 class CV_EXPORTS GMG_GPU
2250 {
2251 public:
2252     GMG_GPU();
2253
2254     /**
2255      * Validate parameters and set up data structures for appropriate frame size.
2256      * @param frameSize Input frame size
2257      * @param min       Minimum value taken on by pixels in image sequence. Usually 0
2258      * @param max       Maximum value taken on by pixels in image sequence. e.g. 1.0 or 255
2259      */
2260     void initialize(Size frameSize, float min = 0.0f, float max = 255.0f);
2261
2262     /**
2263      * Performs single-frame background subtraction and builds up a statistical background image
2264      * model.
2265      * @param frame        Input frame
2266      * @param fgmask       Output mask image representing foreground and background pixels
2267      * @param stream       Stream for the asynchronous version
2268      */
2269     void operator ()(const GpuMat& frame, GpuMat& fgmask, float learningRate = -1.0f, Stream& stream = Stream::Null());
2270
2271     //! Releases all inner buffers
2272     void release();
2273
2274     //! Total number of distinct colors to maintain in histogram.
2275     int maxFeatures;
2276
2277     //! Set between 0.0 and 1.0, determines how quickly features are "forgotten" from histograms.
2278     float learningRate;
2279
2280     //! Number of frames of video to use to initialize histograms.
2281     int numInitializationFrames;
2282
2283     //! Number of discrete levels in each channel to be used in histograms.
2284     int quantizationLevels;
2285
2286     //! Prior probability that any given pixel is a background pixel. A sensitivity parameter.
2287     float backgroundPrior;
2288
2289     //! Value above which pixel is determined to be FG.
2290     float decisionThreshold;
2291
2292     //! Smoothing radius, in pixels, for cleaning up FG image.
2293     int smoothingRadius;
2294
2295     //! Perform background model update.
2296     bool updateBackgroundModel;
2297
2298 private:
2299     float maxVal_, minVal_;
2300
2301     Size frameSize_;
2302
2303     int frameNum_;
2304
2305     GpuMat nfeatures_;
2306     GpuMat colors_;
2307     GpuMat weights_;
2308
2309     Ptr<FilterEngine_GPU> boxFilter_;
2310     GpuMat buf_;
2311 };
2312
2313 ////////////////////////////////// Video Encoding //////////////////////////////////
2314
2315 // Works only under Windows
2316 // Supports olny H264 video codec and AVI files
2317 class CV_EXPORTS VideoWriter_GPU
2318 {
2319 public:
2320     struct EncoderParams;
2321
2322     // Callbacks for video encoder, use it if you want to work with raw video stream
2323     class EncoderCallBack;
2324
2325     enum SurfaceFormat
2326     {
2327         SF_UYVY = 0,
2328         SF_YUY2,
2329         SF_YV12,
2330         SF_NV12,
2331         SF_IYUV,
2332         SF_BGR,
2333         SF_GRAY = SF_BGR
2334     };
2335
2336     VideoWriter_GPU();
2337     VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
2338     VideoWriter_GPU(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
2339     VideoWriter_GPU(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
2340     VideoWriter_GPU(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
2341     ~VideoWriter_GPU();
2342
2343     // all methods throws cv::Exception if error occurs
2344     void open(const std::string& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
2345     void open(const std::string& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
2346     void open(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
2347     void open(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
2348
2349     bool isOpened() const;
2350     void close();
2351
2352     void write(const cv::gpu::GpuMat& image, bool lastFrame = false);
2353
2354     struct CV_EXPORTS EncoderParams
2355     {
2356         int       P_Interval;      //    NVVE_P_INTERVAL,
2357         int       IDR_Period;      //    NVVE_IDR_PERIOD,
2358         int       DynamicGOP;      //    NVVE_DYNAMIC_GOP,
2359         int       RCType;          //    NVVE_RC_TYPE,
2360         int       AvgBitrate;      //    NVVE_AVG_BITRATE,
2361         int       PeakBitrate;     //    NVVE_PEAK_BITRATE,
2362         int       QP_Level_Intra;  //    NVVE_QP_LEVEL_INTRA,
2363         int       QP_Level_InterP; //    NVVE_QP_LEVEL_INTER_P,
2364         int       QP_Level_InterB; //    NVVE_QP_LEVEL_INTER_B,
2365         int       DeblockMode;     //    NVVE_DEBLOCK_MODE,
2366         int       ProfileLevel;    //    NVVE_PROFILE_LEVEL,
2367         int       ForceIntra;      //    NVVE_FORCE_INTRA,
2368         int       ForceIDR;        //    NVVE_FORCE_IDR,
2369         int       ClearStat;       //    NVVE_CLEAR_STAT,
2370         int       DIMode;          //    NVVE_SET_DEINTERLACE,
2371         int       Presets;         //    NVVE_PRESETS,
2372         int       DisableCabac;    //    NVVE_DISABLE_CABAC,
2373         int       NaluFramingType; //    NVVE_CONFIGURE_NALU_FRAMING_TYPE
2374         int       DisableSPSPPS;   //    NVVE_DISABLE_SPS_PPS
2375
2376         EncoderParams();
2377         explicit EncoderParams(const std::string& configFile);
2378
2379         void load(const std::string& configFile);
2380         void save(const std::string& configFile) const;
2381     };
2382
2383     EncoderParams getParams() const;
2384
2385     class CV_EXPORTS EncoderCallBack
2386     {
2387     public:
2388         enum PicType
2389         {
2390             IFRAME = 1,
2391             PFRAME = 2,
2392             BFRAME = 3
2393         };
2394
2395         virtual ~EncoderCallBack() {}
2396
2397         // callback function to signal the start of bitstream that is to be encoded
2398         // must return pointer to buffer
2399         virtual uchar* acquireBitStream(int* bufferSize) = 0;
2400
2401         // callback function to signal that the encoded bitstream is ready to be written to file
2402         virtual void releaseBitStream(unsigned char* data, int size) = 0;
2403
2404         // callback function to signal that the encoding operation on the frame has started
2405         virtual void onBeginFrame(int frameNumber, PicType picType) = 0;
2406
2407         // callback function signals that the encoding operation on the frame has finished
2408         virtual void onEndFrame(int frameNumber, PicType picType) = 0;
2409     };
2410
2411 private:
2412     VideoWriter_GPU(const VideoWriter_GPU&);
2413     VideoWriter_GPU& operator=(const VideoWriter_GPU&);
2414
2415     class Impl;
2416     std::auto_ptr<Impl> impl_;
2417 };
2418
2419
2420 ////////////////////////////////// Video Decoding //////////////////////////////////////////
2421
2422 namespace detail
2423 {
2424     class FrameQueue;
2425     class VideoParser;
2426 }
2427
2428 class CV_EXPORTS VideoReader_GPU
2429 {
2430 public:
2431     enum Codec
2432     {
2433         MPEG1 = 0,
2434         MPEG2,
2435         MPEG4,
2436         VC1,
2437         H264,
2438         JPEG,
2439         H264_SVC,
2440         H264_MVC,
2441
2442         Uncompressed_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   // Y,U,V (4:2:0)
2443         Uncompressed_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   // Y,V,U (4:2:0)
2444         Uncompressed_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   // Y,UV  (4:2:0)
2445         Uncompressed_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   // YUYV/YUY2 (4:2:2)
2446         Uncompressed_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y')),   // UYVY (4:2:2)
2447     };
2448
2449     enum ChromaFormat
2450     {
2451         Monochrome=0,
2452         YUV420,
2453         YUV422,
2454         YUV444,
2455     };
2456
2457     struct FormatInfo
2458     {
2459         Codec codec;
2460         ChromaFormat chromaFormat;
2461         int width;
2462         int height;
2463     };
2464
2465     class VideoSource;
2466
2467     VideoReader_GPU();
2468     explicit VideoReader_GPU(const std::string& filename);
2469     explicit VideoReader_GPU(const cv::Ptr<VideoSource>& source);
2470
2471     ~VideoReader_GPU();
2472
2473     void open(const std::string& filename);
2474     void open(const cv::Ptr<VideoSource>& source);
2475     bool isOpened() const;
2476
2477     void close();
2478
2479     bool read(GpuMat& image);
2480
2481     FormatInfo format() const;
2482     void dumpFormat(std::ostream& st);
2483
2484     class CV_EXPORTS VideoSource
2485     {
2486     public:
2487         VideoSource() : frameQueue_(0), videoParser_(0) {}
2488         virtual ~VideoSource() {}
2489
2490         virtual FormatInfo format() const = 0;
2491         virtual void start() = 0;
2492         virtual void stop() = 0;
2493         virtual bool isStarted() const = 0;
2494         virtual bool hasError() const = 0;
2495
2496         void setFrameQueue(detail::FrameQueue* frameQueue) { frameQueue_ = frameQueue; }
2497         void setVideoParser(detail::VideoParser* videoParser) { videoParser_ = videoParser; }
2498
2499     protected:
2500         bool parseVideoData(const uchar* data, size_t size, bool endOfStream = false);
2501
2502     private:
2503         VideoSource(const VideoSource&);
2504         VideoSource& operator =(const VideoSource&);
2505
2506         detail::FrameQueue* frameQueue_;
2507         detail::VideoParser* videoParser_;
2508     };
2509
2510 private:
2511     VideoReader_GPU(const VideoReader_GPU&);
2512     VideoReader_GPU& operator =(const VideoReader_GPU&);
2513
2514     class Impl;
2515     std::auto_ptr<Impl> impl_;
2516 };
2517
2518 //! removes points (CV_32FC2, single row matrix) with zero mask value
2519 CV_EXPORTS void compactPoints(GpuMat &points0, GpuMat &points1, const GpuMat &mask);
2520
2521 CV_EXPORTS void calcWobbleSuppressionMaps(
2522         int left, int idx, int right, Size size, const Mat &ml, const Mat &mr,
2523         GpuMat &mapx, GpuMat &mapy);
2524
2525 } // namespace gpu
2526
2527 } // namespace cv
2528
2529 #endif /* __OPENCV_GPU_HPP__ */