1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
11 // For Open Source Computer Vision Library
13 // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
14 // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
15 // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
16 // Third party copyrights are property of their respective owners.
18 // Redistribution and use in source and binary forms, with or without modification,
19 // are permitted provided that the following conditions are met:
21 // * Redistribution's of source code must retain the above copyright notice,
22 // this list of conditions and the following disclaimer.
24 // * Redistribution's in binary form must reproduce the above copyright notice,
25 // this list of conditions and the following disclaimer in the documentation
26 // and/or other oclMaterials provided with the distribution.
28 // * The name of the copyright holders may not be used to endorse or promote products
29 // derived from this software without specific prior written permission.
31 // This software is provided by the copyright holders and contributors "as is" and
32 // any express or implied warranties, including, but not limited to, the implied
33 // warranties of merchantability and fitness for a particular purpose are disclaimed.
34 // In no event shall the Intel Corporation or contributors be liable for any direct,
35 // indirect, incidental, special, exemplary, or consequential damages
36 // (including, but not limited to, procurement of substitute goods or services;
37 // loss of use, data, or profits; or business interruption) however caused
38 // and on any theory of liability, whether in contract, strict liability,
39 // or tort (including negligence or otherwise) arising in any way out of
40 // the use of this software, even if advised of the possibility of such damage.
44 #ifndef __OPENCV_OCL_HPP__
45 #define __OPENCV_OCL_HPP__
50 #include "opencv2/core.hpp"
51 #include "opencv2/imgproc.hpp"
52 #include "opencv2/objdetect.hpp"
60 CVCL_DEVICE_TYPE_DEFAULT = (1 << 0),
61 CVCL_DEVICE_TYPE_CPU = (1 << 1),
62 CVCL_DEVICE_TYPE_GPU = (1 << 2),
63 CVCL_DEVICE_TYPE_ACCELERATOR = (1 << 3),
64 //CVCL_DEVICE_TYPE_CUSTOM = (1 << 4)
65 CVCL_DEVICE_TYPE_ALL = 0xFFFFFFFF
77 DEVICE_MEM_DEFAULT = 0,
78 DEVICE_MEM_AHP, //alloc host pointer
79 DEVICE_MEM_UHP, //use host pointer
80 DEVICE_MEM_CHP, //copy host pointer
81 DEVICE_MEM_PM //persistent memory
84 //Get the global device memory and read/write type
85 //return 1 if unified memory system supported, otherwise return 0
86 CV_EXPORTS int getDevMemType(DevMemRW& rw_type, DevMemType& mem_type);
88 //Set the global device memory and read/write type,
89 //the newly generated oclMat will all use this type
90 //return -1 if the target type is unsupported, otherwise return 0
91 CV_EXPORTS int setDevMemType(DevMemRW rw_type = DEVICE_MEM_R_W, DevMemType mem_type = DEVICE_MEM_DEFAULT);
93 //this class contains ocl runtime information
104 Info &operator = (const Info &m);
105 std::vector<String> DeviceName;
108 //////////////////////////////// Initialization & Info ////////////////////////
109 //this function may be obsoleted
110 //CV_EXPORTS cl_device_id getDevice();
111 //the function must be called before any other cv::ocl::functions, it initialize ocl runtime
112 //each Info relates to an OpenCL platform
113 //there is one or more devices in each platform, each one has a separate name
114 CV_EXPORTS int getDevice(std::vector<Info> &oclinfo, int devicetype = CVCL_DEVICE_TYPE_GPU);
116 //set device you want to use, optional function after getDevice be called
117 //the devnum is the index of the selected device in DeviceName vector of INfo
118 CV_EXPORTS void setDevice(Info &oclinfo, int devnum = 0);
120 //The two functions below enable other opencl program to use ocl module's cl_context and cl_command_queue
121 //returns cl_context *
122 CV_EXPORTS void* getoclContext();
123 //returns cl_command_queue *
124 CV_EXPORTS void* getoclCommandQueue();
126 //explicit call clFinish. The global command queue will be used.
127 CV_EXPORTS void finish();
129 //this function enable ocl module to use customized cl_context and cl_command_queue
130 //getDevice also need to be called before this function
131 CV_EXPORTS void setDeviceEx(Info &oclinfo, void *ctx, void *qu, int devnum = 0);
133 //returns true when global OpenCL context is initialized
134 CV_EXPORTS bool initialized();
136 //////////////////////////////// OpenCL context ////////////////////////
137 //This is a global singleton class used to represent a OpenCL context.
138 class CV_EXPORTS Context
142 friend class std::auto_ptr<Context>;
143 friend bool initialized();
145 static std::auto_ptr<Context> clCxt;
152 static Context *getContext();
153 static void setContext(Info &oclinfo);
155 enum {CL_DOUBLE, CL_UNIFIED_MEM, CL_VER_1_2};
156 bool supportsFeature(int ftype);
157 size_t computeUnits();
158 size_t maxWorkGroupSize();
160 void* oclCommandQueue();
163 //! Calls a kernel, by string. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing.
164 CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt ,
165 const char **source, String kernelName,
166 size_t globalThreads[3], size_t localThreads[3],
167 std::vector< std::pair<size_t, const void *> > &args,
168 int channels, int depth, const char *build_options,
169 bool finish = true, bool measureKernelTime = false,
170 bool cleanUp = true);
172 //! Calls a kernel, by file. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing.
173 CV_EXPORTS double openCLExecuteKernelInterop(Context *clCxt ,
174 const char **fileName, const int numFiles, String kernelName,
175 size_t globalThreads[3], size_t localThreads[3],
176 std::vector< std::pair<size_t, const void *> > &args,
177 int channels, int depth, const char *build_options,
178 bool finish = true, bool measureKernelTime = false,
179 bool cleanUp = true);
181 //! Enable or disable OpenCL program binary caching onto local disk
182 // After a program (*.cl files in opencl/ folder) is built at runtime, we allow the
183 // compiled OpenCL program to be cached to the path automatically as "path/*.clb"
184 // binary file, which will be reused when the OpenCV executable is started again.
186 // Caching mode is controlled by the following enums
188 // 1. the feature is by default enabled when OpenCV is built in release mode.
189 // 2. the CACHE_DEBUG / CACHE_RELEASE flags only effectively work with MSVC compiler;
190 // for GNU compilers, the function always treats the build as release mode (enabled by default).
193 CACHE_NONE = 0, // do not cache OpenCL binary
194 CACHE_DEBUG = 0x1 << 0, // cache OpenCL binary when built in debug mode (only work with MSVC)
195 CACHE_RELEASE = 0x1 << 1, // default behavior, only cache when built in release mode (only work with MSVC)
196 CACHE_ALL = CACHE_DEBUG | CACHE_RELEASE, // always cache opencl binary
197 CACHE_UPDATE = 0x1 << 2 // if the binary cache file with the same name is already on the disk, it will be updated.
199 CV_EXPORTS void setBinaryDiskCache(int mode = CACHE_RELEASE, cv::String path = "./");
201 //! set where binary cache to be saved to
202 CV_EXPORTS void setBinpath(const char *path);
204 class CV_EXPORTS oclMatExpr;
205 //////////////////////////////// oclMat ////////////////////////////////
206 class CV_EXPORTS oclMat
209 //! default constructor
211 //! constructs oclMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
212 oclMat(int rows, int cols, int type);
213 oclMat(Size size, int type);
214 //! constucts oclMatrix and fills it with the specified value _s.
215 oclMat(int rows, int cols, int type, const Scalar &s);
216 oclMat(Size size, int type, const Scalar &s);
218 oclMat(const oclMat &m);
220 //! constructor for oclMatrix headers pointing to user-allocated data
221 oclMat(int rows, int cols, int type, void *data, size_t step = Mat::AUTO_STEP);
222 oclMat(Size size, int type, void *data, size_t step = Mat::AUTO_STEP);
224 //! creates a matrix header for a part of the bigger matrix
225 oclMat(const oclMat &m, const Range &rowRange, const Range &colRange);
226 oclMat(const oclMat &m, const Rect &roi);
228 //! builds oclMat from Mat. Perfom blocking upload to device.
229 explicit oclMat (const Mat &m);
231 //! destructor - calls release()
234 //! assignment operators
235 oclMat &operator = (const oclMat &m);
236 //! assignment operator. Perfom blocking upload to device.
237 oclMat &operator = (const Mat &m);
238 oclMat &operator = (const oclMatExpr& expr);
240 //! pefroms blocking upload data to oclMat.
241 void upload(const cv::Mat &m);
244 //! downloads data from device to host memory. Blocking calls.
245 operator Mat() const;
246 void download(cv::Mat &m) const;
248 //! convert to _InputArray
249 operator _InputArray();
251 //! convert to _OutputArray
252 operator _OutputArray();
254 //! returns a new oclMatrix header for the specified row
255 oclMat row(int y) const;
256 //! returns a new oclMatrix header for the specified column
257 oclMat col(int x) const;
258 //! ... for the specified row span
259 oclMat rowRange(int startrow, int endrow) const;
260 oclMat rowRange(const Range &r) const;
261 //! ... for the specified column span
262 oclMat colRange(int startcol, int endcol) const;
263 oclMat colRange(const Range &r) const;
265 //! returns deep copy of the oclMatrix, i.e. the data is copied
266 oclMat clone() const;
267 //! copies the oclMatrix content to "m".
268 // It calls m.create(this->size(), this->type()).
269 // It supports any data type
270 void copyTo( oclMat &m ) const;
271 //! copies those oclMatrix elements to "m" that are marked with non-zero mask elements.
272 //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
273 void copyTo( oclMat &m, const oclMat &mask ) const;
274 //! converts oclMatrix to another datatype with optional scalng. See cvConvertScale.
275 //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
276 void convertTo( oclMat &m, int rtype, double alpha = 1, double beta = 0 ) const;
278 void assignTo( oclMat &m, int type = -1 ) const;
280 //! sets every oclMatrix element to s
281 //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
282 oclMat& operator = (const Scalar &s);
283 //! sets some of the oclMatrix elements to s, according to the mask
284 //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
285 oclMat& setTo(const Scalar &s, const oclMat &mask = oclMat());
286 //! creates alternative oclMatrix header for the same data, with different
287 // number of channels and/or different number of rows. see cvReshape.
288 oclMat reshape(int cn, int rows = 0) const;
290 //! allocates new oclMatrix data unless the oclMatrix already has specified size and type.
291 // previous data is unreferenced if needed.
292 void create(int rows, int cols, int type);
293 void create(Size size, int type);
295 //! allocates new oclMatrix with specified device memory type.
296 void createEx(int rows, int cols, int type,
297 DevMemRW rw_type, DevMemType mem_type, void* hptr = 0);
298 void createEx(Size size, int type, DevMemRW rw_type,
299 DevMemType mem_type, void* hptr = 0);
301 //! decreases reference counter;
302 // deallocate the data when reference counter reaches 0.
305 //! swaps with other smart pointer
306 void swap(oclMat &mat);
308 //! locates oclMatrix header within a parent oclMatrix. See below
309 void locateROI( Size &wholeSize, Point &ofs ) const;
310 //! moves/resizes the current oclMatrix ROI inside the parent oclMatrix.
311 oclMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
312 //! extracts a rectangular sub-oclMatrix
313 // (this is a generalized form of row, rowRange etc.)
314 oclMat operator()( Range rowRange, Range colRange ) const;
315 oclMat operator()( const Rect &roi ) const;
317 oclMat& operator+=( const oclMat& m );
318 oclMat& operator-=( const oclMat& m );
319 oclMat& operator*=( const oclMat& m );
320 oclMat& operator/=( const oclMat& m );
322 //! returns true if the oclMatrix data is continuous
323 // (i.e. when there are no gaps between successive rows).
324 // similar to CV_IS_oclMat_CONT(cvoclMat->type)
325 bool isContinuous() const;
326 //! returns element size in bytes,
327 // similar to CV_ELEM_SIZE(cvMat->type)
328 size_t elemSize() const;
329 //! returns the size of element channel in bytes.
330 size_t elemSize1() const;
331 //! returns element type, similar to CV_MAT_TYPE(cvMat->type)
333 //! returns element type, i.e. 8UC3 returns 8UC4 because in ocl
334 //! 3 channels element actually use 4 channel space
336 //! returns element type, similar to CV_MAT_DEPTH(cvMat->type)
338 //! returns element type, similar to CV_MAT_CN(cvMat->type)
339 int channels() const;
340 //! returns element type, return 4 for 3 channels element,
341 //!becuase 3 channels element actually use 4 channel space
342 int oclchannels() const;
343 //! returns step/elemSize1()
344 size_t step1() const;
345 //! returns oclMatrix size:
346 // width == number of columns, height == number of rows
348 //! returns true if oclMatrix data is NULL
351 //! returns pointer to y-th row
352 uchar* ptr(int y = 0);
353 const uchar *ptr(int y = 0) const;
355 //! template version of the above method
356 template<typename _Tp> _Tp *ptr(int y = 0);
357 template<typename _Tp> const _Tp *ptr(int y = 0) const;
359 //! matrix transposition
362 /*! includes several bit-fields:
363 - the magic signature
369 //! the number of rows and columns
371 //! a distance between successive rows in bytes; includes the gap if any
373 //! pointer to the data(OCL memory object)
376 //! pointer to the reference counter;
377 // when oclMatrix points to user-allocated data, the pointer is NULL
380 //! helper fields used in locateROI and adjustROI
381 //datastart and dataend are not used in current version
385 //! OpenCL context associated with the oclMat object.
387 //add offset for handle ROI, calculated in byte
389 //add wholerows and wholecols for the whole matrix, datastart and dataend are no longer used
394 // convert InputArray/OutputArray to oclMat references
395 CV_EXPORTS oclMat& getOclMatRef(InputArray src);
396 CV_EXPORTS oclMat& getOclMatRef(OutputArray src);
398 ///////////////////// mat split and merge /////////////////////////////////
399 //! Compose a multi-channel array from several single-channel arrays
401 CV_EXPORTS void merge(const oclMat *src, size_t n, oclMat &dst);
402 CV_EXPORTS void merge(const std::vector<oclMat> &src, oclMat &dst);
404 //! Divides multi-channel array into several single-channel arrays
406 CV_EXPORTS void split(const oclMat &src, oclMat *dst);
407 CV_EXPORTS void split(const oclMat &src, std::vector<oclMat> &dst);
409 ////////////////////////////// Arithmetics ///////////////////////////////////
410 //#if defined DOUBLE_SUPPORT
415 // CV_EXPORTS void addWeighted(const oclMat& a,F alpha, const oclMat& b,F beta,F gama, oclMat& c);
416 CV_EXPORTS void addWeighted(const oclMat &a, double alpha, const oclMat &b, double beta, double gama, oclMat &c);
417 //! adds one matrix to another (c = a + b)
418 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
419 CV_EXPORTS void add(const oclMat &a, const oclMat &b, oclMat &c);
420 //! adds one matrix to another (c = a + b)
421 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
422 CV_EXPORTS void add(const oclMat &a, const oclMat &b, oclMat &c, const oclMat &mask);
423 //! adds scalar to a matrix (c = a + s)
424 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
425 CV_EXPORTS void add(const oclMat &a, const Scalar &sc, oclMat &c, const oclMat &mask = oclMat());
426 //! subtracts one matrix from another (c = a - b)
427 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
428 CV_EXPORTS void subtract(const oclMat &a, const oclMat &b, oclMat &c);
429 //! subtracts one matrix from another (c = a - b)
430 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
431 CV_EXPORTS void subtract(const oclMat &a, const oclMat &b, oclMat &c, const oclMat &mask);
432 //! subtracts scalar from a matrix (c = a - s)
433 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
434 CV_EXPORTS void subtract(const oclMat &a, const Scalar &sc, oclMat &c, const oclMat &mask = oclMat());
435 //! subtracts scalar from a matrix (c = a - s)
436 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
437 CV_EXPORTS void subtract(const Scalar &sc, const oclMat &a, oclMat &c, const oclMat &mask = oclMat());
438 //! computes element-wise product of the two arrays (c = a * b)
439 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
440 CV_EXPORTS void multiply(const oclMat &a, const oclMat &b, oclMat &c, double scale = 1);
441 //! multiplies matrix to a number (dst = scalar * src)
442 // supports CV_32FC1 only
443 CV_EXPORTS void multiply(double scalar, const oclMat &src, oclMat &dst);
444 //! computes element-wise quotient of the two arrays (c = a / b)
445 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
446 CV_EXPORTS void divide(const oclMat &a, const oclMat &b, oclMat &c, double scale = 1);
447 //! computes element-wise quotient of the two arrays (c = a / b)
448 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
449 CV_EXPORTS void divide(double scale, const oclMat &b, oclMat &c);
451 //! compares elements of two arrays (c = a <cmpop> b)
452 // supports except CV_8SC1,CV_8SC2,CV8SC3,CV_8SC4 types
453 CV_EXPORTS void compare(const oclMat &a, const oclMat &b, oclMat &c, int cmpop);
455 //! transposes the matrix
456 // supports CV_8UC1, 8UC4, 8SC4, 16UC2, 16SC2, 32SC1 and 32FC1.(the same as cuda)
457 CV_EXPORTS void transpose(const oclMat &src, oclMat &dst);
459 //! computes element-wise absolute difference of two arrays (c = abs(a - b))
460 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
461 CV_EXPORTS void absdiff(const oclMat &a, const oclMat &b, oclMat &c);
462 //! computes element-wise absolute difference of array and scalar (c = abs(a - s))
463 // supports all types except CV_8SC1,CV_8SC2,CV8SC3 and CV_8SC4
464 CV_EXPORTS void absdiff(const oclMat &a, const Scalar &s, oclMat &c);
466 //! computes mean value and standard deviation of all or selected array elements
467 // supports except CV_32F,CV_64F
468 CV_EXPORTS void meanStdDev(const oclMat &mtx, Scalar &mean, Scalar &stddev);
470 //! computes norm of array
471 // supports NORM_INF, NORM_L1, NORM_L2
472 // supports only CV_8UC1 type
473 CV_EXPORTS double norm(const oclMat &src1, int normType = NORM_L2);
475 //! computes norm of the difference between two arrays
476 // supports NORM_INF, NORM_L1, NORM_L2
477 // supports only CV_8UC1 type
478 CV_EXPORTS double norm(const oclMat &src1, const oclMat &src2, int normType = NORM_L2);
480 //! reverses the order of the rows, columns or both in a matrix
481 // supports all types
482 CV_EXPORTS void flip(const oclMat &a, oclMat &b, int flipCode);
484 //! computes sum of array elements
485 // disabled until fix crash
487 CV_EXPORTS Scalar sum(const oclMat &m);
488 CV_EXPORTS Scalar absSum(const oclMat &m);
489 CV_EXPORTS Scalar sqrSum(const oclMat &m);
491 //! finds global minimum and maximum array elements and returns their values
492 // support all C1 types
494 CV_EXPORTS void minMax(const oclMat &src, double *minVal, double *maxVal = 0, const oclMat &mask = oclMat());
495 CV_EXPORTS void minMax_buf(const oclMat &src, double *minVal, double *maxVal, const oclMat &mask, oclMat& buf);
497 //! finds global minimum and maximum array elements and returns their values with locations
498 // support all C1 types
500 CV_EXPORTS void minMaxLoc(const oclMat &src, double *minVal, double *maxVal = 0, Point *minLoc = 0, Point *maxLoc = 0,
501 const oclMat &mask = oclMat());
503 //! counts non-zero array elements
505 CV_EXPORTS int countNonZero(const oclMat &src);
507 //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
508 // destination array will have the depth type as lut and the same channels number as source
509 //It supports 8UC1 8UC4 only
510 CV_EXPORTS void LUT(const oclMat &src, const oclMat &lut, oclMat &dst);
512 //! only 8UC1 and 256 bins is supported now
513 CV_EXPORTS void calcHist(const oclMat &mat_src, oclMat &mat_hist);
514 //! only 8UC1 and 256 bins is supported now
515 CV_EXPORTS void equalizeHist(const oclMat &mat_src, oclMat &mat_dst);
517 //! only 8UC1 is supported now
518 class CV_EXPORTS CLAHE
521 virtual void apply(const oclMat &src, oclMat &dst) = 0;
523 virtual void setClipLimit(double clipLimit) = 0;
524 virtual double getClipLimit() const = 0;
526 virtual void setTilesGridSize(Size tileGridSize) = 0;
527 virtual Size getTilesGridSize() const = 0;
529 virtual void collectGarbage() = 0;
533 CV_EXPORTS Ptr<cv::ocl::CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));
536 // supports 8UC1 8UC4
537 CV_EXPORTS void bilateralFilter(const oclMat& src, oclMat& dst, int d, double sigmaColor, double sigmaSpave, int borderType=BORDER_DEFAULT);
538 //! computes exponent of each matrix element (b = e**a)
539 // supports only CV_32FC1 type
540 CV_EXPORTS void exp(const oclMat &a, oclMat &b);
542 //! computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
543 // supports only CV_32FC1 type
544 CV_EXPORTS void log(const oclMat &a, oclMat &b);
546 //! computes magnitude of each (x(i), y(i)) vector
547 // supports only CV_32F CV_64F type
548 CV_EXPORTS void magnitude(const oclMat &x, const oclMat &y, oclMat &magnitude);
549 CV_EXPORTS void magnitudeSqr(const oclMat &x, const oclMat &y, oclMat &magnitude);
551 CV_EXPORTS void magnitudeSqr(const oclMat &x, oclMat &magnitude);
553 //! computes angle (angle(i)) of each (x(i), y(i)) vector
554 // supports only CV_32F CV_64F type
555 CV_EXPORTS void phase(const oclMat &x, const oclMat &y, oclMat &angle, bool angleInDegrees = false);
557 //! the function raises every element of tne input array to p
558 //! support only CV_32F CV_64F type
559 CV_EXPORTS void pow(const oclMat &x, double p, oclMat &y);
561 //! converts Cartesian coordinates to polar
562 // supports only CV_32F CV_64F type
563 CV_EXPORTS void cartToPolar(const oclMat &x, const oclMat &y, oclMat &magnitude, oclMat &angle, bool angleInDegrees = false);
565 //! converts polar coordinates to Cartesian
566 // supports only CV_32F CV_64F type
567 CV_EXPORTS void polarToCart(const oclMat &magnitude, const oclMat &angle, oclMat &x, oclMat &y, bool angleInDegrees = false);
569 //! perfroms per-elements bit-wise inversion
570 // supports all types
571 CV_EXPORTS void bitwise_not(const oclMat &src, oclMat &dst);
572 //! calculates per-element bit-wise disjunction of two arrays
573 // supports all types
574 CV_EXPORTS void bitwise_or(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
575 CV_EXPORTS void bitwise_or(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
576 //! calculates per-element bit-wise conjunction of two arrays
577 // supports all types
578 CV_EXPORTS void bitwise_and(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
579 CV_EXPORTS void bitwise_and(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
580 //! calculates per-element bit-wise "exclusive or" operation
581 // supports all types
582 CV_EXPORTS void bitwise_xor(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
583 CV_EXPORTS void bitwise_xor(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
585 //! Logical operators
586 CV_EXPORTS oclMat operator ~ (const oclMat &);
587 CV_EXPORTS oclMat operator | (const oclMat &, const oclMat &);
588 CV_EXPORTS oclMat operator & (const oclMat &, const oclMat &);
589 CV_EXPORTS oclMat operator ^ (const oclMat &, const oclMat &);
592 //! Mathematics operators
593 CV_EXPORTS oclMatExpr operator + (const oclMat &src1, const oclMat &src2);
594 CV_EXPORTS oclMatExpr operator - (const oclMat &src1, const oclMat &src2);
595 CV_EXPORTS oclMatExpr operator * (const oclMat &src1, const oclMat &src2);
596 CV_EXPORTS oclMatExpr operator / (const oclMat &src1, const oclMat &src2);
598 struct CV_EXPORTS ConvolveBuf
602 Size user_block_size;
605 oclMat image_spect, templ_spect, result_spect;
606 oclMat image_block, templ_block, result_data;
608 void create(Size image_size, Size templ_size);
609 static Size estimateBlockSize(Size result_size, Size templ_size);
612 //! computes convolution of two images, may use discrete Fourier transform
613 //! support only CV_32FC1 type
614 CV_EXPORTS void convolve(const oclMat &image, const oclMat &temp1, oclMat &result, bool ccorr = false);
615 CV_EXPORTS void convolve(const oclMat &image, const oclMat &temp1, oclMat &result, bool ccorr, ConvolveBuf& buf);
617 //! Performs a per-element multiplication of two Fourier spectrums.
618 //! Only full (not packed) CV_32FC2 complex spectrums in the interleaved format are supported for now.
619 //! support only CV_32FC2 type
620 CV_EXPORTS void mulSpectrums(const oclMat &a, const oclMat &b, oclMat &c, int flags, float scale, bool conjB = false);
622 CV_EXPORTS void cvtColor(const oclMat &src, oclMat &dst, int code , int dcn = 0);
624 //////////////////////////////// Filter Engine ////////////////////////////////
627 The Base Class for 1D or Row-wise Filters
629 This is the base class for linear or non-linear filters that process 1D data.
630 In particular, such filters are used for the "horizontal" filtering parts in separable filters.
632 class CV_EXPORTS BaseRowFilter_GPU
635 BaseRowFilter_GPU(int ksize_, int anchor_, int bordertype_) : ksize(ksize_), anchor(anchor_), bordertype(bordertype_) {}
636 virtual ~BaseRowFilter_GPU() {}
637 virtual void operator()(const oclMat &src, oclMat &dst) = 0;
638 int ksize, anchor, bordertype;
642 The Base Class for Column-wise Filters
644 This is the base class for linear or non-linear filters that process columns of 2D arrays.
645 Such filters are used for the "vertical" filtering parts in separable filters.
647 class CV_EXPORTS BaseColumnFilter_GPU
650 BaseColumnFilter_GPU(int ksize_, int anchor_, int bordertype_) : ksize(ksize_), anchor(anchor_), bordertype(bordertype_) {}
651 virtual ~BaseColumnFilter_GPU() {}
652 virtual void operator()(const oclMat &src, oclMat &dst) = 0;
653 int ksize, anchor, bordertype;
657 The Base Class for Non-Separable 2D Filters.
659 This is the base class for linear or non-linear 2D filters.
661 class CV_EXPORTS BaseFilter_GPU
664 BaseFilter_GPU(const Size &ksize_, const Point &anchor_, const int &borderType_)
665 : ksize(ksize_), anchor(anchor_), borderType(borderType_) {}
666 virtual ~BaseFilter_GPU() {}
667 virtual void operator()(const oclMat &src, oclMat &dst) = 0;
674 The Base Class for Filter Engine.
676 The class can be used to apply an arbitrary filtering operation to an image.
677 It contains all the necessary intermediate buffers.
679 class CV_EXPORTS FilterEngine_GPU
682 virtual ~FilterEngine_GPU() {}
684 virtual void apply(const oclMat &src, oclMat &dst, Rect roi = Rect(0, 0, -1, -1)) = 0;
687 //! returns the non-separable filter engine with the specified filter
688 CV_EXPORTS Ptr<FilterEngine_GPU> createFilter2D_GPU(const Ptr<BaseFilter_GPU> filter2D);
690 //! returns the primitive row filter with the specified kernel
691 CV_EXPORTS Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat &rowKernel,
692 int anchor = -1, int bordertype = BORDER_DEFAULT);
694 //! returns the primitive column filter with the specified kernel
695 CV_EXPORTS Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat &columnKernel,
696 int anchor = -1, int bordertype = BORDER_DEFAULT, double delta = 0.0);
698 //! returns the separable linear filter engine
699 CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat &rowKernel,
700 const Mat &columnKernel, const Point &anchor = Point(-1, -1), double delta = 0.0, int bordertype = BORDER_DEFAULT);
702 //! returns the separable filter engine with the specified filters
703 CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU> &rowFilter,
704 const Ptr<BaseColumnFilter_GPU> &columnFilter);
706 //! returns the Gaussian filter engine
707 CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigma1, double sigma2 = 0, int bordertype = BORDER_DEFAULT);
709 //! returns filter engine for the generalized Sobel operator
710 CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU( int srcType, int dstType, int dx, int dy, int ksize, int borderType = BORDER_DEFAULT );
712 //! applies Laplacian operator to the image
713 // supports only ksize = 1 and ksize = 3 8UC1 8UC4 32FC1 32FC4 data type
714 CV_EXPORTS void Laplacian(const oclMat &src, oclMat &dst, int ddepth, int ksize = 1, double scale = 1);
716 //! returns 2D box filter
717 // supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type
718 CV_EXPORTS Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType,
719 const Size &ksize, Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
721 //! returns box filter engine
722 CV_EXPORTS Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size &ksize,
723 const Point &anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
725 //! returns 2D filter with the specified kernel
726 // supports CV_8UC1 and CV_8UC4 types
727 CV_EXPORTS Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat &kernel, const Size &ksize,
728 Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
730 //! returns the non-separable linear filter engine
731 CV_EXPORTS Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat &kernel,
732 const Point &anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
734 //! smooths the image using the normalized box filter
735 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
736 // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101,BORDER_WRAP
737 CV_EXPORTS void boxFilter(const oclMat &src, oclMat &dst, int ddepth, Size ksize,
738 Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
740 //! returns 2D morphological filter
741 //! only MORPH_ERODE and MORPH_DILATE are supported
742 // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
743 // kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
744 CV_EXPORTS Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat &kernel, const Size &ksize,
745 Point anchor = Point(-1, -1));
747 //! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
748 CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat &kernel,
749 const Point &anchor = Point(-1, -1), int iterations = 1);
751 //! a synonym for normalized box filter
752 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
753 // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
754 static inline void blur(const oclMat &src, oclMat &dst, Size ksize, Point anchor = Point(-1, -1),
755 int borderType = BORDER_CONSTANT)
757 boxFilter(src, dst, -1, ksize, anchor, borderType);
760 //! applies non-separable 2D linear filter to the image
761 // Note, at the moment this function only works when anchor point is in the kernel center
762 // and kernel size supported is either 3x3 or 5x5; otherwise the function will fail to output valid result
763 CV_EXPORTS void filter2D(const oclMat &src, oclMat &dst, int ddepth, const Mat &kernel,
764 Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
766 //! applies separable 2D linear filter to the image
767 CV_EXPORTS void sepFilter2D(const oclMat &src, oclMat &dst, int ddepth, const Mat &kernelX, const Mat &kernelY,
768 Point anchor = Point(-1, -1), double delta = 0.0, int bordertype = BORDER_DEFAULT);
770 //! applies generalized Sobel operator to the image
771 // dst.type must equalize src.type
772 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
773 // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
774 CV_EXPORTS void Sobel(const oclMat &src, oclMat &dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0.0, int bordertype = BORDER_DEFAULT);
776 //! applies the vertical or horizontal Scharr operator to the image
777 // dst.type must equalize src.type
778 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
779 // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
780 CV_EXPORTS void Scharr(const oclMat &src, oclMat &dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0.0, int bordertype = BORDER_DEFAULT);
782 //! smooths the image using Gaussian filter.
783 // dst.type must equalize src.type
784 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
785 // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
786 CV_EXPORTS void GaussianBlur(const oclMat &src, oclMat &dst, Size ksize, double sigma1, double sigma2 = 0, int bordertype = BORDER_DEFAULT);
788 //! erodes the image (applies the local minimum operator)
789 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
790 CV_EXPORTS void erode( const oclMat &src, oclMat &dst, const Mat &kernel, Point anchor = Point(-1, -1), int iterations = 1,
792 int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue());
795 //! dilates the image (applies the local maximum operator)
796 // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
797 CV_EXPORTS void dilate( const oclMat &src, oclMat &dst, const Mat &kernel, Point anchor = Point(-1, -1), int iterations = 1,
799 int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue());
802 //! applies an advanced morphological operation to the image
803 CV_EXPORTS void morphologyEx( const oclMat &src, oclMat &dst, int op, const Mat &kernel, Point anchor = Point(-1, -1), int iterations = 1,
805 int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue());
808 ////////////////////////////// Image processing //////////////////////////////
809 //! Does mean shift filtering on GPU.
810 CV_EXPORTS void meanShiftFiltering(const oclMat &src, oclMat &dst, int sp, int sr,
811 TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
813 //! Does mean shift procedure on GPU.
814 CV_EXPORTS void meanShiftProc(const oclMat &src, oclMat &dstr, oclMat &dstsp, int sp, int sr,
815 TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
817 //! Does mean shift segmentation with elimiation of small regions.
818 CV_EXPORTS void meanShiftSegmentation(const oclMat &src, Mat &dst, int sp, int sr, int minsize,
819 TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
821 //! applies fixed threshold to the image.
822 // supports CV_8UC1 and CV_32FC1 data type
823 // supports threshold type: THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV
824 CV_EXPORTS double threshold(const oclMat &src, oclMat &dst, double thresh, double maxVal, int type = THRESH_TRUNC);
826 //! resizes the image
827 // Supports INTER_NEAREST, INTER_LINEAR
828 // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
829 CV_EXPORTS void resize(const oclMat &src, oclMat &dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR);
831 //! Applies a generic geometrical transformation to an image.
833 // Supports INTER_NEAREST, INTER_LINEAR.
835 // Map1 supports CV_16SC2, CV_32FC2 types.
837 // Src supports CV_8UC1, CV_8UC2, CV_8UC4.
839 CV_EXPORTS void remap(const oclMat &src, oclMat &dst, oclMat &map1, oclMat &map2, int interpolation, int bordertype, const Scalar &value = Scalar());
841 //! copies 2D array to a larger destination array and pads borders with user-specifiable constant
842 // supports CV_8UC1, CV_8UC4, CV_32SC1 types
843 CV_EXPORTS void copyMakeBorder(const oclMat &src, oclMat &dst, int top, int bottom, int left, int right, int boardtype, const Scalar &value = Scalar());
845 //! Smoothes image using median filter
846 // The source 1- or 4-channel image. When m is 3 or 5, the image depth should be CV 8U or CV 32F.
847 CV_EXPORTS void medianFilter(const oclMat &src, oclMat &dst, int m);
849 //! warps the image using affine transformation
850 // Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
851 // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
852 CV_EXPORTS void warpAffine(const oclMat &src, oclMat &dst, const Mat &M, Size dsize, int flags = INTER_LINEAR);
854 //! warps the image using perspective transformation
855 // Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
856 // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
857 CV_EXPORTS void warpPerspective(const oclMat &src, oclMat &dst, const Mat &M, Size dsize, int flags = INTER_LINEAR);
859 //! computes the integral image and integral for the squared image
860 // sum will have CV_32S type, sqsum - CV32F type
861 // supports only CV_8UC1 source type
862 CV_EXPORTS void integral(const oclMat &src, oclMat &sum, oclMat &sqsum);
863 CV_EXPORTS void integral(const oclMat &src, oclMat &sum);
864 CV_EXPORTS void cornerHarris(const oclMat &src, oclMat &dst, int blockSize, int ksize, double k, int bordertype = cv::BORDER_DEFAULT);
865 CV_EXPORTS void cornerHarris_dxdy(const oclMat &src, oclMat &dst, oclMat &Dx, oclMat &Dy,
866 int blockSize, int ksize, double k, int bordertype = cv::BORDER_DEFAULT);
867 CV_EXPORTS void cornerMinEigenVal(const oclMat &src, oclMat &dst, int blockSize, int ksize, int bordertype = cv::BORDER_DEFAULT);
868 CV_EXPORTS void cornerMinEigenVal_dxdy(const oclMat &src, oclMat &dst, oclMat &Dx, oclMat &Dy,
869 int blockSize, int ksize, int bordertype = cv::BORDER_DEFAULT);
871 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
872 ///////////////////////////////////////////CascadeClassifier//////////////////////////////////////////////////////////////////
873 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
876 class CV_EXPORTS OclCascadeClassifier : public cv::CascadeClassifier
879 OclCascadeClassifier() {};
880 ~OclCascadeClassifier() {};
882 CvSeq* oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage, double scaleFactor,
883 int minNeighbors, int flags, CvSize minSize = cvSize(0, 0), CvSize maxSize = cvSize(0, 0));
888 class CV_EXPORTS OclCascadeClassifierBuf : public cv::CascadeClassifier
891 OclCascadeClassifierBuf() :
892 m_flags(0), initialized(false), m_scaleFactor(0), buffers(NULL) {}
894 ~OclCascadeClassifierBuf() { release(); }
896 void detectMultiScale(oclMat &image, CV_OUT std::vector<cv::Rect>& faces,
897 double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0,
898 Size minSize = Size(), Size maxSize = Size());
902 void Init(const int rows, const int cols, double scaleFactor, int flags,
903 const int outputsz, const size_t localThreads[],
904 Size minSize, Size maxSize);
905 void CreateBaseBufs(const int datasize, const int totalclassifier, const int flags, const int outputsz);
906 void CreateFactorRelatedBufs(const int rows, const int cols, const int flags,
907 const double scaleFactor, const size_t localThreads[],
908 Size minSize, Size maxSize);
909 void GenResult(CV_OUT std::vector<cv::Rect>& faces, const std::vector<cv::Rect> &rectList, const std::vector<int> &rweights);
916 bool findBiggestObject;
918 double m_scaleFactor;
921 std::vector<Size> sizev;
922 std::vector<float> scalev;
923 oclMat gimg1, gsum, gsqsum;
928 /////////////////////////////// Pyramid /////////////////////////////////////
929 CV_EXPORTS void pyrDown(const oclMat &src, oclMat &dst);
931 //! upsamples the source image and then smoothes it
932 CV_EXPORTS void pyrUp(const oclMat &src, oclMat &dst);
934 //! performs linear blending of two images
935 //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
936 // supports only CV_8UC1 source type
937 CV_EXPORTS void blendLinear(const oclMat &img1, const oclMat &img2, const oclMat &weights1, const oclMat &weights2, oclMat &result);
939 //! computes vertical sum, supports only CV_32FC1 images
940 CV_EXPORTS void columnSum(const oclMat &src, oclMat &sum);
942 ///////////////////////////////////////// match_template /////////////////////////////////////////////////////////////
943 struct CV_EXPORTS MatchTemplateBuf
945 Size user_block_size;
946 oclMat imagef, templf;
947 std::vector<oclMat> images;
948 std::vector<oclMat> image_sums;
949 std::vector<oclMat> image_sqsums;
952 //! computes the proximity map for the raster template and the image where the template is searched for
953 // Supports TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED for type 8UC1 and 8UC4
954 // Supports TM_SQDIFF, TM_CCORR for type 32FC1 and 32FC4
955 CV_EXPORTS void matchTemplate(const oclMat &image, const oclMat &templ, oclMat &result, int method);
957 //! computes the proximity map for the raster template and the image where the template is searched for
958 // Supports TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED for type 8UC1 and 8UC4
959 // Supports TM_SQDIFF, TM_CCORR for type 32FC1 and 32FC4
960 CV_EXPORTS void matchTemplate(const oclMat &image, const oclMat &templ, oclMat &result, int method, MatchTemplateBuf &buf);
964 ///////////////////////////////////////////// Canny /////////////////////////////////////////////
965 struct CV_EXPORTS CannyBuf;
967 //! compute edges of the input image using Canny operator
968 // Support CV_8UC1 only
969 CV_EXPORTS void Canny(const oclMat &image, oclMat &edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
970 CV_EXPORTS void Canny(const oclMat &image, CannyBuf &buf, oclMat &edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
971 CV_EXPORTS void Canny(const oclMat &dx, const oclMat &dy, oclMat &edges, double low_thresh, double high_thresh, bool L2gradient = false);
972 CV_EXPORTS void Canny(const oclMat &dx, const oclMat &dy, CannyBuf &buf, oclMat &edges, double low_thresh, double high_thresh, bool L2gradient = false);
974 struct CV_EXPORTS CannyBuf
976 CannyBuf() : counter(NULL) {}
981 explicit CannyBuf(const Size &image_size, int apperture_size = 3) : counter(NULL)
983 create(image_size, apperture_size);
985 CannyBuf(const oclMat &dx_, const oclMat &dy_);
986 void create(const Size &image_size, int apperture_size = 3);
990 oclMat dx_buf, dy_buf;
991 oclMat magBuf, mapBuf;
992 oclMat trackBuf1, trackBuf2;
994 Ptr<FilterEngine_GPU> filterDX, filterDY;
997 ///////////////////////////////////////// Hough Transform /////////////////////////////////////////
999 struct HoughCirclesBuf
1008 CV_EXPORTS void HoughCircles(const oclMat& src, oclMat& circles, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles = 4096);
1009 CV_EXPORTS void HoughCircles(const oclMat& src, oclMat& circles, HoughCirclesBuf& buf, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles = 4096);
1010 CV_EXPORTS void HoughCirclesDownload(const oclMat& d_circles, OutputArray h_circles);
1013 ///////////////////////////////////////// clAmdFft related /////////////////////////////////////////
1014 //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
1015 //! Param dft_size is the size of DFT transform.
1017 //! For complex-to-real transform it is assumed that the source matrix is packed in CLFFT's format.
1018 // support src type of CV32FC1, CV32FC2
1019 // support flags: DFT_INVERSE, DFT_REAL_OUTPUT, DFT_COMPLEX_OUTPUT, DFT_ROWS
1020 // dft_size is the size of original input, which is used for transformation from complex to real.
1021 // dft_size must be powers of 2, 3 and 5
1022 // real to complex dft requires at least v1.8 clAmdFft
1023 // real to complex dft output is not the same with cpu version
1024 // real to complex and complex to real does not support DFT_ROWS
1025 CV_EXPORTS void dft(const oclMat &src, oclMat &dst, Size dft_size = Size(0, 0), int flags = 0);
1027 //! implements generalized matrix product algorithm GEMM from BLAS
1028 // The functionality requires clAmdBlas library
1029 // only support type CV_32FC1
1030 // flag GEMM_3_T is not supported
1031 CV_EXPORTS void gemm(const oclMat &src1, const oclMat &src2, double alpha,
1032 const oclMat &src3, double beta, oclMat &dst, int flags = 0);
1034 //////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
1036 struct CV_EXPORTS HOGDescriptor
1040 enum { DEFAULT_WIN_SIGMA = -1 };
1042 enum { DEFAULT_NLEVELS = 64 };
1044 enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };
1048 HOGDescriptor(Size win_size = Size(64, 128), Size block_size = Size(16, 16),
1050 Size block_stride = Size(8, 8), Size cell_size = Size(8, 8),
1052 int nbins = 9, double win_sigma = DEFAULT_WIN_SIGMA,
1054 double threshold_L2hys = 0.2, bool gamma_correction = true,
1056 int nlevels = DEFAULT_NLEVELS);
1060 size_t getDescriptorSize() const;
1062 size_t getBlockHistogramSize() const;
1066 void setSVMDetector(const std::vector<float> &detector);
1070 static std::vector<float> getDefaultPeopleDetector();
1072 static std::vector<float> getPeopleDetector48x96();
1074 static std::vector<float> getPeopleDetector64x128();
1078 void detect(const oclMat &img, std::vector<Point> &found_locations,
1080 double hit_threshold = 0, Size win_stride = Size(),
1082 Size padding = Size());
1086 void detectMultiScale(const oclMat &img, std::vector<Rect> &found_locations,
1088 double hit_threshold = 0, Size win_stride = Size(),
1090 Size padding = Size(), double scale0 = 1.05,
1092 int group_threshold = 2);
1096 void getDescriptors(const oclMat &img, Size win_stride,
1098 oclMat &descriptors,
1100 int descr_format = DESCR_FORMAT_COL_BY_COL);
1116 double threshold_L2hys;
1118 bool gamma_correction;
1126 // initialize buffers; only need to do once in case of multiscale detection
1128 void init_buffer(const oclMat &img, Size win_stride);
1132 void computeBlockHistograms(const oclMat &img);
1134 void computeGradient(const oclMat &img, oclMat &grad, oclMat &qangle);
1138 double getWinSigma() const;
1140 bool checkDetectorSize() const;
1144 static int numPartsWithin(int size, int part_size, int stride);
1146 static Size numPartsWithin(Size size, Size part_size, Size stride);
1150 // Coefficients of the separating plane
1158 // Results of the last classification step
1166 // Results of the last histogram evaluation step
1172 // Gradients conputation results
1174 oclMat grad, qangle;
1184 // effect size of input image (might be different from original size after scaling)
1191 ////////////////////////feature2d_ocl/////////////////
1192 /****************************************************************************************\
1194 \****************************************************************************************/
1195 template<typename T>
1196 struct CV_EXPORTS Accumulator
1200 template<> struct Accumulator<unsigned char>
1204 template<> struct Accumulator<unsigned short>
1208 template<> struct Accumulator<char>
1212 template<> struct Accumulator<short>
1218 * Manhattan distance (city block distance) functor
1221 struct CV_EXPORTS L1
1223 enum { normType = NORM_L1 };
1224 typedef T ValueType;
1225 typedef typename Accumulator<T>::Type ResultType;
1227 ResultType operator()( const T *a, const T *b, int size ) const
1229 return normL1<ValueType, ResultType>(a, b, size);
1234 * Euclidean distance functor
1237 struct CV_EXPORTS L2
1239 enum { normType = NORM_L2 };
1240 typedef T ValueType;
1241 typedef typename Accumulator<T>::Type ResultType;
1243 ResultType operator()( const T *a, const T *b, int size ) const
1245 return (ResultType)std::sqrt((double)normL2Sqr<ValueType, ResultType>(a, b, size));
1250 * Hamming distance functor - counts the bit differences between two strings - useful for the Brief descriptor
1251 * bit count of A exclusive XOR'ed with B
1253 struct CV_EXPORTS Hamming
1255 enum { normType = NORM_HAMMING };
1256 typedef unsigned char ValueType;
1257 typedef int ResultType;
1259 /** this will count the bits in a ^ b
1261 ResultType operator()( const unsigned char *a, const unsigned char *b, int size ) const
1263 return normHamming(a, b, size);
1267 ////////////////////////////////// BruteForceMatcher //////////////////////////////////
1269 class CV_EXPORTS BruteForceMatcher_OCL_base
1272 enum DistType {L1Dist = 0, L2Dist, HammingDist};
1273 explicit BruteForceMatcher_OCL_base(DistType distType = L2Dist);
1275 // Add descriptors to train descriptor collection
1276 void add(const std::vector<oclMat> &descCollection);
1278 // Get train descriptors collection
1279 const std::vector<oclMat> &getTrainDescriptors() const;
1281 // Clear train descriptors collection
1284 // Return true if there are not train descriptors in collection
1287 // Return true if the matcher supports mask in match methods
1288 bool isMaskSupported() const;
1290 // Find one best match for each query descriptor
1291 void matchSingle(const oclMat &query, const oclMat &train,
1292 oclMat &trainIdx, oclMat &distance,
1293 const oclMat &mask = oclMat());
1295 // Download trainIdx and distance and convert it to CPU vector with DMatch
1296 static void matchDownload(const oclMat &trainIdx, const oclMat &distance, std::vector<DMatch> &matches);
1297 // Convert trainIdx and distance to vector with DMatch
1298 static void matchConvert(const Mat &trainIdx, const Mat &distance, std::vector<DMatch> &matches);
1300 // Find one best match for each query descriptor
1301 void match(const oclMat &query, const oclMat &train, std::vector<DMatch> &matches, const oclMat &mask = oclMat());
1303 // Make gpu collection of trains and masks in suitable format for matchCollection function
1304 void makeGpuCollection(oclMat &trainCollection, oclMat &maskCollection, const std::vector<oclMat> &masks = std::vector<oclMat>());
1306 // Find one best match from train collection for each query descriptor
1307 void matchCollection(const oclMat &query, const oclMat &trainCollection,
1308 oclMat &trainIdx, oclMat &imgIdx, oclMat &distance,
1309 const oclMat &masks = oclMat());
1311 // Download trainIdx, imgIdx and distance and convert it to vector with DMatch
1312 static void matchDownload(const oclMat &trainIdx, const oclMat &imgIdx, const oclMat &distance, std::vector<DMatch> &matches);
1313 // Convert trainIdx, imgIdx and distance to vector with DMatch
1314 static void matchConvert(const Mat &trainIdx, const Mat &imgIdx, const Mat &distance, std::vector<DMatch> &matches);
1316 // Find one best match from train collection for each query descriptor.
1317 void match(const oclMat &query, std::vector<DMatch> &matches, const std::vector<oclMat> &masks = std::vector<oclMat>());
1319 // Find k best matches for each query descriptor (in increasing order of distances)
1320 void knnMatchSingle(const oclMat &query, const oclMat &train,
1321 oclMat &trainIdx, oclMat &distance, oclMat &allDist, int k,
1322 const oclMat &mask = oclMat());
1324 // Download trainIdx and distance and convert it to vector with DMatch
1325 // compactResult is used when mask is not empty. If compactResult is false matches
1326 // vector will have the same size as queryDescriptors rows. If compactResult is true
1327 // matches vector will not contain matches for fully masked out query descriptors.
1328 static void knnMatchDownload(const oclMat &trainIdx, const oclMat &distance,
1329 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1330 // Convert trainIdx and distance to vector with DMatch
1331 static void knnMatchConvert(const Mat &trainIdx, const Mat &distance,
1332 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1334 // Find k best matches for each query descriptor (in increasing order of distances).
1335 // compactResult is used when mask is not empty. If compactResult is false matches
1336 // vector will have the same size as queryDescriptors rows. If compactResult is true
1337 // matches vector will not contain matches for fully masked out query descriptors.
1338 void knnMatch(const oclMat &query, const oclMat &train,
1339 std::vector< std::vector<DMatch> > &matches, int k, const oclMat &mask = oclMat(),
1340 bool compactResult = false);
1342 // Find k best matches from train collection for each query descriptor (in increasing order of distances)
1343 void knnMatch2Collection(const oclMat &query, const oclMat &trainCollection,
1344 oclMat &trainIdx, oclMat &imgIdx, oclMat &distance,
1345 const oclMat &maskCollection = oclMat());
1347 // Download trainIdx and distance and convert it to vector with DMatch
1348 // compactResult is used when mask is not empty. If compactResult is false matches
1349 // vector will have the same size as queryDescriptors rows. If compactResult is true
1350 // matches vector will not contain matches for fully masked out query descriptors.
1351 static void knnMatch2Download(const oclMat &trainIdx, const oclMat &imgIdx, const oclMat &distance,
1352 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1353 // Convert trainIdx and distance to vector with DMatch
1354 static void knnMatch2Convert(const Mat &trainIdx, const Mat &imgIdx, const Mat &distance,
1355 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1357 // Find k best matches for each query descriptor (in increasing order of distances).
1358 // compactResult is used when mask is not empty. If compactResult is false matches
1359 // vector will have the same size as queryDescriptors rows. If compactResult is true
1360 // matches vector will not contain matches for fully masked out query descriptors.
1361 void knnMatch(const oclMat &query, std::vector< std::vector<DMatch> > &matches, int k,
1362 const std::vector<oclMat> &masks = std::vector<oclMat>(), bool compactResult = false);
1364 // Find best matches for each query descriptor which have distance less than maxDistance.
1365 // nMatches.at<int>(0, queryIdx) will contain matches count for queryIdx.
1366 // carefully nMatches can be greater than trainIdx.cols - it means that matcher didn't find all matches,
1367 // because it didn't have enough memory.
1368 // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nTrain / 100), 10),
1369 // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
1370 // Matches doesn't sorted.
1371 void radiusMatchSingle(const oclMat &query, const oclMat &train,
1372 oclMat &trainIdx, oclMat &distance, oclMat &nMatches, float maxDistance,
1373 const oclMat &mask = oclMat());
1375 // Download trainIdx, nMatches and distance and convert it to vector with DMatch.
1376 // matches will be sorted in increasing order of distances.
1377 // compactResult is used when mask is not empty. If compactResult is false matches
1378 // vector will have the same size as queryDescriptors rows. If compactResult is true
1379 // matches vector will not contain matches for fully masked out query descriptors.
1380 static void radiusMatchDownload(const oclMat &trainIdx, const oclMat &distance, const oclMat &nMatches,
1381 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1382 // Convert trainIdx, nMatches and distance to vector with DMatch.
1383 static void radiusMatchConvert(const Mat &trainIdx, const Mat &distance, const Mat &nMatches,
1384 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1386 // Find best matches for each query descriptor which have distance less than maxDistance
1387 // in increasing order of distances).
1388 void radiusMatch(const oclMat &query, const oclMat &train,
1389 std::vector< std::vector<DMatch> > &matches, float maxDistance,
1390 const oclMat &mask = oclMat(), bool compactResult = false);
1392 // Find best matches for each query descriptor which have distance less than maxDistance.
1393 // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nQuery / 100), 10),
1394 // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
1395 // Matches doesn't sorted.
1396 void radiusMatchCollection(const oclMat &query, oclMat &trainIdx, oclMat &imgIdx, oclMat &distance, oclMat &nMatches, float maxDistance,
1397 const std::vector<oclMat> &masks = std::vector<oclMat>());
1399 // Download trainIdx, imgIdx, nMatches and distance and convert it to vector with DMatch.
1400 // matches will be sorted in increasing order of distances.
1401 // compactResult is used when mask is not empty. If compactResult is false matches
1402 // vector will have the same size as queryDescriptors rows. If compactResult is true
1403 // matches vector will not contain matches for fully masked out query descriptors.
1404 static void radiusMatchDownload(const oclMat &trainIdx, const oclMat &imgIdx, const oclMat &distance, const oclMat &nMatches,
1405 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1406 // Convert trainIdx, nMatches and distance to vector with DMatch.
1407 static void radiusMatchConvert(const Mat &trainIdx, const Mat &imgIdx, const Mat &distance, const Mat &nMatches,
1408 std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1410 // Find best matches from train collection for each query descriptor which have distance less than
1411 // maxDistance (in increasing order of distances).
1412 void radiusMatch(const oclMat &query, std::vector< std::vector<DMatch> > &matches, float maxDistance,
1413 const std::vector<oclMat> &masks = std::vector<oclMat>(), bool compactResult = false);
1418 std::vector<oclMat> trainDescCollection;
1421 template <class Distance>
1422 class CV_EXPORTS BruteForceMatcher_OCL;
1424 template <typename T>
1425 class CV_EXPORTS BruteForceMatcher_OCL< L1<T> > : public BruteForceMatcher_OCL_base
1428 explicit BruteForceMatcher_OCL() : BruteForceMatcher_OCL_base(L1Dist) {}
1429 explicit BruteForceMatcher_OCL(L1<T> /*d*/) : BruteForceMatcher_OCL_base(L1Dist) {}
1431 template <typename T>
1432 class CV_EXPORTS BruteForceMatcher_OCL< L2<T> > : public BruteForceMatcher_OCL_base
1435 explicit BruteForceMatcher_OCL() : BruteForceMatcher_OCL_base(L2Dist) {}
1436 explicit BruteForceMatcher_OCL(L2<T> /*d*/) : BruteForceMatcher_OCL_base(L2Dist) {}
1438 template <> class CV_EXPORTS BruteForceMatcher_OCL< Hamming > : public BruteForceMatcher_OCL_base
1441 explicit BruteForceMatcher_OCL() : BruteForceMatcher_OCL_base(HammingDist) {}
1442 explicit BruteForceMatcher_OCL(Hamming /*d*/) : BruteForceMatcher_OCL_base(HammingDist) {}
1445 class CV_EXPORTS BFMatcher_OCL : public BruteForceMatcher_OCL_base
1448 explicit BFMatcher_OCL(int norm = NORM_L2) : BruteForceMatcher_OCL_base(norm == NORM_L1 ? L1Dist : norm == NORM_L2 ? L2Dist : HammingDist) {}
1451 class CV_EXPORTS GoodFeaturesToTrackDetector_OCL
1454 explicit GoodFeaturesToTrackDetector_OCL(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0,
1455 int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04);
1457 //! return 1 rows matrix with CV_32FC2 type
1458 void operator ()(const oclMat& image, oclMat& corners, const oclMat& mask = oclMat());
1459 //! download points of type Point2f to a vector. the vector's content will be erased
1460 void downloadPoints(const oclMat &points, std::vector<Point2f> &points_v);
1463 double qualityLevel;
1467 bool useHarrisDetector;
1469 void releaseMemory()
1474 minMaxbuf_.release();
1475 tmpCorners_.release();
1485 inline GoodFeaturesToTrackDetector_OCL::GoodFeaturesToTrackDetector_OCL(int maxCorners_, double qualityLevel_, double minDistance_,
1486 int blockSize_, bool useHarrisDetector_, double harrisK_)
1488 maxCorners = maxCorners_;
1489 qualityLevel = qualityLevel_;
1490 minDistance = minDistance_;
1491 blockSize = blockSize_;
1492 useHarrisDetector = useHarrisDetector_;
1496 /////////////////////////////// PyrLKOpticalFlow /////////////////////////////////////
1498 class CV_EXPORTS PyrLKOpticalFlow
1503 winSize = Size(21, 21);
1507 useInitialFlow = false;
1508 minEigThreshold = 1e-4f;
1509 getMinEigenVals = false;
1510 isDeviceArch11_ = false;
1513 void sparse(const oclMat &prevImg, const oclMat &nextImg, const oclMat &prevPts, oclMat &nextPts,
1514 oclMat &status, oclMat *err = 0);
1516 void dense(const oclMat &prevImg, const oclMat &nextImg, oclMat &u, oclMat &v, oclMat *err = 0);
1522 bool useInitialFlow;
1523 float minEigThreshold;
1524 bool getMinEigenVals;
1526 void releaseMemory()
1528 dx_calcBuf_.release();
1529 dy_calcBuf_.release();
1539 void calcSharrDeriv(const oclMat &src, oclMat &dx, oclMat &dy);
1541 void buildImagePyramid(const oclMat &img0, std::vector<oclMat> &pyr, bool withBorder);
1546 std::vector<oclMat> prevPyr_;
1547 std::vector<oclMat> nextPyr_;
1555 bool isDeviceArch11_;
1557 //////////////// build warping maps ////////////////////
1558 //! builds plane warping maps
1559 CV_EXPORTS void buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, const Mat &T, float scale, oclMat &map_x, oclMat &map_y);
1560 //! builds cylindrical warping maps
1561 CV_EXPORTS void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale, oclMat &map_x, oclMat &map_y);
1562 //! builds spherical warping maps
1563 CV_EXPORTS void buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale, oclMat &map_x, oclMat &map_y);
1564 //! builds Affine warping maps
1565 CV_EXPORTS void buildWarpAffineMaps(const Mat &M, bool inverse, Size dsize, oclMat &xmap, oclMat &ymap);
1567 //! builds Perspective warping maps
1568 CV_EXPORTS void buildWarpPerspectiveMaps(const Mat &M, bool inverse, Size dsize, oclMat &xmap, oclMat &ymap);
1570 ///////////////////////////////////// interpolate frames //////////////////////////////////////////////
1571 //! Interpolate frames (images) using provided optical flow (displacement field).
1572 //! frame0 - frame 0 (32-bit floating point images, single channel)
1573 //! frame1 - frame 1 (the same type and size)
1574 //! fu - forward horizontal displacement
1575 //! fv - forward vertical displacement
1576 //! bu - backward horizontal displacement
1577 //! bv - backward vertical displacement
1578 //! pos - new frame position
1579 //! newFrame - new frame
1580 //! buf - temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 oclMat;
1581 //! occlusion masks 0, occlusion masks 1,
1582 //! interpolated forward flow 0, interpolated forward flow 1,
1583 //! interpolated backward flow 0, interpolated backward flow 1
1585 CV_EXPORTS void interpolateFrames(const oclMat &frame0, const oclMat &frame1,
1586 const oclMat &fu, const oclMat &fv,
1587 const oclMat &bu, const oclMat &bv,
1588 float pos, oclMat &newFrame, oclMat &buf);
1590 //! computes moments of the rasterized shape or a vector of points
1591 CV_EXPORTS Moments ocl_moments(InputArray _array, bool binaryImage);
1593 class CV_EXPORTS StereoBM_OCL
1596 enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 };
1598 enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 };
1600 //! the default constructor
1602 //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8.
1603 StereoBM_OCL(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ);
1605 //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
1606 //! Output disparity has CV_8U type.
1607 void operator() ( const oclMat &left, const oclMat &right, oclMat &disparity);
1609 //! Some heuristics that tries to estmate
1610 // if current GPU will be faster then CPU in this algorithm.
1611 // It queries current active device.
1612 static bool checkIfGpuCallReasonable();
1618 // If avergeTexThreshold == 0 => post procesing is disabled
1619 // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image
1620 // SumOfHorizontalGradiensInWindow(x, y, winSize) < (winSize * winSize) * avergeTexThreshold
1621 // i.e. input left image is low textured.
1622 float avergeTexThreshold;
1624 oclMat minSSD, leBuf, riBuf;
1627 class CV_EXPORTS StereoBeliefPropagation
1630 enum { DEFAULT_NDISP = 64 };
1631 enum { DEFAULT_ITERS = 5 };
1632 enum { DEFAULT_LEVELS = 5 };
1633 static void estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels);
1634 explicit StereoBeliefPropagation(int ndisp = DEFAULT_NDISP,
1635 int iters = DEFAULT_ITERS,
1636 int levels = DEFAULT_LEVELS,
1637 int msg_type = CV_16S);
1638 StereoBeliefPropagation(int ndisp, int iters, int levels,
1639 float max_data_term, float data_weight,
1640 float max_disc_term, float disc_single_jump,
1641 int msg_type = CV_32F);
1642 void operator()(const oclMat &left, const oclMat &right, oclMat &disparity);
1643 void operator()(const oclMat &data, oclMat &disparity);
1647 float max_data_term;
1649 float max_disc_term;
1650 float disc_single_jump;
1653 oclMat u, d, l, r, u2, d2, l2, r2;
1654 std::vector<oclMat> datas;
1658 class CV_EXPORTS StereoConstantSpaceBP
1661 enum { DEFAULT_NDISP = 128 };
1662 enum { DEFAULT_ITERS = 8 };
1663 enum { DEFAULT_LEVELS = 4 };
1664 enum { DEFAULT_NR_PLANE = 4 };
1665 static void estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels, int &nr_plane);
1666 explicit StereoConstantSpaceBP(
1667 int ndisp = DEFAULT_NDISP,
1668 int iters = DEFAULT_ITERS,
1669 int levels = DEFAULT_LEVELS,
1670 int nr_plane = DEFAULT_NR_PLANE,
1671 int msg_type = CV_32F);
1672 StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane,
1673 float max_data_term, float data_weight, float max_disc_term, float disc_single_jump,
1674 int min_disp_th = 0,
1675 int msg_type = CV_32F);
1676 void operator()(const oclMat &left, const oclMat &right, oclMat &disparity);
1681 float max_data_term;
1683 float max_disc_term;
1684 float disc_single_jump;
1687 bool use_local_init_data_cost;
1689 oclMat u[2], d[2], l[2], r[2];
1690 oclMat disp_selected_pyr[2];
1692 oclMat data_cost_selected;
1697 // Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
1700 // [1] C. Zach, T. Pock and H. Bischof, "A Duality Based Approach for Realtime TV-L1 Optical Flow".
1701 // [2] Javier Sanchez, Enric Meinhardt-Llopis and Gabriele Facciolo. "TV-L1 Optical Flow Estimation".
1702 class CV_EXPORTS OpticalFlowDual_TVL1_OCL
1705 OpticalFlowDual_TVL1_OCL();
1707 void operator ()(const oclMat& I0, const oclMat& I1, oclMat& flowx, oclMat& flowy);
1709 void collectGarbage();
1712 * Time step of the numerical scheme.
1717 * Weight parameter for the data term, attachment parameter.
1718 * This is the most relevant parameter, which determines the smoothness of the output.
1719 * The smaller this parameter is, the smoother the solutions we obtain.
1720 * It depends on the range of motions of the images, so its value should be adapted to each image sequence.
1725 * Weight parameter for (u - v)^2, tightness parameter.
1726 * It serves as a link between the attachment and the regularization terms.
1727 * In theory, it should have a small value in order to maintain both parts in correspondence.
1728 * The method is stable for a large range of values of this parameter.
1733 * Number of scales used to create the pyramid of images.
1738 * Number of warpings per scale.
1739 * Represents the number of times that I1(x+u0) and grad( I1(x+u0) ) are computed per scale.
1740 * This is a parameter that assures the stability of the method.
1741 * It also affects the running time, so it is a compromise between speed and accuracy.
1746 * Stopping criterion threshold used in the numerical scheme, which is a trade-off between precision and running time.
1747 * A small value will yield more accurate solutions at the expense of a slower convergence.
1752 * Stopping criterion iterations number used in the numerical scheme.
1756 bool useInitialFlow;
1759 void procOneScale(const oclMat& I0, const oclMat& I1, oclMat& u1, oclMat& u2);
1761 std::vector<oclMat> I0s;
1762 std::vector<oclMat> I1s;
1763 std::vector<oclMat> u1s;
1764 std::vector<oclMat> u2s;
1786 #if defined _MSC_VER && _MSC_VER >= 1200
1787 # pragma warning( push)
1788 # pragma warning( disable: 4267)
1790 #include "opencv2/ocl/matrix_operations.hpp"
1791 #if defined _MSC_VER && _MSC_VER >= 1200
1792 # pragma warning( pop)
1795 #endif /* __OPENCV_OCL_HPP__ */