modules/ocl/test/test_imgproc.cpp

   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 // @Authors
  19 //    Niko Li, newlife20080214@gmail.com
  20 //    Jia Haipeng, jiahaipeng95@gmail.com
  21 //    Shengen Yan, yanshengen@gmail.com
  22 //    Jiang Liyuan, lyuan001.good@163.com
  23 //    Rock Li, Rock.Li@amd.com
  24 //    Wu Zailong, bullet@yeah.net
  25 //    Xu Pang, pangxu010@163.com
  26 //    Sen Liu, swjtuls1987@126.com
  27 //
  28 // Redistribution and use in source and binary forms, with or without modification,
  29 // are permitted provided that the following conditions are met:
  30 //
  31 //   * Redistribution's of source code must retain the above copyright notice,
  32 //     this list of conditions and the following disclaimer.
  33 //
  34 //   * Redistribution's in binary form must reproduce the above copyright notice,
  35 //     this list of conditions and the following disclaimer in the documentation
  36 //     and/or other oclMaterials provided with the distribution.
  37 //
  38 //   * The name of the copyright holders may not be used to endorse or promote products
  39 //     derived from this software without specific prior written permission.
  40 //
  41 // This software is provided by the copyright holders and contributors "as is" and
  42 // any express or implied warranties, including, but not limited to, the implied
  43 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  44 // In no event shall the Intel Corporation or contributors be liable for any direct,
  45 // indirect, incidental, special, exemplary, or consequential damages
  46 // (including, but not limited to, procurement of substitute goods or services;
  47 // loss of use, data, or profits; or business interruption) however caused
  48 // and on any theory of liability, whether in contract, strict liability,
  49 // or tort (including negligence or otherwise) arising in any way out of
  50 // the use of this software, even if advised of the possibility of such damage.
  51 //
  52 //M*/
  53
  54 #include "test_precomp.hpp"
  55
  56 #ifdef HAVE_OPENCL
  57
  58 using namespace cvtest;
  59 using namespace testing;
  60 using namespace std;
  61
  62 MatType nulltype = -1;
  63
  64 #define ONE_TYPE(type)  testing::ValuesIn(typeVector(type))
  65 #define NULL_TYPE  testing::ValuesIn(typeVector(nulltype))
  66
  67 vector<MatType> typeVector(MatType type)
  68 {
  69     vector<MatType> v;
  70     v.push_back(type);
  71     return v;
  72 }
  73
  74 typedef struct
  75 {
  76     short x;
  77     short y;
  78 } COOR;
  79
  80 COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, cv::Size size, int sp, int sr, int maxIter, float eps, int *tab)
  81 {
  82
  83     int isr2 = sr * sr;
  84     int c0, c1, c2, c3;
  85     int iter;
  86     uchar *ptr = NULL;
  87     uchar *pstart = NULL;
  88     int revx = 0, revy = 0;
  89     c0 = sptr[0];
  90     c1 = sptr[1];
  91     c2 = sptr[2];
  92     c3 = sptr[3];
  93     // iterate meanshift procedure
  94     for(iter = 0; iter < maxIter; iter++ )
  95     {
  96         int count = 0;
  97         int s0 = 0, s1 = 0, s2 = 0, sx = 0, sy = 0;
  98
  99         //mean shift: process pixels in window (p-sigmaSp)x(p+sigmaSp)
 100         int minx = x0 - sp;
 101         int miny = y0 - sp;
 102         int maxx = x0 + sp;
 103         int maxy = y0 + sp;
 104
 105         //deal with the image boundary
 106         if(minx < 0) minx = 0;
 107         if(miny < 0) miny = 0;
 108         if(maxx >= size.width) maxx = size.width - 1;
 109         if(maxy >= size.height) maxy = size.height - 1;
 110         if(iter == 0)
 111         {
 112             pstart = sptr;
 113         }
 114         else
 115         {
 116             pstart = pstart + revy * sstep + (revx << 2); //point to the new position
 117         }
 118         ptr = pstart;
 119         ptr = ptr + (miny - y0) * sstep + ((minx - x0) << 2); //point to the start in the row
 120
 121         for( int y = miny; y <= maxy; y++, ptr += sstep - ((maxx - minx + 1) << 2))
 122         {
 123             int rowCount = 0;
 124             int x = minx;
 125 #if CV_ENABLE_UNROLLED
 126             for( ; x + 4 <= maxx; x += 4, ptr += 16)
 127             {
 128                 int t0, t1, t2;
 129                 t0 = ptr[0], t1 = ptr[1], t2 = ptr[2];
 130                 if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2)
 131                 {
 132                     s0 += t0;
 133                     s1 += t1;
 134                     s2 += t2;
 135                     sx += x;
 136                     rowCount++;
 137                 }
 138                 t0 = ptr[4], t1 = ptr[5], t2 = ptr[6];
 139                 if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2)
 140                 {
 141                     s0 += t0;
 142                     s1 += t1;
 143                     s2 += t2;
 144                     sx += x + 1;
 145                     rowCount++;
 146                 }
 147                 t0 = ptr[8], t1 = ptr[9], t2 = ptr[10];
 148                 if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2)
 149                 {
 150                     s0 += t0;
 151                     s1 += t1;
 152                     s2 += t2;
 153                     sx += x + 2;
 154                     rowCount++;
 155                 }
 156                 t0 = ptr[12], t1 = ptr[13], t2 = ptr[14];
 157                 if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2)
 158                 {
 159                     s0 += t0;
 160                     s1 += t1;
 161                     s2 += t2;
 162                     sx += x + 3;
 163                     rowCount++;
 164                 }
 165             }
 166 #endif
 167             for(; x <= maxx; x++, ptr += 4)
 168             {
 169                 int t0 = ptr[0], t1 = ptr[1], t2 = ptr[2];
 170                 if(tab[t0 - c0 + 255] + tab[t1 - c1 + 255] + tab[t2 - c2 + 255] <= isr2)
 171                 {
 172                     s0 += t0;
 173                     s1 += t1;
 174                     s2 += t2;
 175                     sx += x;
 176                     rowCount++;
 177                 }
 178             }
 179             if(rowCount == 0)
 180                 continue;
 181             count += rowCount;
 182             sy += y * rowCount;
 183         }
 184
 185         if( count == 0 )
 186             break;
 187
 188         int x1 = sx / count;
 189         int y1 = sy / count;
 190         s0 = s0 / count;
 191         s1 = s1 / count;
 192         s2 = s2 / count;
 193
 194         bool stopFlag = (x0 == x1 && y0 == y1) || (abs(x1 - x0) + abs(y1 - y0) +
 195                         tab[s0 - c0 + 255] + tab[s1 - c1 + 255] + tab[s2 - c2 + 255] <= eps);
 196
 197         //revise the pointer corresponding to the new (y0,x0)
 198         revx = x1 - x0;
 199         revy = y1 - y0;
 200
 201         x0 = x1;
 202         y0 = y1;
 203         c0 = s0;
 204         c1 = s1;
 205         c2 = s2;
 206
 207         if( stopFlag )
 208             break;
 209     } //for iter
 210
 211     dptr[0] = (uchar)c0;
 212     dptr[1] = (uchar)c1;
 213     dptr[2] = (uchar)c2;
 214     dptr[3] = (uchar)c3;
 215
 216     COOR coor;
 217     coor.x = (short)x0;
 218     coor.y = (short)y0;
 219     return coor;
 220 }
 221
 222 void meanShiftFiltering_(const Mat &src_roi, Mat &dst_roi, int sp, int sr, cv::TermCriteria crit)
 223 {
 224     if( src_roi.empty() )
 225         CV_Error( CV_StsBadArg, "The input image is empty" );
 226
 227     if( src_roi.depth() != CV_8U || src_roi.channels() != 4 )
 228         CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" );
 229
 230     CV_Assert( (src_roi.cols == dst_roi.cols) && (src_roi.rows == dst_roi.rows) );
 231     CV_Assert( !(dst_roi.step & 0x3) );
 232
 233     if( !(crit.type & cv::TermCriteria::MAX_ITER) )
 234         crit.maxCount = 5;
 235     int maxIter = std::min(std::max(crit.maxCount, 1), 100);
 236     float eps;
 237     if( !(crit.type & cv::TermCriteria::EPS) )
 238         eps = 1.f;
 239     eps = (float)std::max(crit.epsilon, 0.0);
 240
 241     int tab[512];
 242     for(int i = 0; i < 512; i++)
 243         tab[i] = (i - 255) * (i - 255);
 244     uchar *sptr = src_roi.data;
 245     uchar *dptr = dst_roi.data;
 246     int sstep = (int)src_roi.step;
 247     int dstep = (int)dst_roi.step;
 248     cv::Size size = src_roi.size();
 249
 250     for(int i = 0; i < size.height; i++, sptr += sstep - (size.width << 2),
 251             dptr += dstep - (size.width << 2))
 252     {
 253         for(int j = 0; j < size.width; j++, sptr += 4, dptr += 4)
 254         {
 255             do_meanShift(j, i, sptr, dptr, sstep, size, sp, sr, maxIter, eps, tab);
 256         }
 257     }
 258 }
 259
 260 void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, int sp, int sr, cv::TermCriteria crit)
 261 {
 262
 263     if( src_roi.empty() )
 264         CV_Error( CV_StsBadArg, "The input image is empty" );
 265     if( src_roi.depth() != CV_8U || src_roi.channels() != 4 )
 266         CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" );
 267     CV_Assert( (src_roi.cols == dst_roi.cols) && (src_roi.rows == dst_roi.rows) &&
 268                (src_roi.cols == dstCoor_roi.cols) && (src_roi.rows == dstCoor_roi.rows));
 269     CV_Assert( !(dstCoor_roi.step & 0x3) );
 270
 271     if( !(crit.type & cv::TermCriteria::MAX_ITER) )
 272         crit.maxCount = 5;
 273     int maxIter = std::min(std::max(crit.maxCount, 1), 100);
 274     float eps;
 275     if( !(crit.type & cv::TermCriteria::EPS) )
 276         eps = 1.f;
 277     eps = (float)std::max(crit.epsilon, 0.0);
 278
 279     int tab[512];
 280     for(int i = 0; i < 512; i++)
 281         tab[i] = (i - 255) * (i - 255);
 282     uchar *sptr = src_roi.data;
 283     uchar *dptr = dst_roi.data;
 284     short *dCoorptr = (short *)dstCoor_roi.data;
 285     int sstep = (int)src_roi.step;
 286     int dstep = (int)dst_roi.step;
 287     int dCoorstep = (int)dstCoor_roi.step >> 1;
 288     cv::Size size = src_roi.size();
 289
 290     for(int i = 0; i < size.height; i++, sptr += sstep - (size.width << 2),
 291             dptr += dstep - (size.width << 2), dCoorptr += dCoorstep - (size.width << 1))
 292     {
 293         for(int j = 0; j < size.width; j++, sptr += 4, dptr += 4, dCoorptr += 2)
 294         {
 295             *((COOR *)dCoorptr) = do_meanShift(j, i, sptr, dptr, sstep, size, sp, sr, maxIter, eps, tab);
 296         }
 297     }
 298
 299 }
 300
 301 PARAM_TEST_CASE(ImgprocTestBase, MatType, MatType, MatType, MatType, MatType, bool)
 302 {
 303     int type1, type2, type3, type4, type5;
 304     cv::Scalar val;
 305     // set up roi
 306     int roicols;
 307     int roirows;
 308     int src1x;
 309     int src1y;
 310     int src2x;
 311     int src2y;
 312     int dstx;
 313     int dsty;
 314     int dst1x;
 315     int dst1y;
 316     int maskx;
 317     int masky;
 318
 319     //mat
 320     cv::Mat mat1;
 321     cv::Mat mat2;
 322     cv::Mat mask;
 323     cv::Mat dst;
 324     cv::Mat dst1; //bak, for two outputs
 325
 326     //mat with roi
 327     cv::Mat mat1_roi;
 328     cv::Mat mat2_roi;
 329     cv::Mat mask_roi;
 330     cv::Mat dst_roi;
 331     cv::Mat dst1_roi; //bak
 332
 333     //ocl mat
 334     cv::ocl::oclMat clmat1;
 335     cv::ocl::oclMat clmat2;
 336     cv::ocl::oclMat clmask;
 337     cv::ocl::oclMat cldst;
 338     cv::ocl::oclMat cldst1; //bak
 339
 340     //ocl mat with roi
 341     cv::ocl::oclMat clmat1_roi;
 342     cv::ocl::oclMat clmat2_roi;
 343     cv::ocl::oclMat clmask_roi;
 344     cv::ocl::oclMat cldst_roi;
 345     cv::ocl::oclMat cldst1_roi;
 346
 347     virtual void SetUp()
 348     {
 349         type1 = GET_PARAM(0);
 350         type2 = GET_PARAM(1);
 351         type3 = GET_PARAM(2);
 352         type4 = GET_PARAM(3);
 353         type5 = GET_PARAM(4);
 354         cv::Size size(MWIDTH, MHEIGHT);
 355         double min = 1, max = 20;
 356
 357         if(type1 != nulltype)
 358         {
 359             mat1 = randomMat(size, type1, min, max, false);
 360             clmat1 = mat1;
 361         }
 362         if(type2 != nulltype)
 363         {
 364             mat2 = randomMat(size, type2, min, max, false);
 365             clmat2 = mat2;
 366         }
 367         if(type3 != nulltype)
 368         {
 369             dst  = randomMat(size, type3, min, max, false);
 370             cldst = dst;
 371         }
 372         if(type4 != nulltype)
 373         {
 374             dst1 = randomMat(size, type4, min, max, false);
 375             cldst1 = dst1;
 376         }
 377         if(type5 != nulltype)
 378         {
 379             mask = randomMat(size, CV_8UC1, 0, 2,  false);
 380             cv::threshold(mask, mask, 0.5, 255., type5);
 381             clmask = mask;
 382         }
 383         val = cv::Scalar(rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0));
 384     }
 385
 386     void random_roi()
 387     {
 388 #ifdef RANDOMROI
 389         //randomize ROI
 390         roicols = rng.uniform(1, mat1.cols);
 391         roirows = rng.uniform(1, mat1.rows);
 392         src1x   = rng.uniform(0, mat1.cols - roicols);
 393         src1y   = rng.uniform(0, mat1.rows - roirows);
 394         src2x   = rng.uniform(0, mat2.cols - roicols);
 395         src2y   = rng.uniform(0, mat2.rows - roirows);
 396         dstx    = rng.uniform(0, dst.cols  - roicols);
 397         dsty    = rng.uniform(0, dst.rows  - roirows);
 398         dst1x    = rng.uniform(0, dst1.cols  - roicols);
 399         dst1y    = rng.uniform(0, dst1.rows  - roirows);
 400         maskx   = rng.uniform(0, mask.cols - roicols);
 401         masky   = rng.uniform(0, mask.rows - roirows);
 402 #else
 403         roicols = mat1.cols;
 404         roirows = mat1.rows;
 405         src1x = 0;
 406         src1y = 0;
 407         src2x = 0;
 408         src2y = 0;
 409         dstx = 0;
 410         dsty = 0;
 411         dst1x = 0;
 412         dst1y = 0;
 413         maskx = 0;
 414         masky = 0;
 415 #endif
 416
 417
 418         if(type1 != nulltype)
 419         {
 420             mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 421             clmat1_roi = clmat1(Rect(src1x, src1y, roicols, roirows));
 422         }
 423         if(type2 != nulltype)
 424         {
 425             mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows));
 426             clmat2_roi = clmat2(Rect(src2x, src2y, roicols, roirows));
 427         }
 428         if(type3 != nulltype)
 429         {
 430             dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 431             cldst_roi = cldst(Rect(dstx, dsty, roicols, roirows));
 432         }
 433         if(type4 != nulltype)
 434         {
 435             dst1_roi = dst1(Rect(dst1x, dst1y, roicols, roirows));
 436             cldst1_roi = cldst1(Rect(dst1x, dst1y, roicols, roirows));
 437         }
 438         if(type5 != nulltype)
 439         {
 440             mask_roi = mask(Rect(maskx, masky, roicols, roirows));
 441             clmask_roi = clmask(Rect(maskx, masky, roicols, roirows));
 442         }
 443     }
 444
 445     void Near(double threshold)
 446     {
 447         cv::Mat cpu_cldst;
 448         cldst.download(cpu_cldst);
 449         EXPECT_MAT_NEAR(dst, cpu_cldst, threshold);
 450     }
 451 };
 452 ////////////////////////////////equalizeHist//////////////////////////////////////////
 453
 454 struct equalizeHist : ImgprocTestBase {};
 455
 456 OCL_TEST_P(equalizeHist, Mat)
 457 {
 458     if (mat1.type() != CV_8UC1 || mat1.type() != dst.type())
 459     {
 460         cout << "Unsupported type" << endl;
 461         EXPECT_DOUBLE_EQ(0.0, 0.0);
 462     }
 463     else
 464     {
 465         for(int j = 0; j < LOOP_TIMES; j++)
 466         {
 467             random_roi();
 468             cv::equalizeHist(mat1_roi, dst_roi);
 469             cv::ocl::equalizeHist(clmat1_roi, cldst_roi);
 470             Near(1.1);
 471         }
 472     }
 473 }
 474
 475
 476 ////////////////////////////////copyMakeBorder////////////////////////////////////////////
 477
 478 struct CopyMakeBorder : ImgprocTestBase {};
 479
 480 OCL_TEST_P(CopyMakeBorder, Mat)
 481 {
 482     int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE, cv::BORDER_REFLECT, cv::BORDER_WRAP, cv::BORDER_REFLECT_101};
 483     int top = rng.uniform(0, 10);
 484     int bottom = rng.uniform(0, 10);
 485     int left = rng.uniform(0, 10);
 486     int right = rng.uniform(0, 10);
 487     if (mat1.type() != dst.type())
 488     {
 489         cout << "Unsupported type" << endl;
 490         EXPECT_DOUBLE_EQ(0.0, 0.0);
 491     }
 492     else
 493     {
 494         for(size_t i = 0; i < sizeof(bordertype) / sizeof(int); i++)
 495             for(int j = 0; j < LOOP_TIMES; j++)
 496             {
 497                 random_roi();
 498 #ifdef RANDOMROI
 499                 if(((bordertype[i] != cv::BORDER_CONSTANT) && (bordertype[i] != cv::BORDER_REPLICATE)) && (mat1_roi.cols <= left) || (mat1_roi.cols <= right) || (mat1_roi.rows <= top) || (mat1_roi.rows <= bottom))
 500                 {
 501                     continue;
 502                 }
 503                 if((dstx >= left) && (dsty >= top) && (dstx + cldst_roi.cols + right <= cldst_roi.wholecols) && (dsty + cldst_roi.rows + bottom <= cldst_roi.wholerows))
 504                 {
 505                     dst_roi.adjustROI(top, bottom, left, right);
 506                     cldst_roi.adjustROI(top, bottom, left, right);
 507                 }
 508                 else
 509                 {
 510                     continue;
 511                 }
 512 #endif
 513                 cv::copyMakeBorder(mat1_roi, dst_roi, top, bottom, left, right, bordertype[i] | cv::BORDER_ISOLATED, cv::Scalar(1.0));
 514                 cv::ocl::copyMakeBorder(clmat1_roi, cldst_roi, top, bottom, left, right,  bordertype[i] | cv::BORDER_ISOLATED, cv::Scalar(1.0));
 515
 516                 cv::Mat cpu_cldst;
 517 #ifndef RANDOMROI
 518                 cldst_roi.download(cpu_cldst);
 519                 EXPECT_MAT_NEAR(dst_roi, cpu_cldst, 0.0);
 520 #else
 521                 cldst.download(cpu_cldst);
 522                 EXPECT_MAT_NEAR(dst, cpu_cldst, 0.0);
 523 #endif
 524
 525             }
 526     }
 527 }
 528
 529
 530
 531 ////////////////////////////////cornerMinEigenVal//////////////////////////////////////////
 532
 533 struct cornerMinEigenVal : ImgprocTestBase {};
 534
 535 OCL_TEST_P(cornerMinEigenVal, Mat)
 536 {
 537     for(int j = 0; j < LOOP_TIMES; j++)
 538     {
 539
 540         random_roi();
 541         int blockSize = 3, apertureSize = 3;//1 + 2 * (rand() % 4);
 542         //int borderType = cv::BORDER_CONSTANT;
 543         //int borderType = cv::BORDER_REPLICATE;
 544         int borderType = cv::BORDER_REFLECT;
 545         cv::cornerMinEigenVal(mat1_roi, dst_roi, blockSize, apertureSize, borderType);
 546         cv::ocl::cornerMinEigenVal(clmat1_roi, cldst_roi, blockSize, apertureSize, borderType);
 547         Near(1.);
 548     }
 549 }
 550
 551
 552
 553 ////////////////////////////////cornerHarris//////////////////////////////////////////
 554
 555 struct cornerHarris : ImgprocTestBase {};
 556
 557 OCL_TEST_P(cornerHarris, Mat)
 558 {
 559     for(int j = 0; j < LOOP_TIMES; j++)
 560     {
 561
 562         random_roi();
 563         int blockSize = 3, apertureSize = 3; //1 + 2 * (rand() % 4);
 564         double k = 2;
 565         //int borderType = cv::BORDER_CONSTANT;
 566         //int borderType = cv::BORDER_REPLICATE;
 567         int borderType = cv::BORDER_REFLECT;
 568         cv::cornerHarris(mat1_roi, dst_roi, blockSize, apertureSize, k, borderType);
 569         cv::ocl::cornerHarris(clmat1_roi, cldst_roi, blockSize, apertureSize, k, borderType);
 570         Near(1.);
 571     }
 572 }
 573
 574
 575 ////////////////////////////////integral/////////////////////////////////////////////////
 576
 577 struct integral : ImgprocTestBase {};
 578
 579 OCL_TEST_P(integral, Mat1)
 580 {
 581     for(int j = 0; j < LOOP_TIMES; j++)
 582     {
 583         random_roi();
 584
 585         cv::ocl::integral(clmat1_roi, cldst_roi);
 586         cv::integral(mat1_roi, dst_roi);
 587         Near(0);
 588     }
 589 }
 590
 591 OCL_TEST_P(integral, Mat2)
 592 {
 593     for(int j = 0; j < LOOP_TIMES; j++)
 594     {
 595         random_roi();
 596
 597         cv::ocl::integral(clmat1_roi, cldst_roi, cldst1_roi);
 598         cv::integral(mat1_roi, dst_roi, dst1_roi);
 599         Near(0);
 600
 601         cv::Mat cpu_cldst1;
 602         cldst1.download(cpu_cldst1);
 603         EXPECT_MAT_NEAR(dst1, cpu_cldst1, 0.0);
 604     }
 605 }
 606
 607
 608 /////////////////////////////////////////////////////////////////////////////////////////////////
 609 // warpAffine  & warpPerspective
 610
 611 PARAM_TEST_CASE(WarpTestBase, MatType, int)
 612 {
 613     int type;
 614     cv::Size size;
 615     int interpolation;
 616
 617     //src mat
 618     cv::Mat mat1;
 619     cv::Mat dst;
 620
 621     // set up roi
 622     int src_roicols;
 623     int src_roirows;
 624     int dst_roicols;
 625     int dst_roirows;
 626     int src1x;
 627     int src1y;
 628     int dstx;
 629     int dsty;
 630
 631
 632     //src mat with roi
 633     cv::Mat mat1_roi;
 634     cv::Mat dst_roi;
 635
 636     //ocl dst mat for testing
 637     cv::ocl::oclMat gdst_whole;
 638
 639     //ocl mat with roi
 640     cv::ocl::oclMat gmat1;
 641     cv::ocl::oclMat gdst;
 642
 643     virtual void SetUp()
 644     {
 645         type = GET_PARAM(0);
 646         interpolation = GET_PARAM(1);
 647         size = cv::Size(MWIDTH, MHEIGHT);
 648
 649         mat1 = randomMat(size, type, 5, 16, false);
 650         dst  = randomMat(size, type, 5, 16, false);
 651     }
 652
 653     void random_roi()
 654     {
 655 #ifdef RANDOMROI
 656         //randomize ROI
 657         src_roicols = rng.uniform(1, mat1.cols);
 658         src_roirows = rng.uniform(1, mat1.rows);
 659         dst_roicols = rng.uniform(1, dst.cols);
 660         dst_roirows = rng.uniform(1, dst.rows);
 661         src1x   = rng.uniform(0, mat1.cols - src_roicols);
 662         src1y   = rng.uniform(0, mat1.rows - src_roirows);
 663         dstx    = rng.uniform(0, dst.cols  - dst_roicols);
 664         dsty    = rng.uniform(0, dst.rows  - dst_roirows);
 665 #else
 666         src_roicols = mat1.cols;
 667         src_roirows = mat1.rows;
 668         dst_roicols = dst.cols;
 669         dst_roirows = dst.rows;
 670         src1x   = 0;
 671         src1y   = 0;
 672         dstx    = 0;
 673         dsty    = 0;
 674 #endif
 675
 676
 677         mat1_roi = mat1(Rect(src1x, src1y, src_roicols, src_roirows));
 678         dst_roi  = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
 679
 680         gdst_whole = dst;
 681         gdst = gdst_whole(Rect(dstx, dsty, dst_roicols, dst_roirows));
 682
 683
 684         gmat1 = mat1_roi;
 685     }
 686
 687 };
 688
 689 /////warpAffine
 690
 691 struct WarpAffine : WarpTestBase {};
 692
 693 OCL_TEST_P(WarpAffine, Mat)
 694 {
 695     static const double coeffs[2][3] =
 696     {
 697         {cos(CV_PI / 6), -sin(CV_PI / 6), 100.0},
 698         {sin(CV_PI / 6), cos(CV_PI / 6), -100.0}
 699     };
 700     Mat M(2, 3, CV_64F, (void *)coeffs);
 701
 702     for(int j = 0; j < LOOP_TIMES; j++)
 703     {
 704         random_roi();
 705
 706         cv::warpAffine(mat1_roi, dst_roi, M, size, interpolation);
 707         cv::ocl::warpAffine(gmat1, gdst, M, size, interpolation);
 708
 709         cv::Mat cpu_dst;
 710         gdst_whole.download(cpu_dst);
 711         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
 712     }
 713
 714 }
 715
 716
 717 // warpPerspective
 718
 719 struct WarpPerspective : WarpTestBase {};
 720
 721 OCL_TEST_P(WarpPerspective, Mat)
 722 {
 723     static const double coeffs[3][3] =
 724     {
 725         {cos(3.14 / 6), -sin(3.14 / 6), 100.0},
 726         {sin(3.14 / 6), cos(3.14 / 6), -100.0},
 727         {0.0, 0.0, 1.0}
 728     };
 729     Mat M(3, 3, CV_64F, (void *)coeffs);
 730
 731     for(int j = 0; j < LOOP_TIMES; j++)
 732     {
 733         random_roi();
 734
 735         cv::warpPerspective(mat1_roi, dst_roi, M, size, interpolation);
 736         cv::ocl::warpPerspective(gmat1, gdst, M, size, interpolation);
 737
 738         cv::Mat cpu_dst;
 739         gdst_whole.download(cpu_dst);
 740         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
 741     }
 742
 743 }
 744
 745 /////////////////////////////////////////////////////////////////////////////////////////////////
 746 // remap
 747 //////////////////////////////////////////////////////////////////////////////////////////////////
 748
 749 PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int)
 750 {
 751     int srcType;
 752     int map1Type;
 753     int map2Type;
 754     cv::Scalar val;
 755
 756     int interpolation;
 757     int bordertype;
 758
 759     cv::Mat src;
 760     cv::Mat dst;
 761     cv::Mat map1;
 762     cv::Mat map2;
 763
 764     //std::vector<cv::ocl::Info> oclinfo;
 765
 766     int src_roicols;
 767     int src_roirows;
 768     int dst_roicols;
 769     int dst_roirows;
 770     int map1_roicols;
 771     int map1_roirows;
 772     int map2_roicols;
 773     int map2_roirows;
 774     int srcx;
 775     int srcy;
 776     int dstx;
 777     int dsty;
 778     int map1x;
 779     int map1y;
 780     int map2x;
 781     int map2y;
 782
 783     cv::Mat src_roi;
 784     cv::Mat dst_roi;
 785     cv::Mat map1_roi;
 786     cv::Mat map2_roi;
 787
 788     //ocl mat for testing
 789     cv::ocl::oclMat gdst;
 790
 791     //ocl mat with roi
 792     cv::ocl::oclMat gsrc_roi;
 793     cv::ocl::oclMat gdst_roi;
 794     cv::ocl::oclMat gmap1_roi;
 795     cv::ocl::oclMat gmap2_roi;
 796
 797     virtual void SetUp()
 798     {
 799         srcType = GET_PARAM(0);
 800         map1Type = GET_PARAM(1);
 801         map2Type = GET_PARAM(2);
 802         interpolation = GET_PARAM(3);
 803         bordertype = GET_PARAM(4);
 804
 805         cv::Size srcSize = cv::Size(MWIDTH, MHEIGHT);
 806         cv::Size map1Size = cv::Size(MWIDTH, MHEIGHT);
 807         double min = 5, max = 16;
 808
 809         if(srcType != nulltype)
 810         {
 811             src = randomMat(srcSize, srcType, min, max, false);
 812         }
 813         if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2 && map2Type == nulltype))
 814         {
 815             map1 = randomMat(map1Size, map1Type, min, max, false);
 816         }
 817         else if (map1Type == CV_32FC1 && map2Type == CV_32FC1)
 818         {
 819             map1 = randomMat(map1Size, map1Type, min, max, false);
 820             map2 = randomMat(map1Size, map1Type, min, max, false);
 821         }
 822
 823         else
 824         {
 825             cout << "The wrong input type" << endl;
 826             return;
 827         }
 828
 829         dst = randomMat(map1Size, srcType, min, max, false);
 830         switch (src.channels())
 831         {
 832         case 1:
 833             val = cv::Scalar(rng.uniform(0.0, 10.0), 0, 0, 0);
 834             break;
 835         case 2:
 836             val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0, 0);
 837             break;
 838         case 3:
 839             val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0);
 840             break;
 841         case 4:
 842             val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0));
 843             break;
 844         }
 845
 846     }
 847     void random_roi()
 848     {
 849         dst_roicols = rng.uniform(1, dst.cols);
 850         dst_roirows = rng.uniform(1, dst.rows);
 851
 852         src_roicols = rng.uniform(1, src.cols);
 853         src_roirows = rng.uniform(1, src.rows);
 854
 855
 856         srcx = rng.uniform(0, src.cols - src_roicols);
 857         srcy = rng.uniform(0, src.rows - src_roirows);
 858         dstx = rng.uniform(0, dst.cols - dst_roicols);
 859         dsty = rng.uniform(0, dst.rows - dst_roirows);
 860         map1_roicols = dst_roicols;
 861         map1_roirows = dst_roirows;
 862         map2_roicols = dst_roicols;
 863         map2_roirows = dst_roirows;
 864         map1x = dstx;
 865         map1y = dsty;
 866         map2x = dstx;
 867         map2y = dsty;
 868
 869         if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2 && map2Type == nulltype))
 870         {
 871             map1_roi = map1(Rect(map1x, map1y, map1_roicols, map1_roirows));
 872             gmap1_roi = map1_roi;
 873         }
 874
 875         else if (map1Type == CV_32FC1 && map2Type == CV_32FC1)
 876         {
 877             map1_roi = map1(Rect(map1x, map1y, map1_roicols, map1_roirows));
 878             gmap1_roi = map1_roi;
 879             map2_roi = map2(Rect(map2x, map2y, map2_roicols, map2_roirows));
 880             gmap2_roi = map2_roi;
 881         }
 882         src_roi = src(Rect(srcx, srcy, src_roicols, src_roirows));
 883         dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
 884         gsrc_roi = src_roi;
 885         gdst = dst;
 886         gdst_roi = gdst(Rect(dstx, dsty, dst_roicols, dst_roirows));
 887     }
 888 };
 889
 890 OCL_TEST_P(Remap, Mat)
 891 {
 892     if((interpolation == 1 && map1Type == CV_16SC2) || (map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1))
 893     {
 894         cout << "Don't support the dataType" << endl;
 895         return;
 896     }
 897     int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/};
 898
 899     for(int j = 0; j < LOOP_TIMES; j++)
 900     {
 901         random_roi();
 902         cv::remap(src_roi, dst_roi, map1_roi, map2_roi, interpolation, bordertype[0], val);
 903         cv::ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val);
 904         cv::Mat cpu_dst;
 905         gdst.download(cpu_dst);
 906
 907         if(interpolation == 0)
 908             EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
 909         EXPECT_MAT_NEAR(dst, cpu_dst, 2.0);
 910     }
 911 }
 912
 913
 914
 915 /////////////////////////////////////////////////////////////////////////////////////////////////
 916 // resize
 917
 918 PARAM_TEST_CASE(Resize, MatType, cv::Size, double, double, int)
 919 {
 920     int type;
 921     cv::Size dsize;
 922     double fx, fy;
 923     int interpolation;
 924
 925     //src mat
 926     cv::Mat mat1;
 927     cv::Mat dst;
 928
 929     // set up roi
 930     int src_roicols;
 931     int src_roirows;
 932     int dst_roicols;
 933     int dst_roirows;
 934     int src1x;
 935     int src1y;
 936     int dstx;
 937     int dsty;
 938
 939     //src mat with roi
 940     cv::Mat mat1_roi;
 941     cv::Mat dst_roi;
 942
 943     //ocl dst mat for testing
 944     cv::ocl::oclMat gdst_whole;
 945
 946     //ocl mat with roi
 947     cv::ocl::oclMat gmat1;
 948     cv::ocl::oclMat gdst;
 949
 950     virtual void SetUp()
 951     {
 952         type = GET_PARAM(0);
 953         dsize = GET_PARAM(1);
 954         fx = GET_PARAM(2);
 955         fy = GET_PARAM(3);
 956         interpolation = GET_PARAM(4);
 957
 958         cv::Size size(MWIDTH, MHEIGHT);
 959
 960         if(dsize == cv::Size() && !(fx > 0 && fy > 0))
 961         {
 962             cout << "invalid dsize and fx fy" << endl;
 963             return;
 964         }
 965
 966         if(dsize == cv::Size())
 967         {
 968             dsize.width = (int)(size.width * fx);
 969             dsize.height = (int)(size.height * fy);
 970         }
 971
 972         mat1 = randomMat(size, type, 5, 16, false);
 973         dst  = randomMat(dsize, type, 5, 16, false);
 974
 975     }
 976
 977     void random_roi()
 978     {
 979 #ifdef RANDOMROI
 980         //randomize ROI
 981         src_roicols = rng.uniform(1, mat1.cols);
 982         src_roirows = rng.uniform(1, mat1.rows);
 983         dst_roicols = (int)(src_roicols * fx);
 984         dst_roirows = (int)(src_roirows * fy);
 985         src1x   = rng.uniform(0, mat1.cols - src_roicols);
 986         src1y   = rng.uniform(0, mat1.rows - src_roirows);
 987         dstx    = rng.uniform(0, dst.cols  - dst_roicols);
 988         dsty    = rng.uniform(0, dst.rows  - dst_roirows);
 989 #else
 990         src_roicols = mat1.cols;
 991         src_roirows = mat1.rows;
 992         dst_roicols = dst.cols;
 993         dst_roirows = dst.rows;
 994         src1x   = 0;
 995         src1y   = 0;
 996         dstx    = 0;
 997         dsty    = 0;
 998 #endif
 999         dsize.width = dst_roicols;
1000         dsize.height = dst_roirows;
1001         mat1_roi = mat1(Rect(src1x, src1y, src_roicols, src_roirows));
1002         dst_roi  = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
1003
1004         gdst_whole = dst;
1005         gdst = gdst_whole(Rect(dstx, dsty, dst_roicols, dst_roirows));
1006
1007         dsize.width = (int)(mat1_roi.size().width * fx);
1008         dsize.height = (int)(mat1_roi.size().height * fy);
1009
1010         gmat1 = mat1_roi;
1011     }
1012
1013 };
1014
1015 OCL_TEST_P(Resize, Mat)
1016 {
1017     for(int j = 0; j < LOOP_TIMES; j++)
1018     {
1019         random_roi();
1020
1021         // cv::resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation);
1022         // cv::ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation);
1023         if(dst_roicols < 1 || dst_roirows < 1) continue;
1024         cv::resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation);
1025         cv::ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation);
1026
1027         cv::Mat cpu_dst;
1028         gdst_whole.download(cpu_dst);
1029         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
1030     }
1031
1032 }
1033
1034
1035 /////////////////////////////////////////////////////////////////////////////////////////////////
1036 //threshold
1037
1038 PARAM_TEST_CASE(Threshold, MatType, ThreshOp)
1039 {
1040     int type;
1041     int threshOp;
1042
1043     //src mat
1044     cv::Mat mat1;
1045     cv::Mat dst;
1046
1047     // set up roi
1048     int roicols;
1049     int roirows;
1050     int src1x;
1051     int src1y;
1052     int dstx;
1053     int dsty;
1054
1055     //src mat with roi
1056     cv::Mat mat1_roi;
1057     cv::Mat dst_roi;
1058
1059     //ocl dst mat for testing
1060     cv::ocl::oclMat gdst_whole;
1061
1062     //ocl mat with roi
1063     cv::ocl::oclMat gmat1;
1064     cv::ocl::oclMat gdst;
1065
1066     virtual void SetUp()
1067     {
1068         type = GET_PARAM(0);
1069         threshOp = GET_PARAM(1);
1070
1071         cv::Size size(MWIDTH, MHEIGHT);
1072
1073         mat1 = randomMat(size, type, 5, 16, false);
1074         dst  = randomMat(size, type, 5, 16, false);
1075     }
1076
1077     void random_roi()
1078     {
1079 #ifdef RANDOMROI
1080         //randomize ROI
1081         roicols = rng.uniform(1, mat1.cols);
1082         roirows = rng.uniform(1, mat1.rows);
1083         src1x   = rng.uniform(0, mat1.cols - roicols);
1084         src1y   = rng.uniform(0, mat1.rows - roirows);
1085         dstx    = rng.uniform(0, dst.cols  - roicols);
1086         dsty    = rng.uniform(0, dst.rows  - roirows);
1087 #else
1088         roicols = mat1.cols;
1089         roirows = mat1.rows;
1090         src1x   = 0;
1091         src1y   = 0;
1092         dstx    = 0;
1093         dsty    = 0;
1094 #endif
1095
1096         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
1097         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
1098
1099         gdst_whole = dst;
1100         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
1101
1102
1103         gmat1 = mat1_roi;
1104     }
1105
1106 };
1107
1108 OCL_TEST_P(Threshold, Mat)
1109 {
1110     for(int j = 0; j < LOOP_TIMES; j++)
1111     {
1112         random_roi();
1113         double maxVal = randomDouble(20.0, 127.0);
1114         double thresh = randomDouble(0.0, maxVal);
1115
1116         cv::threshold(mat1_roi, dst_roi, thresh, maxVal, threshOp);
1117         cv::ocl::threshold(gmat1, gdst, thresh, maxVal, threshOp);
1118
1119         cv::Mat cpu_dst;
1120         gdst_whole.download(cpu_dst);
1121         EXPECT_MAT_NEAR(dst, cpu_dst, 1);
1122     }
1123
1124 }
1125
1126 PARAM_TEST_CASE(meanShiftTestBase, MatType, MatType, int, int, cv::TermCriteria)
1127 {
1128     int type, typeCoor;
1129     int sp, sr;
1130     cv::TermCriteria crit;
1131     //src mat
1132     cv::Mat src;
1133     cv::Mat dst;
1134     cv::Mat dstCoor;
1135
1136     //set up roi
1137     int roicols;
1138     int roirows;
1139     int srcx;
1140     int srcy;
1141     int dstx;
1142     int dsty;
1143
1144     //src mat with roi
1145     cv::Mat src_roi;
1146     cv::Mat dst_roi;
1147     cv::Mat dstCoor_roi;
1148
1149     //ocl dst mat
1150     cv::ocl::oclMat gdst;
1151     cv::ocl::oclMat gdstCoor;
1152
1153     //ocl mat with roi
1154     cv::ocl::oclMat gsrc_roi;
1155     cv::ocl::oclMat gdst_roi;
1156     cv::ocl::oclMat gdstCoor_roi;
1157
1158     virtual void SetUp()
1159     {
1160         type     = GET_PARAM(0);
1161         typeCoor = GET_PARAM(1);
1162         sp       = GET_PARAM(2);
1163         sr       = GET_PARAM(3);
1164         crit     = GET_PARAM(4);
1165
1166         // MWIDTH=256, MHEIGHT=256. defined in utility.hpp
1167         cv::Size size = cv::Size(MWIDTH, MHEIGHT);
1168
1169         src = randomMat(size, type, 5, 16, false);
1170         dst = randomMat(size, type, 5, 16, false);
1171         dstCoor = randomMat(size, typeCoor, 5, 16, false);
1172
1173     }
1174
1175     void random_roi()
1176     {
1177 #ifdef RANDOMROI
1178         //randomize ROI
1179         roicols = rng.uniform(1, src.cols);
1180         roirows = rng.uniform(1, src.rows);
1181         srcx = rng.uniform(0, src.cols - roicols);
1182         srcy = rng.uniform(0, src.rows - roirows);
1183         dstx = rng.uniform(0, dst.cols - roicols);
1184         dsty = rng.uniform(0, dst.rows - roirows);
1185 #else
1186         roicols = src.cols;
1187         roirows = src.rows;
1188         srcx = 0;
1189         srcy = 0;
1190         dstx = 0;
1191         dsty = 0;
1192 #endif
1193         src_roi = src(Rect(srcx, srcy, roicols, roirows));
1194         dst_roi = dst(Rect(dstx, dsty, roicols, roirows));
1195         dstCoor_roi = dstCoor(Rect(dstx, dsty, roicols, roirows));
1196
1197         gdst = dst;
1198         gdstCoor = dstCoor;
1199
1200         gsrc_roi = src_roi;
1201         gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows));  //gdst_roi
1202         gdstCoor_roi = gdstCoor(Rect(dstx, dsty, roicols, roirows));
1203     }
1204 };
1205
1206 /////////////////////////meanShiftFiltering/////////////////////////////
1207 struct meanShiftFiltering : meanShiftTestBase {};
1208
1209 OCL_TEST_P(meanShiftFiltering, Mat)
1210 {
1211
1212     for(int j = 0; j < LOOP_TIMES; j++)
1213     {
1214         random_roi();
1215
1216         cv::Mat cpu_gdst;
1217         gdst.download(cpu_gdst);
1218
1219         meanShiftFiltering_(src_roi, dst_roi, sp, sr, crit);
1220         cv::ocl::meanShiftFiltering(gsrc_roi, gdst_roi, sp, sr, crit);
1221
1222         gdst.download(cpu_gdst);
1223         EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0);
1224     }
1225 }
1226
1227 ///////////////////////////meanShiftProc//////////////////////////////////
1228 struct meanShiftProc : meanShiftTestBase {};
1229
1230 OCL_TEST_P(meanShiftProc, Mat)
1231 {
1232
1233     for(int j = 0; j < LOOP_TIMES; j++)
1234     {
1235         random_roi();
1236
1237         cv::Mat cpu_gdst;
1238         cv::Mat cpu_gdstCoor;
1239
1240         meanShiftProc_(src_roi, dst_roi, dstCoor_roi, sp, sr, crit);
1241         cv::ocl::meanShiftProc(gsrc_roi, gdst_roi, gdstCoor_roi, sp, sr, crit);
1242
1243         gdst.download(cpu_gdst);
1244         gdstCoor.download(cpu_gdstCoor);
1245         EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0);
1246         EXPECT_MAT_NEAR(dstCoor, cpu_gdstCoor, 0.0);
1247     }
1248 }
1249
1250 ///////////////////////////////////////////////////////////////////////////////////////
1251 //hist
1252 void calcHistGold(const cv::Mat &src, cv::Mat &hist)
1253 {
1254     hist.create(1, 256, CV_32SC1);
1255     hist.setTo(cv::Scalar::all(0));
1256
1257     int *hist_row = hist.ptr<int>();
1258     for (int y = 0; y < src.rows; ++y)
1259     {
1260         const uchar *src_row = src.ptr(y);
1261
1262         for (int x = 0; x < src.cols; ++x)
1263             ++hist_row[src_row[x]];
1264     }
1265 }
1266
1267 PARAM_TEST_CASE(histTestBase, MatType, MatType)
1268 {
1269     int type_src;
1270
1271     //src mat
1272     cv::Mat src;
1273     cv::Mat dst_hist;
1274     //set up roi
1275     int roicols;
1276     int roirows;
1277     int srcx;
1278     int srcy;
1279     //src mat with roi
1280     cv::Mat src_roi;
1281     //ocl dst mat, dst_hist and gdst_hist don't have roi
1282     cv::ocl::oclMat gdst_hist;
1283     //ocl mat with roi
1284     cv::ocl::oclMat gsrc_roi;
1285
1286     virtual void SetUp()
1287     {
1288         type_src   = GET_PARAM(0);
1289
1290         cv::Size size = cv::Size(MWIDTH, MHEIGHT);
1291
1292         src = randomMat(size, type_src, 0, 256, false);
1293
1294     }
1295
1296     void random_roi()
1297     {
1298 #ifdef RANDOMROI
1299         //randomize ROI
1300         roicols = rng.uniform(1, src.cols);
1301         roirows = rng.uniform(1, src.rows);
1302         srcx = rng.uniform(0, src.cols - roicols);
1303         srcy = rng.uniform(0, src.rows - roirows);
1304 #else
1305         roicols = src.cols;
1306         roirows = src.rows;
1307         srcx = 0;
1308         srcy = 0;
1309 #endif
1310         src_roi = src(Rect(srcx, srcy, roicols, roirows));
1311
1312         gsrc_roi = src_roi;
1313     }
1314 };
1315 ///////////////////////////calcHist///////////////////////////////////////
1316 struct calcHist : histTestBase {};
1317
1318 OCL_TEST_P(calcHist, Mat)
1319 {
1320     for(int j = 0; j < LOOP_TIMES; j++)
1321     {
1322         random_roi();
1323
1324         cv::Mat cpu_hist;
1325
1326         calcHistGold(src_roi, dst_hist);
1327         cv::ocl::calcHist(gsrc_roi, gdst_hist);
1328
1329         gdst_hist.download(cpu_hist);
1330         EXPECT_MAT_NEAR(dst_hist, cpu_hist, 0.0);
1331     }
1332 }
1333 ///////////////////////////////////////////////////////////////////////////////////////////////////////
1334 // CLAHE
1335
1336 PARAM_TEST_CASE(CLAHE, cv::Size, double)
1337 {
1338     cv::Size gridSize;
1339     double clipLimit;
1340
1341     cv::Mat src;
1342     cv::Mat dst_gold;
1343
1344     cv::ocl::oclMat g_src;
1345     cv::ocl::oclMat g_dst;
1346
1347     virtual void SetUp()
1348     {
1349         gridSize = GET_PARAM(0);
1350         clipLimit = GET_PARAM(1);
1351
1352         src = randomMat(cv::Size(MWIDTH, MHEIGHT), CV_8UC1, 0, 256, false);
1353         g_src.upload(src);
1354     }
1355 };
1356
1357 OCL_TEST_P(CLAHE, Accuracy)
1358 {
1359     cv::Ptr<cv::CLAHE> clahe = cv::ocl::createCLAHE(clipLimit, gridSize);
1360     clahe->apply(g_src, g_dst);
1361     cv::Mat dst(g_dst);
1362
1363     cv::Ptr<cv::CLAHE> clahe_gold = cv::createCLAHE(clipLimit, gridSize);
1364     clahe_gold->apply(src, dst_gold);
1365
1366     EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
1367 }
1368
1369 ///////////////////////////Convolve//////////////////////////////////
1370 PARAM_TEST_CASE(ConvolveTestBase, MatType, bool)
1371 {
1372     int type;
1373     //src mat
1374     cv::Mat mat1;
1375     cv::Mat mat2;
1376     cv::Mat dst;
1377     cv::Mat dst1; //bak, for two outputs
1378     // set up roi
1379     int roicols;
1380     int roirows;
1381     int src1x;
1382     int src1y;
1383     int src2x;
1384     int src2y;
1385     int dstx;
1386     int dsty;
1387     //src mat with roi
1388     cv::Mat mat1_roi;
1389     cv::Mat mat2_roi;
1390     cv::Mat dst_roi;
1391     cv::Mat dst1_roi; //bak
1392     //ocl dst mat for testing
1393     cv::ocl::oclMat gdst_whole;
1394     cv::ocl::oclMat gdst1_whole; //bak
1395     //ocl mat with roi
1396     cv::ocl::oclMat gmat1;
1397     cv::ocl::oclMat gmat2;
1398     cv::ocl::oclMat gdst;
1399     cv::ocl::oclMat gdst1;   //bak
1400     virtual void SetUp()
1401     {
1402         type = GET_PARAM(0);
1403
1404         cv::Size size(MWIDTH, MHEIGHT);
1405
1406         mat1 = randomMat(size, type, 5, 16, false);
1407         mat2 = randomMat(size, type, 5, 16, false);
1408         dst  = randomMat(size, type, 5, 16, false);
1409         dst1  = randomMat(size, type, 5, 16, false);
1410     }
1411     void random_roi()
1412     {
1413 #ifdef RANDOMROI
1414         //randomize ROI
1415         roicols = rng.uniform(1, mat1.cols);
1416         roirows = rng.uniform(1, mat1.rows);
1417         src1x   = rng.uniform(0, mat1.cols - roicols);
1418         src1y   = rng.uniform(0, mat1.rows - roirows);
1419         dstx    = rng.uniform(0, dst.cols  - roicols);
1420         dsty    = rng.uniform(0, dst.rows  - roirows);
1421 #else
1422         roicols = mat1.cols;
1423         roirows = mat1.rows;
1424         src1x = 0;
1425         src1y = 0;
1426         dstx = 0;
1427         dsty = 0;
1428 #endif
1429         src2x   = rng.uniform(0, mat2.cols - roicols);
1430         src2y   = rng.uniform(0, mat2.rows - roirows);
1431         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
1432         mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows));
1433         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
1434         dst1_roi = dst1(Rect(dstx, dsty, roicols, roirows));
1435
1436         gdst_whole = dst;
1437         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
1438
1439         gdst1_whole = dst1;
1440         gdst1 = gdst1_whole(Rect(dstx, dsty, roicols, roirows));
1441
1442         gmat1 = mat1_roi;
1443         gmat2 = mat2_roi;
1444         //end
1445     }
1446
1447 };
1448 struct Convolve : ConvolveTestBase {};
1449
1450 void conv2( cv::Mat x, cv::Mat y, cv::Mat z)
1451 {
1452     int N1 = x.rows;
1453     int M1 = x.cols;
1454     int N2 = y.rows;
1455     int M2 = y.cols;
1456
1457     int i, j;
1458     int m, n;
1459
1460
1461     float *kerneldata = (float *)(x.data);
1462     float *srcdata = (float *)(y.data);
1463     float *dstdata = (float *)(z.data);
1464
1465     for(i = 0; i < N2; i++)
1466         for(j = 0; j < M2; j++)
1467         {
1468             float temp = 0;
1469             for(m = 0; m < N1; m++)
1470                 for(n = 0; n < M1; n++)
1471                 {
1472                     int r, c;
1473                     r = min(max((i - N1 / 2 + m), 0), N2 - 1);
1474                     c = min(max((j - M1 / 2 + n), 0), M2 - 1);
1475                     temp += kerneldata[m * (x.step >> 2) + n] * srcdata[r * (y.step >> 2) + c];
1476                 }
1477             dstdata[i * (z.step >> 2) + j] = temp;
1478         }
1479 }
1480 OCL_TEST_P(Convolve, Mat)
1481 {
1482     if(mat1.type() != CV_32FC1)
1483     {
1484         cout << "\tUnsupported type\t\n";
1485     }
1486     for(int j = 0; j < LOOP_TIMES; j++)
1487     {
1488         random_roi();
1489         cv::ocl::oclMat temp1;
1490         cv::Mat kernel_cpu = mat2(Rect(0, 0, 7, 7));
1491         temp1 = kernel_cpu;
1492
1493         conv2(kernel_cpu, mat1_roi, dst_roi);
1494         cv::ocl::convolve(gmat1, temp1, gdst);
1495
1496         cv::Mat cpu_dst;
1497         gdst_whole.download(cpu_dst);
1498         EXPECT_MAT_NEAR(dst, cpu_dst, .1);
1499
1500     }
1501 }
1502
1503 //////////////////////////////// ColumnSum //////////////////////////////////////
1504 PARAM_TEST_CASE(ColumnSum, cv::Size)
1505 {
1506     cv::Size size;
1507     cv::Mat src;
1508
1509     virtual void SetUp()
1510     {
1511         size = GET_PARAM(0);
1512     }
1513 };
1514
1515 OCL_TEST_P(ColumnSum, Accuracy)
1516 {
1517     cv::Mat src = randomMat(size, CV_32FC1, 0, 255);
1518     cv::ocl::oclMat d_dst;
1519     cv::ocl::oclMat d_src(src);
1520
1521     cv::ocl::columnSum(d_src, d_dst);
1522
1523     cv::Mat dst(d_dst);
1524
1525     for (int j = 0; j < src.cols; ++j)
1526     {
1527         float gold = src.at<float>(0, j);
1528         float res = dst.at<float>(0, j);
1529         ASSERT_NEAR(res, gold, 1e-5);
1530     }
1531
1532     for (int i = 1; i < src.rows; ++i)
1533     {
1534         for (int j = 0; j < src.cols; ++j)
1535         {
1536             float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
1537             float res = dst.at<float>(i, j);
1538             ASSERT_NEAR(res, gold, 1e-5);
1539         }
1540     }
1541 }
1542 /////////////////////////////////////////////////////////////////////////////////////
1543
1544 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, equalizeHist, Combine(
1545                             ONE_TYPE(CV_8UC1),
1546                             NULL_TYPE,
1547                             ONE_TYPE(CV_8UC1),
1548                             NULL_TYPE,
1549                             NULL_TYPE,
1550                             Values(false))); // Values(false) is the reserved parameter
1551
1552
1553 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CopyMakeBorder, Combine(
1554                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1555                             NULL_TYPE,
1556                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1557                             NULL_TYPE,
1558                             NULL_TYPE,
1559                             Values(false))); // Values(false) is the reserved parameter
1560
1561 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, cornerMinEigenVal, Combine(
1562                             Values(CV_8UC1, CV_32FC1),
1563                             NULL_TYPE,
1564                             ONE_TYPE(CV_32FC1),
1565                             NULL_TYPE,
1566                             NULL_TYPE,
1567                             Values(false))); // Values(false) is the reserved parameter
1568
1569 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, cornerHarris, Combine(
1570                             Values(CV_8UC1, CV_32FC1),
1571                             NULL_TYPE,
1572                             ONE_TYPE(CV_32FC1),
1573                             NULL_TYPE,
1574                             NULL_TYPE,
1575                             Values(false))); // Values(false) is the reserved parameter
1576
1577
1578 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, integral, Combine(
1579                             ONE_TYPE(CV_8UC1),
1580                             NULL_TYPE,
1581                             ONE_TYPE(CV_32SC1),
1582                             ONE_TYPE(CV_32FC1),
1583                             NULL_TYPE,
1584                             Values(false))); // Values(false) is the reserved parameter
1585
1586 INSTANTIATE_TEST_CASE_P(Imgproc, WarpAffine, Combine(
1587                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
1588                             Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR,
1589                                    (MatType)cv::INTER_CUBIC, (MatType)(cv::INTER_NEAREST | cv::WARP_INVERSE_MAP),
1590                                    (MatType)(cv::INTER_LINEAR | cv::WARP_INVERSE_MAP), (MatType)(cv::INTER_CUBIC | cv::WARP_INVERSE_MAP))));
1591
1592
1593 INSTANTIATE_TEST_CASE_P(Imgproc, WarpPerspective, Combine
1594                         (Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
1595                          Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR,
1596                                 (MatType)cv::INTER_CUBIC, (MatType)(cv::INTER_NEAREST | cv::WARP_INVERSE_MAP),
1597                                 (MatType)(cv::INTER_LINEAR | cv::WARP_INVERSE_MAP), (MatType)(cv::INTER_CUBIC | cv::WARP_INVERSE_MAP))));
1598
1599
1600 INSTANTIATE_TEST_CASE_P(Imgproc, Resize, Combine(
1601                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),  Values(cv::Size()),
1602                             Values(0.5, 1.5, 2), Values(0.5, 1.5, 2), Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR)));
1603
1604
1605 INSTANTIATE_TEST_CASE_P(Imgproc, Threshold, Combine(
1606                             Values(CV_8UC1, CV_32FC1), Values(ThreshOp(cv::THRESH_BINARY),
1607                                     ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC),
1608                                     ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))));
1609
1610
1611 INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftFiltering, Combine(
1612                             ONE_TYPE(CV_8UC4),
1613                             ONE_TYPE(CV_16SC2),
1614                             Values(5),
1615                             Values(6),
1616                             Values(cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1))
1617                         ));
1618
1619
1620 INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftProc, Combine(
1621                             ONE_TYPE(CV_8UC4),
1622                             ONE_TYPE(CV_16SC2),
1623                             Values(5),
1624                             Values(6),
1625                             Values(cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1))
1626                         ));
1627
1628 INSTANTIATE_TEST_CASE_P(Imgproc, Remap, Combine(
1629                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
1630                             Values(CV_32FC1, CV_16SC2, CV_32FC2), Values(-1, CV_32FC1),
1631                             Values((int)cv::INTER_NEAREST, (int)cv::INTER_LINEAR),
1632                             Values((int)cv::BORDER_CONSTANT)));
1633
1634
1635 INSTANTIATE_TEST_CASE_P(histTestBase, calcHist, Combine(
1636                             ONE_TYPE(CV_8UC1),
1637                             ONE_TYPE(CV_32SC1) //no use
1638                         ));
1639
1640 INSTANTIATE_TEST_CASE_P(Imgproc, CLAHE, Combine(
1641                         Values(cv::Size(4, 4), cv::Size(32, 8), cv::Size(8, 64)),
1642                         Values(0.0, 10.0, 62.0, 300.0)));
1643
1644 INSTANTIATE_TEST_CASE_P(Imgproc, ColumnSum, DIFFERENT_SIZES);
1645
1646 #endif // HAVE_OPENCL