modules/ocl/include/opencv2/ocl/ocl.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) 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.
  17 //
  18 // Redistribution and use in source and binary forms, with or without modification,
  19 // are permitted provided that the following conditions are met:
  20 //
  21 //   * Redistribution's of source code must retain the above copyright notice,
  22 //     this list of conditions and the following disclaimer.
  23 //
  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.
  27 //
  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.
  30 //
  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.
  41 //
  42 //M*/
  43
  44 #ifndef __OPENCV_OCL_HPP__
  45 #define __OPENCV_OCL_HPP__
  46
  47 #include <memory>
  48 #include <vector>
  49
  50 #include "opencv2/core/core.hpp"
  51 #include "opencv2/imgproc/imgproc.hpp"
  52 #include "opencv2/objdetect/objdetect.hpp"
  53 #include "opencv2/features2d/features2d.hpp"
  54 #include "opencv2/ml/ml.hpp"
  55
  56 namespace cv
  57 {
  58     namespace ocl
  59     {
  60         enum DeviceType
  61         {
  62             CVCL_DEVICE_TYPE_DEFAULT     = (1 << 0),
  63             CVCL_DEVICE_TYPE_CPU         = (1 << 1),
  64             CVCL_DEVICE_TYPE_GPU         = (1 << 2),
  65             CVCL_DEVICE_TYPE_ACCELERATOR = (1 << 3),
  66             //CVCL_DEVICE_TYPE_CUSTOM      = (1 << 4)
  67             CVCL_DEVICE_TYPE_ALL         = 0xFFFFFFFF
  68         };
  69
  70         enum DevMemRW
  71         {
  72             DEVICE_MEM_R_W = 0,
  73             DEVICE_MEM_R_ONLY,
  74             DEVICE_MEM_W_ONLY
  75         };
  76
  77         enum DevMemType
  78         {
  79             DEVICE_MEM_DEFAULT = 0,
  80             DEVICE_MEM_AHP,         //alloc host pointer
  81             DEVICE_MEM_UHP,         //use host pointer
  82             DEVICE_MEM_CHP,         //copy host pointer
  83             DEVICE_MEM_PM           //persistent memory
  84         };
  85
  86         // these classes contain OpenCL runtime information
  87
  88         struct PlatformInfo;
  89
  90         struct DeviceInfo
  91         {
  92             int _id; // reserved, don't use it
  93
  94             DeviceType deviceType;
  95             std::string deviceProfile;
  96             std::string deviceVersion;
  97             std::string deviceName;
  98             std::string deviceVendor;
  99             int deviceVendorId;
 100             std::string deviceDriverVersion;
 101             std::string deviceExtensions;
 102
 103             size_t maxWorkGroupSize;
 104             std::vector<size_t> maxWorkItemSizes;
 105             int maxComputeUnits;
 106             size_t localMemorySize;
 107             size_t maxMemAllocSize;
 108
 109             int deviceVersionMajor;
 110             int deviceVersionMinor;
 111
 112             bool haveDoubleSupport;
 113             bool isUnifiedMemory; // 1 means integrated GPU, otherwise this value is 0
 114
 115             std::string compilationExtraOptions;
 116
 117             const PlatformInfo* platform;
 118
 119             DeviceInfo();
 120         };
 121
 122         struct PlatformInfo
 123         {
 124             int _id; // reserved, don't use it
 125
 126             std::string platformProfile;
 127             std::string platformVersion;
 128             std::string platformName;
 129             std::string platformVendor;
 130             std::string platformExtensons;
 131
 132             int platformVersionMajor;
 133             int platformVersionMinor;
 134
 135             std::vector<const DeviceInfo*> devices;
 136
 137             PlatformInfo();
 138         };
 139
 140         //////////////////////////////// Initialization & Info ////////////////////////
 141         typedef std::vector<const PlatformInfo*> PlatformsInfo;
 142
 143         CV_EXPORTS int getOpenCLPlatforms(PlatformsInfo& platforms);
 144
 145         typedef std::vector<const DeviceInfo*> DevicesInfo;
 146
 147         CV_EXPORTS int getOpenCLDevices(DevicesInfo& devices, int deviceType = CVCL_DEVICE_TYPE_GPU,
 148                 const PlatformInfo* platform = NULL);
 149
 150         // set device you want to use
 151         CV_EXPORTS void setDevice(const DeviceInfo* info);
 152
 153         //////////////////////////////// Error handling ////////////////////////
 154         CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func);
 155
 156         enum FEATURE_TYPE
 157         {
 158             FEATURE_CL_DOUBLE = 1,
 159             FEATURE_CL_UNIFIED_MEM,
 160             FEATURE_CL_VER_1_2
 161         };
 162
 163         // Represents OpenCL context, interface
 164         class CV_EXPORTS Context
 165         {
 166         protected:
 167             Context() { }
 168             ~Context() { }
 169         public:
 170             static Context* getContext();
 171
 172             bool supportsFeature(FEATURE_TYPE featureType) const;
 173             const DeviceInfo& getDeviceInfo() const;
 174
 175             const void* getOpenCLContextPtr() const;
 176             const void* getOpenCLCommandQueuePtr() const;
 177             const void* getOpenCLDeviceIDPtr() const;
 178         };
 179
 180         inline const void *getClContextPtr()
 181         {
 182             return Context::getContext()->getOpenCLContextPtr();
 183         }
 184
 185         inline const void *getClCommandQueuePtr()
 186         {
 187             return Context::getContext()->getOpenCLCommandQueuePtr();
 188         }
 189
 190         CV_EXPORTS bool supportsFeature(FEATURE_TYPE featureType);
 191
 192         CV_EXPORTS void finish();
 193
 194         enum BINARY_CACHE_MODE
 195         {
 196             CACHE_NONE    = 0,        // do not cache OpenCL binary
 197             CACHE_DEBUG   = 0x1 << 0, // cache OpenCL binary when built in debug mode
 198             CACHE_RELEASE = 0x1 << 1, // default behavior, only cache when built in release mode
 199             CACHE_ALL     = CACHE_DEBUG | CACHE_RELEASE, // cache opencl binary
 200         };
 201         //! Enable or disable OpenCL program binary caching onto local disk
 202         // After a program (*.cl files in opencl/ folder) is built at runtime, we allow the
 203         // compiled OpenCL program to be cached to the path automatically as "path/*.clb"
 204         // binary file, which will be reused when the OpenCV executable is started again.
 205         //
 206         // This feature is enabled by default.
 207         CV_EXPORTS void setBinaryDiskCache(int mode = CACHE_RELEASE, cv::String path = "./");
 208
 209         //! set where binary cache to be saved to
 210         CV_EXPORTS void setBinaryPath(const char *path);
 211
 212         struct ProgramSource
 213         {
 214             const char* name;
 215             const char* programStr;
 216             const char* programHash;
 217
 218             // Cache in memory by name (should be unique). Caching on disk disabled.
 219             inline ProgramSource(const char* _name, const char* _programStr)
 220                 : name(_name), programStr(_programStr), programHash(NULL)
 221             {
 222             }
 223
 224             // Cache in memory by name (should be unique). Caching on disk uses programHash mark.
 225             inline ProgramSource(const char* _name, const char* _programStr, const char* _programHash)
 226                 : name(_name), programStr(_programStr), programHash(_programHash)
 227             {
 228             }
 229         };
 230
 231         //! Calls OpenCL kernel. Pass globalThreads = NULL, and cleanUp = true, to finally clean-up without executing.
 232         //! Deprecated, will be replaced
 233         CV_EXPORTS void openCLExecuteKernelInterop(Context *clCxt,
 234                 const cv::ocl::ProgramSource& source, string kernelName,
 235                 size_t globalThreads[3], size_t localThreads[3],
 236                 std::vector< std::pair<size_t, const void *> > &args,
 237                 int channels, int depth, const char *build_options);
 238
 239         class CV_EXPORTS oclMatExpr;
 240         //////////////////////////////// oclMat ////////////////////////////////
 241         class CV_EXPORTS oclMat
 242         {
 243         public:
 244             //! default constructor
 245             oclMat();
 246             //! constructs oclMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
 247             oclMat(int rows, int cols, int type);
 248             oclMat(Size size, int type);
 249             //! constucts oclMatrix and fills it with the specified value _s.
 250             oclMat(int rows, int cols, int type, const Scalar &s);
 251             oclMat(Size size, int type, const Scalar &s);
 252             //! copy constructor
 253             oclMat(const oclMat &m);
 254
 255             //! constructor for oclMatrix headers pointing to user-allocated data
 256             oclMat(int rows, int cols, int type, void *data, size_t step = Mat::AUTO_STEP);
 257             oclMat(Size size, int type, void *data, size_t step = Mat::AUTO_STEP);
 258
 259             //! creates a matrix header for a part of the bigger matrix
 260             oclMat(const oclMat &m, const Range &rowRange, const Range &colRange);
 261             oclMat(const oclMat &m, const Rect &roi);
 262
 263             //! builds oclMat from Mat. Perfom blocking upload to device.
 264             explicit oclMat (const Mat &m);
 265
 266             //! destructor - calls release()
 267             ~oclMat();
 268
 269             //! assignment operators
 270             oclMat &operator = (const oclMat &m);
 271             //! assignment operator. Perfom blocking upload to device.
 272             oclMat &operator = (const Mat &m);
 273             oclMat &operator = (const oclMatExpr& expr);
 274
 275             //! pefroms blocking upload data to oclMat.
 276             void upload(const cv::Mat &m);
 277
 278
 279             //! downloads data from device to host memory. Blocking calls.
 280             operator Mat() const;
 281             void download(cv::Mat &m) const;
 282
 283             //! convert to _InputArray
 284             operator _InputArray();
 285
 286             //! convert to _OutputArray
 287             operator _OutputArray();
 288
 289             //! returns a new oclMatrix header for the specified row
 290             oclMat row(int y) const;
 291             //! returns a new oclMatrix header for the specified column
 292             oclMat col(int x) const;
 293             //! ... for the specified row span
 294             oclMat rowRange(int startrow, int endrow) const;
 295             oclMat rowRange(const Range &r) const;
 296             //! ... for the specified column span
 297             oclMat colRange(int startcol, int endcol) const;
 298             oclMat colRange(const Range &r) const;
 299
 300             //! returns deep copy of the oclMatrix, i.e. the data is copied
 301             oclMat clone() const;
 302
 303             //! copies those oclMatrix elements to "m" that are marked with non-zero mask elements.
 304             // It calls m.create(this->size(), this->type()).
 305             // It supports any data type
 306             void copyTo( oclMat &m, const oclMat &mask = oclMat()) const;
 307
 308             //! converts oclMatrix to another datatype with optional scalng. See cvConvertScale.
 309             //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
 310             void convertTo( oclMat &m, int rtype, double alpha = 1, double beta = 0 ) const;
 311
 312             void assignTo( oclMat &m, int type = -1 ) const;
 313
 314             //! sets every oclMatrix element to s
 315             //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
 316             oclMat& operator = (const Scalar &s);
 317             //! sets some of the oclMatrix elements to s, according to the mask
 318             //It supports 8UC1 8UC4 32SC1 32SC4 32FC1 32FC4
 319             oclMat& setTo(const Scalar &s, const oclMat &mask = oclMat());
 320             //! creates alternative oclMatrix header for the same data, with different
 321             // number of channels and/or different number of rows. see cvReshape.
 322             oclMat reshape(int cn, int rows = 0) const;
 323
 324             //! allocates new oclMatrix data unless the oclMatrix already has specified size and type.
 325             // previous data is unreferenced if needed.
 326             void create(int rows, int cols, int type);
 327             void create(Size size, int type);
 328
 329             //! allocates new oclMatrix with specified device memory type.
 330             void createEx(int rows, int cols, int type, DevMemRW rw_type, DevMemType mem_type);
 331             void createEx(Size size, int type, DevMemRW rw_type, DevMemType mem_type);
 332
 333             //! decreases reference counter;
 334             // deallocate the data when reference counter reaches 0.
 335             void release();
 336
 337             //! swaps with other smart pointer
 338             void swap(oclMat &mat);
 339
 340             //! locates oclMatrix header within a parent oclMatrix. See below
 341             void locateROI( Size &wholeSize, Point &ofs ) const;
 342             //! moves/resizes the current oclMatrix ROI inside the parent oclMatrix.
 343             oclMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
 344             //! extracts a rectangular sub-oclMatrix
 345             // (this is a generalized form of row, rowRange etc.)
 346             oclMat operator()( Range rowRange, Range colRange ) const;
 347             oclMat operator()( const Rect &roi ) const;
 348
 349             oclMat& operator+=( const oclMat& m );
 350             oclMat& operator-=( const oclMat& m );
 351             oclMat& operator*=( const oclMat& m );
 352             oclMat& operator/=( const oclMat& m );
 353
 354             //! returns true if the oclMatrix data is continuous
 355             // (i.e. when there are no gaps between successive rows).
 356             // similar to CV_IS_oclMat_CONT(cvoclMat->type)
 357             bool isContinuous() const;
 358             //! returns element size in bytes,
 359             // similar to CV_ELEM_SIZE(cvMat->type)
 360             size_t elemSize() const;
 361             //! returns the size of element channel in bytes.
 362             size_t elemSize1() const;
 363             //! returns element type, similar to CV_MAT_TYPE(cvMat->type)
 364             int type() const;
 365             //! returns element type, i.e. 8UC3 returns 8UC4 because in ocl
 366             //! 3 channels element actually use 4 channel space
 367             int ocltype() const;
 368             //! returns element type, similar to CV_MAT_DEPTH(cvMat->type)
 369             int depth() const;
 370             //! returns element type, similar to CV_MAT_CN(cvMat->type)
 371             int channels() const;
 372             //! returns element type, return 4 for 3 channels element,
 373             //!becuase 3 channels element actually use 4 channel space
 374             int oclchannels() const;
 375             //! returns step/elemSize1()
 376             size_t step1() const;
 377             //! returns oclMatrix size:
 378             // width == number of columns, height == number of rows
 379             Size size() const;
 380             //! returns true if oclMatrix data is NULL
 381             bool empty() const;
 382
 383             //! returns pointer to y-th row
 384             uchar* ptr(int y = 0);
 385             const uchar *ptr(int y = 0) const;
 386
 387             //! template version of the above method
 388             template<typename _Tp> _Tp *ptr(int y = 0);
 389             template<typename _Tp> const _Tp *ptr(int y = 0) const;
 390
 391             //! matrix transposition
 392             oclMat t() const;
 393
 394             /*! includes several bit-fields:
 395               - the magic signature
 396               - continuity flag
 397               - depth
 398               - number of channels
 399               */
 400             int flags;
 401             //! the number of rows and columns
 402             int rows, cols;
 403             //! a distance between successive rows in bytes; includes the gap if any
 404             size_t step;
 405             //! pointer to the data(OCL memory object)
 406             uchar *data;
 407
 408             //! pointer to the reference counter;
 409             // when oclMatrix points to user-allocated data, the pointer is NULL
 410             int *refcount;
 411
 412             //! helper fields used in locateROI and adjustROI
 413             //datastart and dataend are not used in current version
 414             uchar *datastart;
 415             uchar *dataend;
 416
 417             //! OpenCL context associated with the oclMat object.
 418             Context *clCxt; // TODO clCtx
 419             //add offset for handle ROI, calculated in byte
 420             int offset;
 421             //add wholerows and wholecols for the whole matrix, datastart and dataend are no longer used
 422             int wholerows;
 423             int wholecols;
 424         };
 425
 426         // convert InputArray/OutputArray to oclMat references
 427         CV_EXPORTS oclMat& getOclMatRef(InputArray src);
 428         CV_EXPORTS oclMat& getOclMatRef(OutputArray src);
 429
 430         ///////////////////// mat split and merge /////////////////////////////////
 431         //! Compose a multi-channel array from several single-channel arrays
 432         // Support all types
 433         CV_EXPORTS void merge(const oclMat *src, size_t n, oclMat &dst);
 434         CV_EXPORTS void merge(const vector<oclMat> &src, oclMat &dst);
 435
 436         //! Divides multi-channel array into several single-channel arrays
 437         // Support all types
 438         CV_EXPORTS void split(const oclMat &src, oclMat *dst);
 439         CV_EXPORTS void split(const oclMat &src, vector<oclMat> &dst);
 440
 441         ////////////////////////////// Arithmetics ///////////////////////////////////
 442
 443         //! adds one matrix to another with scale (dst = src1 * alpha + src2 * beta + gama)
 444         // supports all data types
 445         CV_EXPORTS void addWeighted(const oclMat &src1, double  alpha, const oclMat &src2, double beta, double gama, oclMat &dst);
 446
 447         //! adds one matrix to another (dst = src1 + src2)
 448         // supports all data types
 449         CV_EXPORTS void add(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
 450         //! adds scalar to a matrix (dst = src1 + s)
 451         // supports all data types
 452         CV_EXPORTS void add(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
 453
 454         //! subtracts one matrix from another (dst = src1 - src2)
 455         // supports all data types
 456         CV_EXPORTS void subtract(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
 457         //! subtracts scalar from a matrix (dst = src1 - s)
 458         // supports all data types
 459         CV_EXPORTS void subtract(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
 460
 461         //! computes element-wise product of the two arrays (dst = src1 * scale * src2)
 462         // supports all data types
 463         CV_EXPORTS void multiply(const oclMat &src1, const oclMat &src2, oclMat &dst, double scale = 1);
 464         //! multiplies matrix to a number (dst = scalar * src)
 465         // supports all data types
 466         CV_EXPORTS void multiply(double scalar, const oclMat &src, oclMat &dst);
 467
 468         //! computes element-wise quotient of the two arrays (dst = src1 * scale / src2)
 469         // supports all data types
 470         CV_EXPORTS void divide(const oclMat &src1, const oclMat &src2, oclMat &dst, double scale = 1);
 471         //! computes element-wise quotient of the two arrays (dst = scale / src)
 472         // supports all data types
 473         CV_EXPORTS void divide(double scale, const oclMat &src1, oclMat &dst);
 474
 475         //! computes element-wise minimum of the two arrays (dst = min(src1, src2))
 476         // supports all data types
 477         CV_EXPORTS void min(const oclMat &src1, const oclMat &src2, oclMat &dst);
 478
 479         //! computes element-wise maximum of the two arrays (dst = max(src1, src2))
 480         // supports all data types
 481         CV_EXPORTS void max(const oclMat &src1, const oclMat &src2, oclMat &dst);
 482
 483         //! compares elements of two arrays (dst = src1 <cmpop> src2)
 484         // supports all data types
 485         CV_EXPORTS void compare(const oclMat &src1, const oclMat &src2, oclMat &dst, int cmpop);
 486
 487         //! transposes the matrix
 488         // supports all data types
 489         CV_EXPORTS void transpose(const oclMat &src, oclMat &dst);
 490
 491         //! computes element-wise absolute values of an array (dst = abs(src))
 492         // supports all data types
 493         CV_EXPORTS void abs(const oclMat &src, oclMat &dst);
 494
 495         //! computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
 496         // supports all data types
 497         CV_EXPORTS void absdiff(const oclMat &src1, const oclMat &src2, oclMat &dst);
 498         //! computes element-wise absolute difference of array and scalar (dst = abs(src1 - s))
 499         // supports all data types
 500         CV_EXPORTS void absdiff(const oclMat &src1, const Scalar &s, oclMat &dst);
 501
 502         //! computes mean value and standard deviation of all or selected array elements
 503         // supports all data types
 504         CV_EXPORTS void meanStdDev(const oclMat &mtx, Scalar &mean, Scalar &stddev);
 505
 506         //! computes norm of array
 507         // supports NORM_INF, NORM_L1, NORM_L2
 508         // supports all data types
 509         CV_EXPORTS double norm(const oclMat &src1, int normType = NORM_L2);
 510
 511         //! computes norm of the difference between two arrays
 512         // supports NORM_INF, NORM_L1, NORM_L2
 513         // supports all data types
 514         CV_EXPORTS double norm(const oclMat &src1, const oclMat &src2, int normType = NORM_L2);
 515
 516         //! reverses the order of the rows, columns or both in a matrix
 517         // supports all types
 518         CV_EXPORTS void flip(const oclMat &src, oclMat &dst, int flipCode);
 519
 520         //! computes sum of array elements
 521         // support all types
 522         CV_EXPORTS Scalar sum(const oclMat &m);
 523         CV_EXPORTS Scalar absSum(const oclMat &m);
 524         CV_EXPORTS Scalar sqrSum(const oclMat &m);
 525
 526         //! finds global minimum and maximum array elements and returns their values
 527         // support all C1 types
 528         CV_EXPORTS void minMax(const oclMat &src, double *minVal, double *maxVal = 0, const oclMat &mask = oclMat());
 529
 530         //! finds global minimum and maximum array elements and returns their values with locations
 531         // support all C1 types
 532         CV_EXPORTS void minMaxLoc(const oclMat &src, double *minVal, double *maxVal = 0, Point *minLoc = 0, Point *maxLoc = 0,
 533                                   const oclMat &mask = oclMat());
 534
 535         //! counts non-zero array elements
 536         // support all types
 537         CV_EXPORTS int countNonZero(const oclMat &src);
 538
 539         //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
 540         // destination array will have the depth type as lut and the same channels number as source
 541         //It supports 8UC1 8UC4 only
 542         CV_EXPORTS void LUT(const oclMat &src, const oclMat &lut, oclMat &dst);
 543
 544         //! only 8UC1 and 256 bins is supported now
 545         CV_EXPORTS void calcHist(const oclMat &mat_src, oclMat &mat_hist);
 546         //! only 8UC1 and 256 bins is supported now
 547         CV_EXPORTS void equalizeHist(const oclMat &mat_src, oclMat &mat_dst);
 548
 549         //! only 8UC1 is supported now
 550         CV_EXPORTS Ptr<cv::CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));
 551
 552         //! bilateralFilter
 553         // supports 8UC1 8UC4
 554         CV_EXPORTS void bilateralFilter(const oclMat& src, oclMat& dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT);
 555
 556         //! Applies an adaptive bilateral filter to the input image
 557         //  This is not truly a bilateral filter. Instead of using user provided fixed parameters,
 558         //  the function calculates a constant at each window based on local standard deviation,
 559         //  and use this constant to do filtering.
 560         //  supports 8UC1, 8UC3
 561         CV_EXPORTS void adaptiveBilateralFilter(const oclMat& src, oclMat& dst, Size ksize, double sigmaSpace, Point anchor = Point(-1, -1), int borderType=BORDER_DEFAULT);
 562
 563         //! computes exponent of each matrix element (dst = e**src)
 564         // supports only CV_32FC1, CV_64FC1 type
 565         CV_EXPORTS void exp(const oclMat &src, oclMat &dst);
 566
 567         //! computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
 568         // supports only CV_32FC1, CV_64FC1 type
 569         CV_EXPORTS void log(const oclMat &src, oclMat &dst);
 570
 571         //! computes magnitude of each (x(i), y(i)) vector
 572         // supports only CV_32F, CV_64F type
 573         CV_EXPORTS void magnitude(const oclMat &x, const oclMat &y, oclMat &magnitude);
 574
 575         //! computes angle (angle(i)) of each (x(i), y(i)) vector
 576         // supports only CV_32F, CV_64F type
 577         CV_EXPORTS void phase(const oclMat &x, const oclMat &y, oclMat &angle, bool angleInDegrees = false);
 578
 579         //! the function raises every element of tne input array to p
 580         // support only CV_32F, CV_64F type
 581         CV_EXPORTS void pow(const oclMat &x, double p, oclMat &y);
 582
 583         //! converts Cartesian coordinates to polar
 584         // supports only CV_32F CV_64F type
 585         CV_EXPORTS void cartToPolar(const oclMat &x, const oclMat &y, oclMat &magnitude, oclMat &angle, bool angleInDegrees = false);
 586
 587         //! converts polar coordinates to Cartesian
 588         // supports only CV_32F CV_64F type
 589         CV_EXPORTS void polarToCart(const oclMat &magnitude, const oclMat &angle, oclMat &x, oclMat &y, bool angleInDegrees = false);
 590
 591         //! perfroms per-elements bit-wise inversion
 592         // supports all types
 593         CV_EXPORTS void bitwise_not(const oclMat &src, oclMat &dst);
 594
 595         //! calculates per-element bit-wise disjunction of two arrays
 596         // supports all types
 597         CV_EXPORTS void bitwise_or(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
 598         CV_EXPORTS void bitwise_or(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
 599
 600         //! calculates per-element bit-wise conjunction of two arrays
 601         // supports all types
 602         CV_EXPORTS void bitwise_and(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
 603         CV_EXPORTS void bitwise_and(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
 604
 605         //! calculates per-element bit-wise "exclusive or" operation
 606         // supports all types
 607         CV_EXPORTS void bitwise_xor(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat());
 608         CV_EXPORTS void bitwise_xor(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat());
 609
 610         //! Logical operators
 611         CV_EXPORTS oclMat operator ~ (const oclMat &);
 612         CV_EXPORTS oclMat operator | (const oclMat &, const oclMat &);
 613         CV_EXPORTS oclMat operator & (const oclMat &, const oclMat &);
 614         CV_EXPORTS oclMat operator ^ (const oclMat &, const oclMat &);
 615
 616
 617         //! Mathematics operators
 618         CV_EXPORTS oclMatExpr operator + (const oclMat &src1, const oclMat &src2);
 619         CV_EXPORTS oclMatExpr operator - (const oclMat &src1, const oclMat &src2);
 620         CV_EXPORTS oclMatExpr operator * (const oclMat &src1, const oclMat &src2);
 621         CV_EXPORTS oclMatExpr operator / (const oclMat &src1, const oclMat &src2);
 622
 623         //! computes convolution of two images
 624         // support only CV_32FC1 type
 625         CV_EXPORTS void convolve(const oclMat &image, const oclMat &temp1, oclMat &result);
 626
 627         CV_EXPORTS void cvtColor(const oclMat &src, oclMat &dst, int code, int dcn = 0);
 628
 629         //! initializes a scaled identity matrix
 630         CV_EXPORTS void setIdentity(oclMat& src, const Scalar & val = Scalar(1));
 631
 632         //////////////////////////////// Filter Engine ////////////////////////////////
 633
 634         /*!
 635           The Base Class for 1D or Row-wise Filters
 636
 637           This is the base class for linear or non-linear filters that process 1D data.
 638           In particular, such filters are used for the "horizontal" filtering parts in separable filters.
 639           */
 640         class CV_EXPORTS BaseRowFilter_GPU
 641         {
 642         public:
 643             BaseRowFilter_GPU(int ksize_, int anchor_, int bordertype_) : ksize(ksize_), anchor(anchor_), bordertype(bordertype_) {}
 644             virtual ~BaseRowFilter_GPU() {}
 645             virtual void operator()(const oclMat &src, oclMat &dst) = 0;
 646             int ksize, anchor, bordertype;
 647         };
 648
 649         /*!
 650           The Base Class for Column-wise Filters
 651
 652           This is the base class for linear or non-linear filters that process columns of 2D arrays.
 653           Such filters are used for the "vertical" filtering parts in separable filters.
 654           */
 655         class CV_EXPORTS BaseColumnFilter_GPU
 656         {
 657         public:
 658             BaseColumnFilter_GPU(int ksize_, int anchor_, int bordertype_) : ksize(ksize_), anchor(anchor_), bordertype(bordertype_) {}
 659             virtual ~BaseColumnFilter_GPU() {}
 660             virtual void operator()(const oclMat &src, oclMat &dst) = 0;
 661             int ksize, anchor, bordertype;
 662         };
 663
 664         /*!
 665           The Base Class for Non-Separable 2D Filters.
 666
 667           This is the base class for linear or non-linear 2D filters.
 668           */
 669         class CV_EXPORTS BaseFilter_GPU
 670         {
 671         public:
 672             BaseFilter_GPU(const Size &ksize_, const Point &anchor_, const int &borderType_)
 673                 : ksize(ksize_), anchor(anchor_), borderType(borderType_) {}
 674             virtual ~BaseFilter_GPU() {}
 675             virtual void operator()(const oclMat &src, oclMat &dst) = 0;
 676             Size ksize;
 677             Point anchor;
 678             int borderType;
 679         };
 680
 681         /*!
 682           The Base Class for Filter Engine.
 683
 684           The class can be used to apply an arbitrary filtering operation to an image.
 685           It contains all the necessary intermediate buffers.
 686           */
 687         class CV_EXPORTS FilterEngine_GPU
 688         {
 689         public:
 690             virtual ~FilterEngine_GPU() {}
 691
 692             virtual void apply(const oclMat &src, oclMat &dst, Rect roi = Rect(0, 0, -1, -1)) = 0;
 693         };
 694
 695         //! returns the non-separable filter engine with the specified filter
 696         CV_EXPORTS Ptr<FilterEngine_GPU> createFilter2D_GPU(const Ptr<BaseFilter_GPU> filter2D);
 697
 698         //! returns the primitive row filter with the specified kernel
 699         CV_EXPORTS Ptr<BaseRowFilter_GPU> getLinearRowFilter_GPU(int srcType, int bufType, const Mat &rowKernel,
 700                 int anchor = -1, int bordertype = BORDER_DEFAULT);
 701
 702         //! returns the primitive column filter with the specified kernel
 703         CV_EXPORTS Ptr<BaseColumnFilter_GPU> getLinearColumnFilter_GPU(int bufType, int dstType, const Mat &columnKernel,
 704                 int anchor = -1, int bordertype = BORDER_DEFAULT, double delta = 0.0);
 705
 706         //! returns the separable linear filter engine
 707         CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat &rowKernel,
 708                 const Mat &columnKernel, const Point &anchor = Point(-1, -1), double delta = 0.0, int bordertype = BORDER_DEFAULT);
 709
 710         //! returns the separable filter engine with the specified filters
 711         CV_EXPORTS Ptr<FilterEngine_GPU> createSeparableFilter_GPU(const Ptr<BaseRowFilter_GPU> &rowFilter,
 712                 const Ptr<BaseColumnFilter_GPU> &columnFilter);
 713
 714         //! returns the Gaussian filter engine
 715         CV_EXPORTS Ptr<FilterEngine_GPU> createGaussianFilter_GPU(int type, Size ksize, double sigma1, double sigma2 = 0, int bordertype = BORDER_DEFAULT);
 716
 717         //! returns filter engine for the generalized Sobel operator
 718         CV_EXPORTS Ptr<FilterEngine_GPU> createDerivFilter_GPU( int srcType, int dstType, int dx, int dy, int ksize, int borderType = BORDER_DEFAULT );
 719
 720         //! applies Laplacian operator to the image
 721         // supports only ksize = 1 and ksize = 3 8UC1 8UC4 32FC1 32FC4 data type
 722         CV_EXPORTS void Laplacian(const oclMat &src, oclMat &dst, int ddepth, int ksize = 1, double scale = 1);
 723
 724         //! returns 2D box filter
 725         // supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type
 726         CV_EXPORTS Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType,
 727                 const Size &ksize, Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
 728
 729         //! returns box filter engine
 730         CV_EXPORTS Ptr<FilterEngine_GPU> createBoxFilter_GPU(int srcType, int dstType, const Size &ksize,
 731                 const Point &anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
 732
 733         //! returns 2D filter with the specified kernel
 734         // supports CV_8UC1 and CV_8UC4 types
 735         CV_EXPORTS Ptr<BaseFilter_GPU> getLinearFilter_GPU(int srcType, int dstType, const Mat &kernel, const Size &ksize,
 736                 const Point &anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
 737
 738         //! returns the non-separable linear filter engine
 739         CV_EXPORTS Ptr<FilterEngine_GPU> createLinearFilter_GPU(int srcType, int dstType, const Mat &kernel,
 740                 const Point &anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
 741
 742         //! smooths the image using the normalized box filter
 743         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 744         // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101,BORDER_WRAP
 745         CV_EXPORTS void boxFilter(const oclMat &src, oclMat &dst, int ddepth, Size ksize,
 746                                   Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
 747
 748         //! returns 2D morphological filter
 749         //! only MORPH_ERODE and MORPH_DILATE are supported
 750         // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
 751         // kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
 752         CV_EXPORTS Ptr<BaseFilter_GPU> getMorphologyFilter_GPU(int op, int type, const Mat &kernel, const Size &ksize,
 753                 Point anchor = Point(-1, -1));
 754
 755         //! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
 756         CV_EXPORTS Ptr<FilterEngine_GPU> createMorphologyFilter_GPU(int op, int type, const Mat &kernel,
 757                 const Point &anchor = Point(-1, -1), int iterations = 1);
 758
 759         //! a synonym for normalized box filter
 760         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 761         // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
 762         static inline void blur(const oclMat &src, oclMat &dst, Size ksize, Point anchor = Point(-1, -1),
 763                                 int borderType = BORDER_CONSTANT)
 764         {
 765             boxFilter(src, dst, -1, ksize, anchor, borderType);
 766         }
 767
 768         //! applies non-separable 2D linear filter to the image
 769         //  Note, at the moment this function only works when anchor point is in the kernel center
 770         //  and kernel size supported is either 3x3 or 5x5; otherwise the function will fail to output valid result
 771         CV_EXPORTS void filter2D(const oclMat &src, oclMat &dst, int ddepth, const Mat &kernel,
 772                                  Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT);
 773
 774         //! applies separable 2D linear filter to the image
 775         CV_EXPORTS void sepFilter2D(const oclMat &src, oclMat &dst, int ddepth, const Mat &kernelX, const Mat &kernelY,
 776                                     Point anchor = Point(-1, -1), double delta = 0.0, int bordertype = BORDER_DEFAULT);
 777
 778         //! applies generalized Sobel operator to the image
 779         // dst.type must equalize src.type
 780         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 781         // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
 782         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);
 783
 784         //! applies the vertical or horizontal Scharr operator to the image
 785         // dst.type must equalize src.type
 786         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 787         // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
 788         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);
 789
 790         //! smooths the image using Gaussian filter.
 791         // dst.type must equalize src.type
 792         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 793         // supports border type: BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT,BORDER_REFLECT_101
 794         CV_EXPORTS void GaussianBlur(const oclMat &src, oclMat &dst, Size ksize, double sigma1, double sigma2 = 0, int bordertype = BORDER_DEFAULT);
 795
 796         //! erodes the image (applies the local minimum operator)
 797         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 798         CV_EXPORTS void erode( const oclMat &src, oclMat &dst, const Mat &kernel, Point anchor = Point(-1, -1), int iterations = 1,
 799
 800                                int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue());
 801
 802
 803         //! dilates the image (applies the local maximum operator)
 804         // supports data type: CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4
 805         CV_EXPORTS void dilate( const oclMat &src, oclMat &dst, const Mat &kernel, Point anchor = Point(-1, -1), int iterations = 1,
 806
 807                                 int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue());
 808
 809
 810         //! applies an advanced morphological operation to the image
 811         CV_EXPORTS void morphologyEx( const oclMat &src, oclMat &dst, int op, const Mat &kernel, Point anchor = Point(-1, -1), int iterations = 1,
 812
 813                                       int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue());
 814
 815
 816         ////////////////////////////// Image processing //////////////////////////////
 817         //! Does mean shift filtering on GPU.
 818         CV_EXPORTS void meanShiftFiltering(const oclMat &src, oclMat &dst, int sp, int sr,
 819                                            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
 820
 821         //! Does mean shift procedure on GPU.
 822         CV_EXPORTS void meanShiftProc(const oclMat &src, oclMat &dstr, oclMat &dstsp, int sp, int sr,
 823                                       TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
 824
 825         //! Does mean shift segmentation with elimiation of small regions.
 826         CV_EXPORTS void meanShiftSegmentation(const oclMat &src, Mat &dst, int sp, int sr, int minsize,
 827                                               TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
 828
 829         //! applies fixed threshold to the image.
 830         // supports CV_8UC1 and CV_32FC1 data type
 831         // supports threshold type: THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV
 832         CV_EXPORTS double threshold(const oclMat &src, oclMat &dst, double thresh, double maxVal, int type = THRESH_TRUNC);
 833
 834         //! resizes the image
 835         // Supports INTER_NEAREST, INTER_LINEAR
 836         // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
 837         CV_EXPORTS void resize(const oclMat &src, oclMat &dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR);
 838
 839         //! Applies a generic geometrical transformation to an image.
 840
 841         // Supports INTER_NEAREST, INTER_LINEAR.
 842         // Map1 supports CV_16SC2, CV_32FC2  types.
 843         // Src supports CV_8UC1, CV_8UC2, CV_8UC4.
 844         CV_EXPORTS void remap(const oclMat &src, oclMat &dst, oclMat &map1, oclMat &map2, int interpolation, int bordertype, const Scalar &value = Scalar());
 845
 846         //! copies 2D array to a larger destination array and pads borders with user-specifiable constant
 847         // supports CV_8UC1, CV_8UC4, CV_32SC1 types
 848         CV_EXPORTS void copyMakeBorder(const oclMat &src, oclMat &dst, int top, int bottom, int left, int right, int boardtype, const Scalar &value = Scalar());
 849
 850         //! Smoothes image using median filter
 851         // The source 1- or 4-channel image. m should be 3 or 5, the image depth should be CV_8U or CV_32F.
 852         CV_EXPORTS void medianFilter(const oclMat &src, oclMat &dst, int m);
 853
 854         //! warps the image using affine 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 warpAffine(const oclMat &src, oclMat &dst, const Mat &M, Size dsize, int flags = INTER_LINEAR);
 858
 859         //! warps the image using perspective transformation
 860         // Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
 861         // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types
 862         CV_EXPORTS void warpPerspective(const oclMat &src, oclMat &dst, const Mat &M, Size dsize, int flags = INTER_LINEAR);
 863
 864         //! computes the integral image and integral for the squared image
 865         // sum will have CV_32S type, sqsum - CV32F type
 866         // supports only CV_8UC1 source type
 867         CV_EXPORTS void integral(const oclMat &src, oclMat &sum, oclMat &sqsum);
 868         CV_EXPORTS void integral(const oclMat &src, oclMat &sum);
 869         CV_EXPORTS void cornerHarris(const oclMat &src, oclMat &dst, int blockSize, int ksize, double k, int bordertype = cv::BORDER_DEFAULT);
 870         CV_EXPORTS void cornerHarris_dxdy(const oclMat &src, oclMat &dst, oclMat &Dx, oclMat &Dy,
 871             int blockSize, int ksize, double k, int bordertype = cv::BORDER_DEFAULT);
 872         CV_EXPORTS void cornerMinEigenVal(const oclMat &src, oclMat &dst, int blockSize, int ksize, int bordertype = cv::BORDER_DEFAULT);
 873         CV_EXPORTS void cornerMinEigenVal_dxdy(const oclMat &src, oclMat &dst, oclMat &Dx, oclMat &Dy,
 874             int blockSize, int ksize, int bordertype = cv::BORDER_DEFAULT);
 875
 876         /////////////////////////////////// ML ///////////////////////////////////////////
 877
 878         //! Compute closest centers for each lines in source and lable it after center's index
 879         // supports CV_32FC1/CV_32FC2/CV_32FC4 data type
 880         CV_EXPORTS void distanceToCenters(oclMat &dists, oclMat &labels, const oclMat &src, const oclMat &centers);
 881
 882         //!Does k-means procedure on GPU
 883         // supports CV_32FC1/CV_32FC2/CV_32FC4 data type
 884         CV_EXPORTS double kmeans(const oclMat &src, int K, oclMat &bestLabels,
 885                                      TermCriteria criteria, int attemps, int flags, oclMat &centers);
 886
 887
 888         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 889         ///////////////////////////////////////////CascadeClassifier//////////////////////////////////////////////////////////////////
 890         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 891
 892         class CV_EXPORTS_W OclCascadeClassifier : public  cv::CascadeClassifier
 893         {
 894         public:
 895             OclCascadeClassifier() {};
 896             ~OclCascadeClassifier() {};
 897
 898             CvSeq* oclHaarDetectObjects(oclMat &gimg, CvMemStorage *storage, double scaleFactor,
 899                                         int minNeighbors, int flags, CvSize minSize = cvSize(0, 0), CvSize maxSize = cvSize(0, 0));
 900         };
 901
 902         class CV_EXPORTS OclCascadeClassifierBuf : public  cv::CascadeClassifier
 903         {
 904         public:
 905             OclCascadeClassifierBuf() :
 906                 m_flags(0), initialized(false), m_scaleFactor(0), buffers(NULL) {}
 907
 908             ~OclCascadeClassifierBuf() { release(); }
 909
 910             void detectMultiScale(oclMat &image, CV_OUT std::vector<cv::Rect>& faces,
 911                                   double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0,
 912                                   Size minSize = Size(), Size maxSize = Size());
 913             void release();
 914
 915         private:
 916             void Init(const int rows, const int cols, double scaleFactor, int flags,
 917                       const int outputsz, const size_t localThreads[],
 918                       CvSize minSize, CvSize maxSize);
 919             void CreateBaseBufs(const int datasize, const int totalclassifier, const int flags, const int outputsz);
 920             void CreateFactorRelatedBufs(const int rows, const int cols, const int flags,
 921                                          const double scaleFactor, const size_t localThreads[],
 922                                          CvSize minSize, CvSize maxSize);
 923             void GenResult(CV_OUT std::vector<cv::Rect>& faces, const std::vector<cv::Rect> &rectList, const std::vector<int> &rweights);
 924
 925             int m_rows;
 926             int m_cols;
 927             int m_flags;
 928             int m_loopcount;
 929             int m_nodenum;
 930             bool findBiggestObject;
 931             bool initialized;
 932             double m_scaleFactor;
 933             Size m_minSize;
 934             Size m_maxSize;
 935             vector<CvSize> sizev;
 936             vector<float> scalev;
 937             oclMat gimg1, gsum, gsqsum;
 938             void * buffers;
 939         };
 940
 941
 942         /////////////////////////////// Pyramid /////////////////////////////////////
 943         CV_EXPORTS void pyrDown(const oclMat &src, oclMat &dst);
 944
 945         //! upsamples the source image and then smoothes it
 946         CV_EXPORTS void pyrUp(const oclMat &src, oclMat &dst);
 947
 948         //! performs linear blending of two images
 949         //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
 950         // supports only CV_8UC1 source type
 951         CV_EXPORTS void blendLinear(const oclMat &img1, const oclMat &img2, const oclMat &weights1, const oclMat &weights2, oclMat &result);
 952
 953         //! computes vertical sum, supports only CV_32FC1 images
 954         CV_EXPORTS void columnSum(const oclMat &src, oclMat &sum);
 955
 956         ///////////////////////////////////////// match_template /////////////////////////////////////////////////////////////
 957         struct CV_EXPORTS MatchTemplateBuf
 958         {
 959             Size user_block_size;
 960             oclMat imagef, templf;
 961             std::vector<oclMat> images;
 962             std::vector<oclMat> image_sums;
 963             std::vector<oclMat> image_sqsums;
 964         };
 965
 966         //! computes the proximity map for the raster template and the image where the template is searched for
 967         // Supports TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED for type 8UC1 and 8UC4
 968         // Supports TM_SQDIFF, TM_CCORR for type 32FC1 and 32FC4
 969         CV_EXPORTS void matchTemplate(const oclMat &image, const oclMat &templ, oclMat &result, int method);
 970
 971         //! computes the proximity map for the raster template and the image where the template is searched for
 972         // Supports TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED for type 8UC1 and 8UC4
 973         // Supports TM_SQDIFF, TM_CCORR for type 32FC1 and 32FC4
 974         CV_EXPORTS void matchTemplate(const oclMat &image, const oclMat &templ, oclMat &result, int method, MatchTemplateBuf &buf);
 975
 976         ///////////////////////////////////////////// Canny /////////////////////////////////////////////
 977         struct CV_EXPORTS CannyBuf;
 978         //! compute edges of the input image using Canny operator
 979         // Support CV_8UC1 only
 980         CV_EXPORTS void Canny(const oclMat &image, oclMat &edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
 981         CV_EXPORTS void Canny(const oclMat &image, CannyBuf &buf, oclMat &edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
 982         CV_EXPORTS void Canny(const oclMat &dx, const oclMat &dy, oclMat &edges, double low_thresh, double high_thresh, bool L2gradient = false);
 983         CV_EXPORTS void Canny(const oclMat &dx, const oclMat &dy, CannyBuf &buf, oclMat &edges, double low_thresh, double high_thresh, bool L2gradient = false);
 984
 985         struct CV_EXPORTS CannyBuf
 986         {
 987             CannyBuf() : counter(NULL) {}
 988             ~CannyBuf()
 989             {
 990                 release();
 991             }
 992             explicit CannyBuf(const Size &image_size, int apperture_size = 3) : counter(NULL)
 993             {
 994                 create(image_size, apperture_size);
 995             }
 996             CannyBuf(const oclMat &dx_, const oclMat &dy_);
 997
 998             void create(const Size &image_size, int apperture_size = 3);
 999             void release();
1000             oclMat dx, dy;
1001             oclMat dx_buf, dy_buf;
1002             oclMat edgeBuf;
1003             oclMat trackBuf1, trackBuf2;
1004             void *counter;
1005             Ptr<FilterEngine_GPU> filterDX, filterDY;
1006         };
1007
1008         ///////////////////////////////////////// clAmdFft related /////////////////////////////////////////
1009         //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
1010         //! Param dft_size is the size of DFT transform.
1011         //!
1012         //! For complex-to-real transform it is assumed that the source matrix is packed in CLFFT's format.
1013         // support src type of CV32FC1, CV32FC2
1014         // support flags: DFT_INVERSE, DFT_REAL_OUTPUT, DFT_COMPLEX_OUTPUT, DFT_ROWS
1015         // dft_size is the size of original input, which is used for transformation from complex to real.
1016         // dft_size must be powers of 2, 3 and 5
1017         // real to complex dft requires at least v1.8 clAmdFft
1018         // real to complex dft output is not the same with cpu version
1019         // real to complex and complex to real does not support DFT_ROWS
1020         CV_EXPORTS void dft(const oclMat &src, oclMat &dst, Size dft_size = Size(), int flags = 0);
1021
1022         //! implements generalized matrix product algorithm GEMM from BLAS
1023         // The functionality requires clAmdBlas library
1024         // only support type CV_32FC1
1025         // flag GEMM_3_T is not supported
1026         CV_EXPORTS void gemm(const oclMat &src1, const oclMat &src2, double alpha,
1027                              const oclMat &src3, double beta, oclMat &dst, int flags = 0);
1028
1029         //////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
1030         struct CV_EXPORTS HOGDescriptor
1031         {
1032             enum { DEFAULT_WIN_SIGMA = -1 };
1033             enum { DEFAULT_NLEVELS = 64 };
1034             enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };
1035             HOGDescriptor(Size win_size = Size(64, 128), Size block_size = Size(16, 16),
1036                           Size block_stride = Size(8, 8), Size cell_size = Size(8, 8),
1037                           int nbins = 9, double win_sigma = DEFAULT_WIN_SIGMA,
1038                           double threshold_L2hys = 0.2, bool gamma_correction = true,
1039                           int nlevels = DEFAULT_NLEVELS);
1040
1041             size_t getDescriptorSize() const;
1042             size_t getBlockHistogramSize() const;
1043             void setSVMDetector(const vector<float> &detector);
1044             static vector<float> getDefaultPeopleDetector();
1045             static vector<float> getPeopleDetector48x96();
1046             static vector<float> getPeopleDetector64x128();
1047             void detect(const oclMat &img, vector<Point> &found_locations,
1048                         double hit_threshold = 0, Size win_stride = Size(),
1049                         Size padding = Size());
1050             void detectMultiScale(const oclMat &img, vector<Rect> &found_locations,
1051                                   double hit_threshold = 0, Size win_stride = Size(),
1052                                   Size padding = Size(), double scale0 = 1.05,
1053                                   int group_threshold = 2);
1054             void getDescriptors(const oclMat &img, Size win_stride,
1055                                 oclMat &descriptors,
1056                                 int descr_format = DESCR_FORMAT_COL_BY_COL);
1057             Size win_size;
1058             Size block_size;
1059             Size block_stride;
1060             Size cell_size;
1061
1062             int nbins;
1063             double win_sigma;
1064             double threshold_L2hys;
1065             bool gamma_correction;
1066             int nlevels;
1067
1068         protected:
1069             // initialize buffers; only need to do once in case of multiscale detection
1070             void init_buffer(const oclMat &img, Size win_stride);
1071             void computeBlockHistograms(const oclMat &img);
1072             void computeGradient(const oclMat &img, oclMat &grad, oclMat &qangle);
1073             double getWinSigma() const;
1074             bool checkDetectorSize() const;
1075
1076             static int numPartsWithin(int size, int part_size, int stride);
1077             static Size numPartsWithin(Size size, Size part_size, Size stride);
1078
1079             // Coefficients of the separating plane
1080             float free_coef;
1081             oclMat detector;
1082             // Results of the last classification step
1083             oclMat labels;
1084             Mat labels_host;
1085             // Results of the last histogram evaluation step
1086             oclMat block_hists;
1087             // Gradients conputation results
1088             oclMat grad, qangle;
1089             // scaled image
1090             oclMat image_scale;
1091             // effect size of input image (might be different from original size after scaling)
1092             Size effect_size;
1093         };
1094
1095
1096         ////////////////////////feature2d_ocl/////////////////
1097         /****************************************************************************************\
1098         *                                      Distance                                          *
1099         \****************************************************************************************/
1100         template<typename T>
1101         struct CV_EXPORTS Accumulator
1102         {
1103             typedef T Type;
1104         };
1105         template<> struct Accumulator<unsigned char>
1106         {
1107             typedef float Type;
1108         };
1109         template<> struct Accumulator<unsigned short>
1110         {
1111             typedef float Type;
1112         };
1113         template<> struct Accumulator<char>
1114         {
1115             typedef float Type;
1116         };
1117         template<> struct Accumulator<short>
1118         {
1119             typedef float Type;
1120         };
1121
1122         /*
1123          * Manhattan distance (city block distance) functor
1124          */
1125         template<class T>
1126         struct CV_EXPORTS L1
1127         {
1128             enum { normType = NORM_L1 };
1129             typedef T ValueType;
1130             typedef typename Accumulator<T>::Type ResultType;
1131
1132             ResultType operator()( const T *a, const T *b, int size ) const
1133             {
1134                 return normL1<ValueType, ResultType>(a, b, size);
1135             }
1136         };
1137
1138         /*
1139          * Euclidean distance functor
1140          */
1141         template<class T>
1142         struct CV_EXPORTS L2
1143         {
1144             enum { normType = NORM_L2 };
1145             typedef T ValueType;
1146             typedef typename Accumulator<T>::Type ResultType;
1147
1148             ResultType operator()( const T *a, const T *b, int size ) const
1149             {
1150                 return (ResultType)sqrt((double)normL2Sqr<ValueType, ResultType>(a, b, size));
1151             }
1152         };
1153
1154         /*
1155          * Hamming distance functor - counts the bit differences between two strings - useful for the Brief descriptor
1156          * bit count of A exclusive XOR'ed with B
1157          */
1158         struct CV_EXPORTS Hamming
1159         {
1160             enum { normType = NORM_HAMMING };
1161             typedef unsigned char ValueType;
1162             typedef int ResultType;
1163
1164             /** this will count the bits in a ^ b
1165              */
1166             ResultType operator()( const unsigned char *a, const unsigned char *b, int size ) const
1167             {
1168                 return normHamming(a, b, size);
1169             }
1170         };
1171
1172         ////////////////////////////////// BruteForceMatcher //////////////////////////////////
1173
1174         class CV_EXPORTS BruteForceMatcher_OCL_base
1175         {
1176         public:
1177             enum DistType {L1Dist = 0, L2Dist, HammingDist};
1178             explicit BruteForceMatcher_OCL_base(DistType distType = L2Dist);
1179             // Add descriptors to train descriptor collection
1180             void add(const std::vector<oclMat> &descCollection);
1181             // Get train descriptors collection
1182             const std::vector<oclMat> &getTrainDescriptors() const;
1183             // Clear train descriptors collection
1184             void clear();
1185             // Return true if there are not train descriptors in collection
1186             bool empty() const;
1187
1188             // Return true if the matcher supports mask in match methods
1189             bool isMaskSupported() const;
1190
1191             // Find one best match for each query descriptor
1192             void matchSingle(const oclMat &query, const oclMat &train,
1193                              oclMat &trainIdx, oclMat &distance,
1194                              const oclMat &mask = oclMat());
1195
1196             // Download trainIdx and distance and convert it to CPU vector with DMatch
1197             static void matchDownload(const oclMat &trainIdx, const oclMat &distance, std::vector<DMatch> &matches);
1198             // Convert trainIdx and distance to vector with DMatch
1199             static void matchConvert(const Mat &trainIdx, const Mat &distance, std::vector<DMatch> &matches);
1200
1201             // Find one best match for each query descriptor
1202             void match(const oclMat &query, const oclMat &train, std::vector<DMatch> &matches, const oclMat &mask = oclMat());
1203
1204             // Make gpu collection of trains and masks in suitable format for matchCollection function
1205             void makeGpuCollection(oclMat &trainCollection, oclMat &maskCollection, const std::vector<oclMat> &masks = std::vector<oclMat>());
1206
1207
1208             // Find one best match from train collection for each query descriptor
1209             void matchCollection(const oclMat &query, const oclMat &trainCollection,
1210                                  oclMat &trainIdx, oclMat &imgIdx, oclMat &distance,
1211                                  const oclMat &masks = oclMat());
1212
1213             // Download trainIdx, imgIdx and distance and convert it to vector with DMatch
1214             static void matchDownload(const oclMat &trainIdx, const oclMat &imgIdx, const oclMat &distance, std::vector<DMatch> &matches);
1215             // Convert trainIdx, imgIdx and distance to vector with DMatch
1216             static void matchConvert(const Mat &trainIdx, const Mat &imgIdx, const Mat &distance, std::vector<DMatch> &matches);
1217
1218             // Find one best match from train collection for each query descriptor.
1219             void match(const oclMat &query, std::vector<DMatch> &matches, const std::vector<oclMat> &masks = std::vector<oclMat>());
1220
1221             // Find k best matches for each query descriptor (in increasing order of distances)
1222             void knnMatchSingle(const oclMat &query, const oclMat &train,
1223                                 oclMat &trainIdx, oclMat &distance, oclMat &allDist, int k,
1224                                 const oclMat &mask = oclMat());
1225
1226             // Download trainIdx and distance and convert it to vector with DMatch
1227             // compactResult is used when mask is not empty. If compactResult is false matches
1228             // vector will have the same size as queryDescriptors rows. If compactResult is true
1229             // matches vector will not contain matches for fully masked out query descriptors.
1230             static void knnMatchDownload(const oclMat &trainIdx, const oclMat &distance,
1231                                          std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1232
1233             // Convert trainIdx and distance to vector with DMatch
1234             static void knnMatchConvert(const Mat &trainIdx, const Mat &distance,
1235                                         std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1236
1237             // Find k best matches for each query descriptor (in increasing order of distances).
1238             // compactResult is used when mask is not empty. If compactResult is false matches
1239             // vector will have the same size as queryDescriptors rows. If compactResult is true
1240             // matches vector will not contain matches for fully masked out query descriptors.
1241             void knnMatch(const oclMat &query, const oclMat &train,
1242                           std::vector< std::vector<DMatch> > &matches, int k, const oclMat &mask = oclMat(),
1243                           bool compactResult = false);
1244
1245             // Find k best matches from train collection for each query descriptor (in increasing order of distances)
1246             void knnMatch2Collection(const oclMat &query, const oclMat &trainCollection,
1247                                      oclMat &trainIdx, oclMat &imgIdx, oclMat &distance,
1248                                      const oclMat &maskCollection = oclMat());
1249
1250             // Download trainIdx and distance and convert it to vector with DMatch
1251             // compactResult is used when mask is not empty. If compactResult is false matches
1252             // vector will have the same size as queryDescriptors rows. If compactResult is true
1253             // matches vector will not contain matches for fully masked out query descriptors.
1254             static void knnMatch2Download(const oclMat &trainIdx, const oclMat &imgIdx, const oclMat &distance,
1255                                           std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1256
1257             // Convert trainIdx and distance to vector with DMatch
1258             static void knnMatch2Convert(const Mat &trainIdx, const Mat &imgIdx, const Mat &distance,
1259                                          std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1260
1261             // Find k best matches  for each query descriptor (in increasing order of distances).
1262             // compactResult is used when mask is not empty. If compactResult is false matches
1263             // vector will have the same size as queryDescriptors rows. If compactResult is true
1264             // matches vector will not contain matches for fully masked out query descriptors.
1265             void knnMatch(const oclMat &query, std::vector< std::vector<DMatch> > &matches, int k,
1266                           const std::vector<oclMat> &masks = std::vector<oclMat>(), bool compactResult = false);
1267
1268             // Find best matches for each query descriptor which have distance less than maxDistance.
1269             // nMatches.at<int>(0, queryIdx) will contain matches count for queryIdx.
1270             // carefully nMatches can be greater than trainIdx.cols - it means that matcher didn't find all matches,
1271             // because it didn't have enough memory.
1272             // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nTrain / 100), 10),
1273             // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
1274             // Matches doesn't sorted.
1275             void radiusMatchSingle(const oclMat &query, const oclMat &train,
1276                                    oclMat &trainIdx, oclMat &distance, oclMat &nMatches, float maxDistance,
1277                                    const oclMat &mask = oclMat());
1278
1279             // Download trainIdx, nMatches and distance and convert it to vector with DMatch.
1280             // matches will be sorted in increasing order of distances.
1281             // compactResult is used when mask is not empty. If compactResult is false matches
1282             // vector will have the same size as queryDescriptors rows. If compactResult is true
1283             // matches vector will not contain matches for fully masked out query descriptors.
1284             static void radiusMatchDownload(const oclMat &trainIdx, const oclMat &distance, const oclMat &nMatches,
1285                                             std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1286             // Convert trainIdx, nMatches and distance to vector with DMatch.
1287             static void radiusMatchConvert(const Mat &trainIdx, const Mat &distance, const Mat &nMatches,
1288                                            std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1289             // Find best matches for each query descriptor which have distance less than maxDistance
1290             // in increasing order of distances).
1291             void radiusMatch(const oclMat &query, const oclMat &train,
1292                              std::vector< std::vector<DMatch> > &matches, float maxDistance,
1293                              const oclMat &mask = oclMat(), bool compactResult = false);
1294             // Find best matches for each query descriptor which have distance less than maxDistance.
1295             // If trainIdx is empty, then trainIdx and distance will be created with size nQuery x max((nQuery / 100), 10),
1296             // otherwize user can pass own allocated trainIdx and distance with size nQuery x nMaxMatches
1297             // Matches doesn't sorted.
1298             void radiusMatchCollection(const oclMat &query, oclMat &trainIdx, oclMat &imgIdx, oclMat &distance, oclMat &nMatches, float maxDistance,
1299                                        const std::vector<oclMat> &masks = std::vector<oclMat>());
1300             // Download trainIdx, imgIdx, nMatches and distance and convert it to vector with DMatch.
1301             // matches will be sorted in increasing order of distances.
1302             // compactResult is used when mask is not empty. If compactResult is false matches
1303             // vector will have the same size as queryDescriptors rows. If compactResult is true
1304             // matches vector will not contain matches for fully masked out query descriptors.
1305             static void radiusMatchDownload(const oclMat &trainIdx, const oclMat &imgIdx, const oclMat &distance, const oclMat &nMatches,
1306                                             std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1307             // Convert trainIdx, nMatches and distance to vector with DMatch.
1308             static void radiusMatchConvert(const Mat &trainIdx, const Mat &imgIdx, const Mat &distance, const Mat &nMatches,
1309                                            std::vector< std::vector<DMatch> > &matches, bool compactResult = false);
1310             // Find best matches from train collection for each query descriptor which have distance less than
1311             // maxDistance (in increasing order of distances).
1312             void radiusMatch(const oclMat &query, std::vector< std::vector<DMatch> > &matches, float maxDistance,
1313                              const std::vector<oclMat> &masks = std::vector<oclMat>(), bool compactResult = false);
1314             DistType distType;
1315         private:
1316             std::vector<oclMat> trainDescCollection;
1317         };
1318
1319         template <class Distance>
1320         class CV_EXPORTS BruteForceMatcher_OCL;
1321
1322         template <typename T>
1323         class CV_EXPORTS BruteForceMatcher_OCL< L1<T> > : public BruteForceMatcher_OCL_base
1324         {
1325         public:
1326             explicit BruteForceMatcher_OCL() : BruteForceMatcher_OCL_base(L1Dist) {}
1327             explicit BruteForceMatcher_OCL(L1<T> /*d*/) : BruteForceMatcher_OCL_base(L1Dist) {}
1328         };
1329
1330         template <typename T>
1331         class CV_EXPORTS BruteForceMatcher_OCL< L2<T> > : public BruteForceMatcher_OCL_base
1332         {
1333         public:
1334             explicit BruteForceMatcher_OCL() : BruteForceMatcher_OCL_base(L2Dist) {}
1335             explicit BruteForceMatcher_OCL(L2<T> /*d*/) : BruteForceMatcher_OCL_base(L2Dist) {}
1336         };
1337
1338         template <> class CV_EXPORTS BruteForceMatcher_OCL< Hamming > : public BruteForceMatcher_OCL_base
1339         {
1340         public:
1341             explicit BruteForceMatcher_OCL() : BruteForceMatcher_OCL_base(HammingDist) {}
1342             explicit BruteForceMatcher_OCL(Hamming /*d*/) : BruteForceMatcher_OCL_base(HammingDist) {}
1343         };
1344
1345         class CV_EXPORTS BFMatcher_OCL : public BruteForceMatcher_OCL_base
1346         {
1347         public:
1348             explicit BFMatcher_OCL(int norm = NORM_L2) : BruteForceMatcher_OCL_base(norm == NORM_L1 ? L1Dist : norm == NORM_L2 ? L2Dist : HammingDist) {}
1349         };
1350
1351         class CV_EXPORTS GoodFeaturesToTrackDetector_OCL
1352         {
1353         public:
1354             explicit GoodFeaturesToTrackDetector_OCL(int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 0.0,
1355                 int blockSize = 3, bool useHarrisDetector = false, double harrisK = 0.04);
1356
1357             //! return 1 rows matrix with CV_32FC2 type
1358             void operator ()(const oclMat& image, oclMat& corners, const oclMat& mask = oclMat());
1359             //! download points of type Point2f to a vector. the vector's content will be erased
1360             void downloadPoints(const oclMat &points, vector<Point2f> &points_v);
1361
1362             int maxCorners;
1363             double qualityLevel;
1364             double minDistance;
1365
1366             int blockSize;
1367             bool useHarrisDetector;
1368             double harrisK;
1369             void releaseMemory()
1370             {
1371                 Dx_.release();
1372                 Dy_.release();
1373                 eig_.release();
1374                 minMaxbuf_.release();
1375                 tmpCorners_.release();
1376             }
1377         private:
1378             oclMat Dx_;
1379             oclMat Dy_;
1380             oclMat eig_;
1381             oclMat minMaxbuf_;
1382             oclMat tmpCorners_;
1383         };
1384
1385         inline GoodFeaturesToTrackDetector_OCL::GoodFeaturesToTrackDetector_OCL(int maxCorners_, double qualityLevel_, double minDistance_,
1386             int blockSize_, bool useHarrisDetector_, double harrisK_)
1387         {
1388             maxCorners = maxCorners_;
1389             qualityLevel = qualityLevel_;
1390             minDistance = minDistance_;
1391             blockSize = blockSize_;
1392             useHarrisDetector = useHarrisDetector_;
1393             harrisK = harrisK_;
1394         }
1395
1396         /////////////////////////////// PyrLKOpticalFlow /////////////////////////////////////
1397         class CV_EXPORTS PyrLKOpticalFlow
1398         {
1399         public:
1400             PyrLKOpticalFlow()
1401             {
1402                 winSize = Size(21, 21);
1403                 maxLevel = 3;
1404                 iters = 30;
1405                 derivLambda = 0.5;
1406                 useInitialFlow = false;
1407                 minEigThreshold = 1e-4f;
1408                 getMinEigenVals = false;
1409                 isDeviceArch11_ = false;
1410             }
1411
1412             void sparse(const oclMat &prevImg, const oclMat &nextImg, const oclMat &prevPts, oclMat &nextPts,
1413                         oclMat &status, oclMat *err = 0);
1414             void dense(const oclMat &prevImg, const oclMat &nextImg, oclMat &u, oclMat &v, oclMat *err = 0);
1415             Size winSize;
1416             int maxLevel;
1417             int iters;
1418             double derivLambda;
1419             bool useInitialFlow;
1420             float minEigThreshold;
1421             bool getMinEigenVals;
1422             void releaseMemory()
1423             {
1424                 dx_calcBuf_.release();
1425                 dy_calcBuf_.release();
1426
1427                 prevPyr_.clear();
1428                 nextPyr_.clear();
1429
1430                 dx_buf_.release();
1431                 dy_buf_.release();
1432             }
1433         private:
1434             void calcSharrDeriv(const oclMat &src, oclMat &dx, oclMat &dy);
1435             void buildImagePyramid(const oclMat &img0, vector<oclMat> &pyr, bool withBorder);
1436
1437             oclMat dx_calcBuf_;
1438             oclMat dy_calcBuf_;
1439
1440             vector<oclMat> prevPyr_;
1441             vector<oclMat> nextPyr_;
1442
1443             oclMat dx_buf_;
1444             oclMat dy_buf_;
1445             oclMat uPyr_[2];
1446             oclMat vPyr_[2];
1447             bool isDeviceArch11_;
1448         };
1449
1450         class CV_EXPORTS FarnebackOpticalFlow
1451         {
1452         public:
1453             FarnebackOpticalFlow();
1454
1455             int numLevels;
1456             double pyrScale;
1457             bool fastPyramids;
1458             int winSize;
1459             int numIters;
1460             int polyN;
1461             double polySigma;
1462             int flags;
1463
1464             void operator ()(const oclMat &frame0, const oclMat &frame1, oclMat &flowx, oclMat &flowy);
1465
1466             void releaseMemory();
1467
1468         private:
1469             void prepareGaussian(
1470                 int n, double sigma, float *g, float *xg, float *xxg,
1471                 double &ig11, double &ig03, double &ig33, double &ig55);
1472
1473             void setPolynomialExpansionConsts(int n, double sigma);
1474
1475             void updateFlow_boxFilter(
1476                 const oclMat& R0, const oclMat& R1, oclMat& flowx, oclMat &flowy,
1477                 oclMat& M, oclMat &bufM, int blockSize, bool updateMatrices);
1478
1479             void updateFlow_gaussianBlur(
1480                 const oclMat& R0, const oclMat& R1, oclMat& flowx, oclMat& flowy,
1481                 oclMat& M, oclMat &bufM, int blockSize, bool updateMatrices);
1482
1483             oclMat frames_[2];
1484             oclMat pyrLevel_[2], M_, bufM_, R_[2], blurredFrame_[2];
1485             std::vector<oclMat> pyramid0_, pyramid1_;
1486         };
1487
1488         //////////////// build warping maps ////////////////////
1489         //! builds plane warping maps
1490         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);
1491         //! builds cylindrical warping maps
1492         CV_EXPORTS void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale, oclMat &map_x, oclMat &map_y);
1493         //! builds spherical warping maps
1494         CV_EXPORTS void buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale, oclMat &map_x, oclMat &map_y);
1495         //! builds Affine warping maps
1496         CV_EXPORTS void buildWarpAffineMaps(const Mat &M, bool inverse, Size dsize, oclMat &xmap, oclMat &ymap);
1497
1498         //! builds Perspective warping maps
1499         CV_EXPORTS void buildWarpPerspectiveMaps(const Mat &M, bool inverse, Size dsize, oclMat &xmap, oclMat &ymap);
1500
1501         ///////////////////////////////////// interpolate frames //////////////////////////////////////////////
1502         //! Interpolate frames (images) using provided optical flow (displacement field).
1503         //! frame0   - frame 0 (32-bit floating point images, single channel)
1504         //! frame1   - frame 1 (the same type and size)
1505         //! fu       - forward horizontal displacement
1506         //! fv       - forward vertical displacement
1507         //! bu       - backward horizontal displacement
1508         //! bv       - backward vertical displacement
1509         //! pos      - new frame position
1510         //! newFrame - new frame
1511         //! buf      - temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 oclMat;
1512         //!            occlusion masks            0, occlusion masks            1,
1513         //!            interpolated forward flow  0, interpolated forward flow  1,
1514         //!            interpolated backward flow 0, interpolated backward flow 1
1515         //!
1516         CV_EXPORTS void interpolateFrames(const oclMat &frame0, const oclMat &frame1,
1517                                           const oclMat &fu, const oclMat &fv,
1518                                           const oclMat &bu, const oclMat &bv,
1519                                           float pos, oclMat &newFrame, oclMat &buf);
1520
1521         //! computes moments of the rasterized shape or a vector of points
1522         CV_EXPORTS Moments ocl_moments(InputArray _array, bool binaryImage);
1523
1524         class CV_EXPORTS StereoBM_OCL
1525         {
1526         public:
1527             enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 };
1528
1529             enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 };
1530
1531             //! the default constructor
1532             StereoBM_OCL();
1533             //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8.
1534             StereoBM_OCL(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ);
1535
1536             //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair
1537             //! Output disparity has CV_8U type.
1538             void operator() ( const oclMat &left, const oclMat &right, oclMat &disparity);
1539
1540             //! Some heuristics that tries to estmate
1541             // if current GPU will be faster then CPU in this algorithm.
1542             // It queries current active device.
1543             static bool checkIfGpuCallReasonable();
1544
1545             int preset;
1546             int ndisp;
1547             int winSize;
1548
1549             // If avergeTexThreshold  == 0 => post procesing is disabled
1550             // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image
1551             // SumOfHorizontalGradiensInWindow(x, y, winSize) < (winSize * winSize) * avergeTexThreshold
1552             // i.e. input left image is low textured.
1553             float avergeTexThreshold;
1554         private:
1555             oclMat minSSD, leBuf, riBuf;
1556         };
1557
1558         class CV_EXPORTS StereoBeliefPropagation
1559         {
1560         public:
1561             enum { DEFAULT_NDISP  = 64 };
1562             enum { DEFAULT_ITERS  = 5  };
1563             enum { DEFAULT_LEVELS = 5  };
1564             static void estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels);
1565             explicit StereoBeliefPropagation(int ndisp  = DEFAULT_NDISP,
1566                                              int iters  = DEFAULT_ITERS,
1567                                              int levels = DEFAULT_LEVELS,
1568                                              int msg_type = CV_16S);
1569             StereoBeliefPropagation(int ndisp, int iters, int levels,
1570                                     float max_data_term, float data_weight,
1571                                     float max_disc_term, float disc_single_jump,
1572                                     int msg_type = CV_32F);
1573             void operator()(const oclMat &left, const oclMat &right, oclMat &disparity);
1574             void operator()(const oclMat &data, oclMat &disparity);
1575             int ndisp;
1576             int iters;
1577             int levels;
1578             float max_data_term;
1579             float data_weight;
1580             float max_disc_term;
1581             float disc_single_jump;
1582             int msg_type;
1583         private:
1584             oclMat u, d, l, r, u2, d2, l2, r2;
1585             std::vector<oclMat> datas;
1586             oclMat out;
1587         };
1588
1589         class CV_EXPORTS StereoConstantSpaceBP
1590         {
1591         public:
1592             enum { DEFAULT_NDISP    = 128 };
1593             enum { DEFAULT_ITERS    = 8   };
1594             enum { DEFAULT_LEVELS   = 4   };
1595             enum { DEFAULT_NR_PLANE = 4   };
1596             static void estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels, int &nr_plane);
1597             explicit StereoConstantSpaceBP(
1598                 int ndisp    = DEFAULT_NDISP,
1599                 int iters    = DEFAULT_ITERS,
1600                 int levels   = DEFAULT_LEVELS,
1601                 int nr_plane = DEFAULT_NR_PLANE,
1602                 int msg_type = CV_32F);
1603             StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane,
1604                 float max_data_term, float data_weight, float max_disc_term, float disc_single_jump,
1605                 int min_disp_th = 0,
1606                 int msg_type = CV_32F);
1607             void operator()(const oclMat &left, const oclMat &right, oclMat &disparity);
1608             int ndisp;
1609             int iters;
1610             int levels;
1611             int nr_plane;
1612             float max_data_term;
1613             float data_weight;
1614             float max_disc_term;
1615             float disc_single_jump;
1616             int min_disp_th;
1617             int msg_type;
1618             bool use_local_init_data_cost;
1619         private:
1620             oclMat u[2], d[2], l[2], r[2];
1621             oclMat disp_selected_pyr[2];
1622             oclMat data_cost;
1623             oclMat data_cost_selected;
1624             oclMat temp;
1625             oclMat out;
1626         };
1627
1628         // Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
1629         //
1630         // see reference:
1631         //   [1] C. Zach, T. Pock and H. Bischof, "A Duality Based Approach for Realtime TV-L1 Optical Flow".
1632         //   [2] Javier Sanchez, Enric Meinhardt-Llopis and Gabriele Facciolo. "TV-L1 Optical Flow Estimation".
1633         class CV_EXPORTS OpticalFlowDual_TVL1_OCL
1634         {
1635         public:
1636             OpticalFlowDual_TVL1_OCL();
1637
1638             void operator ()(const oclMat& I0, const oclMat& I1, oclMat& flowx, oclMat& flowy);
1639
1640             void collectGarbage();
1641
1642             /**
1643             * Time step of the numerical scheme.
1644             */
1645             double tau;
1646
1647             /**
1648             * Weight parameter for the data term, attachment parameter.
1649             * This is the most relevant parameter, which determines the smoothness of the output.
1650             * The smaller this parameter is, the smoother the solutions we obtain.
1651             * It depends on the range of motions of the images, so its value should be adapted to each image sequence.
1652             */
1653             double lambda;
1654
1655             /**
1656             * Weight parameter for (u - v)^2, tightness parameter.
1657             * It serves as a link between the attachment and the regularization terms.
1658             * In theory, it should have a small value in order to maintain both parts in correspondence.
1659             * The method is stable for a large range of values of this parameter.
1660             */
1661             double theta;
1662
1663             /**
1664             * Number of scales used to create the pyramid of images.
1665             */
1666             int nscales;
1667
1668             /**
1669             * Number of warpings per scale.
1670             * Represents the number of times that I1(x+u0) and grad( I1(x+u0) ) are computed per scale.
1671             * This is a parameter that assures the stability of the method.
1672             * It also affects the running time, so it is a compromise between speed and accuracy.
1673             */
1674             int warps;
1675
1676             /**
1677             * Stopping criterion threshold used in the numerical scheme, which is a trade-off between precision and running time.
1678             * A small value will yield more accurate solutions at the expense of a slower convergence.
1679             */
1680             double epsilon;
1681
1682             /**
1683             * Stopping criterion iterations number used in the numerical scheme.
1684             */
1685             int iterations;
1686
1687             bool useInitialFlow;
1688
1689         private:
1690             void procOneScale(const oclMat& I0, const oclMat& I1, oclMat& u1, oclMat& u2);
1691
1692             std::vector<oclMat> I0s;
1693             std::vector<oclMat> I1s;
1694             std::vector<oclMat> u1s;
1695             std::vector<oclMat> u2s;
1696
1697             oclMat I1x_buf;
1698             oclMat I1y_buf;
1699
1700             oclMat I1w_buf;
1701             oclMat I1wx_buf;
1702             oclMat I1wy_buf;
1703
1704             oclMat grad_buf;
1705             oclMat rho_c_buf;
1706
1707             oclMat p11_buf;
1708             oclMat p12_buf;
1709             oclMat p21_buf;
1710             oclMat p22_buf;
1711
1712             oclMat diff_buf;
1713             oclMat norm_buf;
1714         };
1715         // current supported sorting methods
1716         enum
1717         {
1718             SORT_BITONIC,   // only support power-of-2 buffer size
1719             SORT_SELECTION, // cannot sort duplicate keys
1720             SORT_MERGE,
1721             SORT_RADIX      // only support signed int/float keys(CV_32S/CV_32F)
1722         };
1723         //! Returns the sorted result of all the elements in input based on equivalent keys.
1724         //
1725         //  The element unit in the values to be sorted is determined from the data type,
1726         //  i.e., a CV_32FC2 input {a1a2, b1b2} will be considered as two elements, regardless its
1727         //  matrix dimension.
1728         //  both keys and values will be sorted inplace
1729         //  Key needs to be single channel oclMat.
1730         //
1731         //  Example:
1732         //  input -
1733         //    keys   = {2,    3,   1}   (CV_8UC1)
1734         //    values = {10,5, 4,3, 6,2} (CV_8UC2)
1735         //  sortByKey(keys, values, SORT_SELECTION, false);
1736         //  output -
1737         //    keys   = {1,    2,   3}   (CV_8UC1)
1738         //    values = {6,2, 10,5, 4,3} (CV_8UC2)
1739         CV_EXPORTS void sortByKey(oclMat& keys, oclMat& values, int method, bool isGreaterThan = false);
1740         /*!Base class for MOG and MOG2!*/
1741         class CV_EXPORTS BackgroundSubtractor
1742         {
1743         public:
1744             //! the virtual destructor
1745             virtual ~BackgroundSubtractor();
1746             //! the update operator that takes the next video frame and returns the current foreground mask as 8-bit binary image.
1747             virtual void operator()(const oclMat& image, oclMat& fgmask, float learningRate);
1748
1749             //! computes a background image
1750             virtual void getBackgroundImage(oclMat& backgroundImage) const = 0;
1751         };
1752                 /*!
1753         Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm
1754
1755         The class implements the following algorithm:
1756         "An improved adaptive background mixture model for real-time tracking with shadow detection"
1757         P. KadewTraKuPong and R. Bowden,
1758         Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001."
1759         http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
1760         */
1761         class CV_EXPORTS MOG: public cv::ocl::BackgroundSubtractor
1762         {
1763         public:
1764             //! the default constructor
1765             MOG(int nmixtures = -1);
1766
1767             //! re-initiaization method
1768             void initialize(Size frameSize, int frameType);
1769
1770             //! the update operator
1771             void operator()(const oclMat& frame, oclMat& fgmask, float learningRate = 0.f);
1772
1773             //! computes a background image which are the mean of all background gaussians
1774             void getBackgroundImage(oclMat& backgroundImage) const;
1775
1776             //! releases all inner buffers
1777             void release();
1778
1779             int history;
1780             float varThreshold;
1781             float backgroundRatio;
1782             float noiseSigma;
1783
1784         private:
1785             int nmixtures_;
1786
1787             Size frameSize_;
1788             int frameType_;
1789             int nframes_;
1790
1791             oclMat weight_;
1792             oclMat sortKey_;
1793             oclMat mean_;
1794             oclMat var_;
1795         };
1796
1797         /*!
1798         The class implements the following algorithm:
1799         "Improved adaptive Gausian mixture model for background subtraction"
1800         Z.Zivkovic
1801         International Conference Pattern Recognition, UK, August, 2004.
1802         http://www.zoranz.net/Publications/zivkovic2004ICPR.pdf
1803         */
1804         class CV_EXPORTS MOG2: public cv::ocl::BackgroundSubtractor
1805         {
1806         public:
1807             //! the default constructor
1808             MOG2(int nmixtures = -1);
1809
1810             //! re-initiaization method
1811             void initialize(Size frameSize, int frameType);
1812
1813             //! the update operator
1814             void operator()(const oclMat& frame, oclMat& fgmask, float learningRate = -1.0f);
1815
1816             //! computes a background image which are the mean of all background gaussians
1817             void getBackgroundImage(oclMat& backgroundImage) const;
1818
1819             //! releases all inner buffers
1820             void release();
1821
1822             // parameters
1823             // you should call initialize after parameters changes
1824
1825             int history;
1826
1827             //! here it is the maximum allowed number of mixture components.
1828             //! Actual number is determined dynamically per pixel
1829             float varThreshold;
1830             // threshold on the squared Mahalanobis distance to decide if it is well described
1831             // by the background model or not. Related to Cthr from the paper.
1832             // This does not influence the update of the background. A typical value could be 4 sigma
1833             // and that is varThreshold=4*4=16; Corresponds to Tb in the paper.
1834
1835             /////////////////////////
1836             // less important parameters - things you might change but be carefull
1837             ////////////////////////
1838
1839             float backgroundRatio;
1840             // corresponds to fTB=1-cf from the paper
1841             // TB - threshold when the component becomes significant enough to be included into
1842             // the background model. It is the TB=1-cf from the paper. So I use cf=0.1 => TB=0.
1843             // For alpha=0.001 it means that the mode should exist for approximately 105 frames before
1844             // it is considered foreground
1845             // float noiseSigma;
1846             float varThresholdGen;
1847
1848             //correspondts to Tg - threshold on the squared Mahalan. dist. to decide
1849             //when a sample is close to the existing components. If it is not close
1850             //to any a new component will be generated. I use 3 sigma => Tg=3*3=9.
1851             //Smaller Tg leads to more generated components and higher Tg might make
1852             //lead to small number of components but they can grow too large
1853             float fVarInit;
1854             float fVarMin;
1855             float fVarMax;
1856
1857             //initial variance  for the newly generated components.
1858             //It will will influence the speed of adaptation. A good guess should be made.
1859             //A simple way is to estimate the typical standard deviation from the images.
1860             //I used here 10 as a reasonable value
1861             // min and max can be used to further control the variance
1862             float fCT; //CT - complexity reduction prior
1863             //this is related to the number of samples needed to accept that a component
1864             //actually exists. We use CT=0.05 of all the samples. By setting CT=0 you get
1865             //the standard Stauffer&Grimson algorithm (maybe not exact but very similar)
1866
1867             //shadow detection parameters
1868             bool bShadowDetection; //default 1 - do shadow detection
1869             unsigned char nShadowDetection; //do shadow detection - insert this value as the detection result - 127 default value
1870             float fTau;
1871             // Tau - shadow threshold. The shadow is detected if the pixel is darker
1872             //version of the background. Tau is a threshold on how much darker the shadow can be.
1873             //Tau= 0.5 means that if pixel is more than 2 times darker then it is not shadow
1874             //See: Prati,Mikic,Trivedi,Cucchiarra,"Detecting Moving Shadows...",IEEE PAMI,2003.
1875
1876         private:
1877             int nmixtures_;
1878
1879             Size frameSize_;
1880             int frameType_;
1881             int nframes_;
1882
1883             oclMat weight_;
1884             oclMat variance_;
1885             oclMat mean_;
1886
1887             oclMat bgmodelUsedModes_; //keep track of number of modes per pixel
1888         };
1889
1890         /*!***************Kalman Filter*************!*/
1891         class CV_EXPORTS KalmanFilter
1892         {
1893         public:
1894             KalmanFilter();
1895             //! the full constructor taking the dimensionality of the state, of the measurement and of the control vector
1896             KalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F);
1897             //! re-initializes Kalman filter. The previous content is destroyed.
1898             void init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F);
1899
1900             const oclMat& predict(const oclMat& control=oclMat());
1901             const oclMat& correct(const oclMat& measurement);
1902
1903             oclMat statePre;           //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
1904             oclMat statePost;          //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
1905             oclMat transitionMatrix;   //!< state transition matrix (A)
1906             oclMat controlMatrix;      //!< control matrix (B) (not used if there is no control)
1907             oclMat measurementMatrix;  //!< measurement matrix (H)
1908             oclMat processNoiseCov;    //!< process noise covariance matrix (Q)
1909             oclMat measurementNoiseCov;//!< measurement noise covariance matrix (R)
1910             oclMat errorCovPre;        //!< priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
1911             oclMat gain;               //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
1912             oclMat errorCovPost;       //!< posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
1913         private:
1914             oclMat temp1;
1915             oclMat temp2;
1916             oclMat temp3;
1917             oclMat temp4;
1918             oclMat temp5;
1919         };
1920
1921         /*!***************K Nearest Neighbour*************!*/
1922         class CV_EXPORTS KNearestNeighbour: public CvKNearest
1923         {
1924         public:
1925             KNearestNeighbour();
1926             ~KNearestNeighbour();
1927
1928             bool train(const Mat& trainData, Mat& labels, Mat& sampleIdx = Mat().setTo(Scalar::all(0)),
1929                 bool isRegression = false, int max_k = 32, bool updateBase = false);
1930
1931             void clear();
1932
1933             void find_nearest(const oclMat& samples, int k, oclMat& lables);
1934
1935         private:
1936             oclMat samples_ocl;
1937         };
1938
1939         /*!***************  SVM  *************!*/
1940         class CV_EXPORTS CvSVM_OCL : public CvSVM
1941         {
1942         public:
1943             CvSVM_OCL();
1944
1945             CvSVM_OCL(const cv::Mat& trainData, const cv::Mat& responses,
1946                       const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
1947                       CvSVMParams params=CvSVMParams());
1948             CV_WRAP float predict( const int row_index, Mat& src, bool returnDFVal=false ) const;
1949             CV_WRAP void predict( cv::InputArray samples, cv::OutputArray results ) const;
1950             CV_WRAP float predict( const cv::Mat& sample, bool returnDFVal=false ) const;
1951             float predict( const CvMat* samples, CV_OUT CvMat* results ) const;
1952
1953         protected:
1954             float predict( const int row_index, int row_len, Mat& src, bool returnDFVal=false ) const;
1955             void create_kernel();
1956             void create_solver();
1957         };
1958
1959         /*!***************  END  *************!*/
1960     }
1961 }
1962 #if defined _MSC_VER && _MSC_VER >= 1200
1963 #  pragma warning( push)
1964 #  pragma warning( disable: 4267)
1965 #endif
1966 #include "opencv2/ocl/matrix_operations.hpp"
1967 #if defined _MSC_VER && _MSC_VER >= 1200
1968 #  pragma warning( pop)
1969 #endif
1970
1971 #endif /* __OPENCV_OCL_HPP__ */