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 "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::RNG &rng = TS::ptr()->get_rng();
 355         cv::Size size(MWIDTH, MHEIGHT);
 356         double min = 1, max = 20;
 357
 358         if(type1 != nulltype)
 359         {
 360             mat1 = randomMat(rng, size, type1, min, max, false);
 361             clmat1 = mat1;
 362         }
 363         if(type2 != nulltype)
 364         {
 365             mat2 = randomMat(rng, size, type2, min, max, false);
 366             clmat2 = mat2;
 367         }
 368         if(type3 != nulltype)
 369         {
 370             dst  = randomMat(rng, size, type3, min, max, false);
 371             cldst = dst;
 372         }
 373         if(type4 != nulltype)
 374         {
 375             dst1 = randomMat(rng, size, type4, min, max, false);
 376             cldst1 = dst1;
 377         }
 378         if(type5 != nulltype)
 379         {
 380             mask = randomMat(rng, size, CV_8UC1, 0, 2,  false);
 381             cv::threshold(mask, mask, 0.5, 255., type5);
 382             clmask = mask;
 383         }
 384         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));
 385     }
 386
 387     void random_roi()
 388     {
 389 #ifdef RANDOMROI
 390         //randomize ROI
 391         cv::RNG &rng = TS::ptr()->get_rng();
 392         roicols = rng.uniform(1, mat1.cols);
 393         roirows = rng.uniform(1, mat1.rows);
 394         src1x   = rng.uniform(0, mat1.cols - roicols);
 395         src1y   = rng.uniform(0, mat1.rows - roirows);
 396         src2x   = rng.uniform(0, mat2.cols - roicols);
 397         src2y   = rng.uniform(0, mat2.rows - roirows);
 398         dstx    = rng.uniform(0, dst.cols  - roicols);
 399         dsty    = rng.uniform(0, dst.rows  - roirows);
 400         dst1x    = rng.uniform(0, dst1.cols  - roicols);
 401         dst1y    = rng.uniform(0, dst1.rows  - roirows);
 402         maskx   = rng.uniform(0, mask.cols - roicols);
 403         masky   = rng.uniform(0, mask.rows - roirows);
 404 #else
 405         roicols = mat1.cols;
 406         roirows = mat1.rows;
 407         src1x = 0;
 408         src1y = 0;
 409         src2x = 0;
 410         src2y = 0;
 411         dstx = 0;
 412         dsty = 0;
 413         dst1x = 0;
 414         dst1y = 0;
 415         maskx = 0;
 416         masky = 0;
 417 #endif
 418
 419
 420         if(type1 != nulltype)
 421         {
 422             mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 423             clmat1_roi = clmat1(Rect(src1x, src1y, roicols, roirows));
 424         }
 425         if(type2 != nulltype)
 426         {
 427             mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows));
 428             clmat2_roi = clmat2(Rect(src2x, src2y, roicols, roirows));
 429         }
 430         if(type3 != nulltype)
 431         {
 432             dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 433             cldst_roi = cldst(Rect(dstx, dsty, roicols, roirows));
 434         }
 435         if(type4 != nulltype)
 436         {
 437             dst1_roi = dst1(Rect(dst1x, dst1y, roicols, roirows));
 438             cldst1_roi = cldst1(Rect(dst1x, dst1y, roicols, roirows));
 439         }
 440         if(type5 != nulltype)
 441         {
 442             mask_roi = mask(Rect(maskx, masky, roicols, roirows));
 443             clmask_roi = clmask(Rect(maskx, masky, roicols, roirows));
 444         }
 445     }
 446
 447     void Near(double threshold)
 448     {
 449         cv::Mat cpu_cldst;
 450         cldst.download(cpu_cldst);
 451         EXPECT_MAT_NEAR(dst, cpu_cldst, threshold);
 452     }
 453 };
 454 ////////////////////////////////equalizeHist//////////////////////////////////////////
 455
 456 struct equalizeHist : ImgprocTestBase {};
 457
 458 TEST_P(equalizeHist, Mat)
 459 {
 460     if (mat1.type() != CV_8UC1 || mat1.type() != dst.type())
 461     {
 462         cout << "Unsupported type" << endl;
 463         EXPECT_DOUBLE_EQ(0.0, 0.0);
 464     }
 465     else
 466     {
 467         for(int j = 0; j < LOOP_TIMES; j++)
 468         {
 469             random_roi();
 470             cv::equalizeHist(mat1_roi, dst_roi);
 471             cv::ocl::equalizeHist(clmat1_roi, cldst_roi);
 472             Near(1.1);
 473         }
 474     }
 475 }
 476
 477
 478
 479
 480
 481 ////////////////////////////////bilateralFilter////////////////////////////////////////////
 482
 483 struct bilateralFilter : ImgprocTestBase {};
 484
 485 TEST_P(bilateralFilter, Mat)
 486 {
 487     double sigmacolor = 50.0;
 488     int radius = 9;
 489     int d = 2 * radius + 1;
 490     double sigmaspace = 20.0;
 491     int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE, cv::BORDER_REFLECT, cv::BORDER_WRAP, cv::BORDER_REFLECT_101};
 492     //const char *borderstr[] = {"BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", "BORDER_WRAP", "BORDER_REFLECT_101"};
 493
 494     if (mat1.depth() != CV_8U || mat1.type() != dst.type())
 495     {
 496         cout << "Unsupported type" << endl;
 497         EXPECT_DOUBLE_EQ(0.0, 0.0);
 498     }
 499     else
 500     {
 501         for(size_t i = 0; i < sizeof(bordertype) / sizeof(int); i++)
 502             for(int j = 0; j < LOOP_TIMES; j++)
 503             {
 504                 random_roi();
 505                 if(((bordertype[i] != cv::BORDER_CONSTANT) && (bordertype[i] != cv::BORDER_REPLICATE) && (mat1_roi.cols <= radius)) || (mat1_roi.cols <= radius) || (mat1_roi.rows <= radius) || (mat1_roi.rows <= radius))
 506                 {
 507                     continue;
 508                 }
 509                 //if((dstx>=radius) && (dsty >= radius) && (dstx+cldst_roi.cols+radius <=cldst_roi.wholecols) && (dsty+cldst_roi.rows+radius <= cldst_roi.wholerows))
 510                 //{
 511                 //      dst_roi.adjustROI(radius, radius, radius, radius);
 512                 //      cldst_roi.adjustROI(radius, radius, radius, radius);
 513                 //}
 514                 //else
 515                 //{
 516                 //      continue;
 517                 //}
 518
 519                 cv::bilateralFilter(mat1_roi, dst_roi, d, sigmacolor, sigmaspace, bordertype[i] | cv::BORDER_ISOLATED);
 520                 cv::ocl::bilateralFilter(clmat1_roi, cldst_roi, d, sigmacolor, sigmaspace, bordertype[i] | cv::BORDER_ISOLATED);
 521                 Near(1.);
 522             }
 523     }
 524 }
 525
 526
 527
 528 ////////////////////////////////copyMakeBorder////////////////////////////////////////////
 529
 530 struct CopyMakeBorder : ImgprocTestBase {};
 531
 532 TEST_P(CopyMakeBorder, Mat)
 533 {
 534     int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE, cv::BORDER_REFLECT, cv::BORDER_WRAP, cv::BORDER_REFLECT_101};
 535     //const char *borderstr[] = {"BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", "BORDER_WRAP", "BORDER_REFLECT_101"};
 536     cv::RNG &rng = TS::ptr()->get_rng();
 537     int top = rng.uniform(0, 10);
 538     int bottom = rng.uniform(0, 10);
 539     int left = rng.uniform(0, 10);
 540     int right = rng.uniform(0, 10);
 541     if (mat1.type() != dst.type())
 542     {
 543         cout << "Unsupported type" << endl;
 544         EXPECT_DOUBLE_EQ(0.0, 0.0);
 545     }
 546     else
 547     {
 548         for(size_t i = 0; i < sizeof(bordertype) / sizeof(int); i++)
 549             for(int j = 0; j < LOOP_TIMES; j++)
 550             {
 551                 random_roi();
 552 #ifdef RANDOMROI
 553                 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))
 554                 {
 555                     continue;
 556                 }
 557                 if((dstx >= left) && (dsty >= top) && (dstx + cldst_roi.cols + right <= cldst_roi.wholecols) && (dsty + cldst_roi.rows + bottom <= cldst_roi.wholerows))
 558                 {
 559                     dst_roi.adjustROI(top, bottom, left, right);
 560                     cldst_roi.adjustROI(top, bottom, left, right);
 561                 }
 562                 else
 563                 {
 564                     continue;
 565                 }
 566 #endif
 567                 cv::copyMakeBorder(mat1_roi, dst_roi, top, bottom, left, right, bordertype[i] | cv::BORDER_ISOLATED, cv::Scalar(1.0));
 568                 cv::ocl::copyMakeBorder(clmat1_roi, cldst_roi, top, bottom, left, right,  bordertype[i] | cv::BORDER_ISOLATED, cv::Scalar(1.0));
 569
 570                 cv::Mat cpu_cldst;
 571 #ifndef RANDOMROI
 572                 cldst_roi.download(cpu_cldst);
 573                 EXPECT_MAT_NEAR(dst_roi, cpu_cldst, 0.0);
 574 #else
 575                 cldst.download(cpu_cldst);
 576                 EXPECT_MAT_NEAR(dst, cpu_cldst, 0.0);
 577 #endif
 578
 579             }
 580     }
 581 }
 582
 583
 584
 585 ////////////////////////////////cornerMinEigenVal//////////////////////////////////////////
 586
 587 struct cornerMinEigenVal : ImgprocTestBase {};
 588
 589 TEST_P(cornerMinEigenVal, Mat)
 590 {
 591     for(int j = 0; j < LOOP_TIMES; j++)
 592     {
 593
 594         random_roi();
 595         int blockSize = 3, apertureSize = 3;//1 + 2 * (rand() % 4);
 596         //int borderType = cv::BORDER_CONSTANT;
 597         //int borderType = cv::BORDER_REPLICATE;
 598         int borderType = cv::BORDER_REFLECT;
 599         cv::cornerMinEigenVal(mat1_roi, dst_roi, blockSize, apertureSize, borderType);
 600         cv::ocl::cornerMinEigenVal(clmat1_roi, cldst_roi, blockSize, apertureSize, borderType);
 601         Near(1.);
 602     }
 603 }
 604
 605
 606
 607 ////////////////////////////////cornerHarris//////////////////////////////////////////
 608
 609 struct cornerHarris : ImgprocTestBase {};
 610
 611 TEST_P(cornerHarris, Mat)
 612 {
 613     for(int j = 0; j < LOOP_TIMES; j++)
 614     {
 615
 616         random_roi();
 617         int blockSize = 3, apertureSize = 3; //1 + 2 * (rand() % 4);
 618         double k = 2;
 619         //int borderType = cv::BORDER_CONSTANT;
 620         //int borderType = cv::BORDER_REPLICATE;
 621         int borderType = cv::BORDER_REFLECT;
 622         cv::cornerHarris(mat1_roi, dst_roi, blockSize, apertureSize, k, borderType);
 623         cv::ocl::cornerHarris(clmat1_roi, cldst_roi, blockSize, apertureSize, k, borderType);
 624         Near(1.);
 625     }
 626 }
 627
 628
 629 ////////////////////////////////integral/////////////////////////////////////////////////
 630
 631 struct integral : ImgprocTestBase {};
 632
 633 TEST_P(integral, Mat)
 634 {
 635     for(int j = 0; j < LOOP_TIMES; j++)
 636     {
 637         random_roi();
 638
 639         cv::ocl::integral(clmat1_roi, cldst_roi, cldst1_roi);
 640         cv::integral(mat1_roi, dst_roi, dst1_roi);
 641         Near(0);
 642
 643         cv::Mat cpu_cldst1;
 644         cldst1.download(cpu_cldst1);
 645         EXPECT_MAT_NEAR(dst1, cpu_cldst1, 0.0);
 646     }
 647 }
 648
 649
 650 /////////////////////////////////////////////////////////////////////////////////////////////////
 651 // warpAffine  & warpPerspective
 652
 653 PARAM_TEST_CASE(WarpTestBase, MatType, int)
 654 {
 655     int type;
 656     cv::Size size;
 657     int interpolation;
 658
 659     //src mat
 660     cv::Mat mat1;
 661     cv::Mat dst;
 662
 663     // set up roi
 664     int src_roicols;
 665     int src_roirows;
 666     int dst_roicols;
 667     int dst_roirows;
 668     int src1x;
 669     int src1y;
 670     int dstx;
 671     int dsty;
 672
 673
 674     //src mat with roi
 675     cv::Mat mat1_roi;
 676     cv::Mat dst_roi;
 677
 678     //ocl dst mat for testing
 679     cv::ocl::oclMat gdst_whole;
 680
 681     //ocl mat with roi
 682     cv::ocl::oclMat gmat1;
 683     cv::ocl::oclMat gdst;
 684
 685     virtual void SetUp()
 686     {
 687         type = GET_PARAM(0);
 688         //dsize = GET_PARAM(1);
 689         interpolation = GET_PARAM(1);
 690
 691         cv::RNG &rng = TS::ptr()->get_rng();
 692         size = cv::Size(MWIDTH, MHEIGHT);
 693
 694         mat1 = randomMat(rng, size, type, 5, 16, false);
 695         dst  = randomMat(rng, size, type, 5, 16, false);
 696
 697     }
 698
 699     void random_roi()
 700     {
 701 #ifdef RANDOMROI
 702         //randomize ROI
 703         cv::RNG &rng = TS::ptr()->get_rng();
 704         src_roicols = rng.uniform(1, mat1.cols);
 705         src_roirows = rng.uniform(1, mat1.rows);
 706         dst_roicols = rng.uniform(1, dst.cols);
 707         dst_roirows = rng.uniform(1, dst.rows);
 708         src1x   = rng.uniform(0, mat1.cols - src_roicols);
 709         src1y   = rng.uniform(0, mat1.rows - src_roirows);
 710         dstx    = rng.uniform(0, dst.cols  - dst_roicols);
 711         dsty    = rng.uniform(0, dst.rows  - dst_roirows);
 712 #else
 713         src_roicols = mat1.cols;
 714         src_roirows = mat1.rows;
 715         dst_roicols = dst.cols;
 716         dst_roirows = dst.rows;
 717         src1x   = 0;
 718         src1y   = 0;
 719         dstx    = 0;
 720         dsty    = 0;
 721 #endif
 722
 723
 724         mat1_roi = mat1(Rect(src1x, src1y, src_roicols, src_roirows));
 725         dst_roi  = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
 726
 727         gdst_whole = dst;
 728         gdst = gdst_whole(Rect(dstx, dsty, dst_roicols, dst_roirows));
 729
 730
 731         gmat1 = mat1_roi;
 732     }
 733
 734 };
 735
 736 /////warpAffine
 737
 738 struct WarpAffine : WarpTestBase {};
 739
 740 TEST_P(WarpAffine, Mat)
 741 {
 742     static const double coeffs[2][3] =
 743     {
 744         {cos(CV_PI / 6), -sin(CV_PI / 6), 100.0},
 745         {sin(CV_PI / 6), cos(CV_PI / 6), -100.0}
 746     };
 747     Mat M(2, 3, CV_64F, (void *)coeffs);
 748
 749     for(int j = 0; j < LOOP_TIMES; j++)
 750     {
 751         random_roi();
 752
 753         cv::warpAffine(mat1_roi, dst_roi, M, size, interpolation);
 754         cv::ocl::warpAffine(gmat1, gdst, M, size, interpolation);
 755
 756         cv::Mat cpu_dst;
 757         gdst_whole.download(cpu_dst);
 758         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
 759     }
 760
 761 }
 762
 763
 764 // warpPerspective
 765
 766 struct WarpPerspective : WarpTestBase {};
 767
 768 TEST_P(WarpPerspective, Mat)
 769 {
 770     static const double coeffs[3][3] =
 771     {
 772         {cos(3.14 / 6), -sin(3.14 / 6), 100.0},
 773         {sin(3.14 / 6), cos(3.14 / 6), -100.0},
 774         {0.0, 0.0, 1.0}
 775     };
 776     Mat M(3, 3, CV_64F, (void *)coeffs);
 777
 778     for(int j = 0; j < LOOP_TIMES; j++)
 779     {
 780         random_roi();
 781
 782         cv::warpPerspective(mat1_roi, dst_roi, M, size, interpolation);
 783         cv::ocl::warpPerspective(gmat1, gdst, M, size, interpolation);
 784
 785         cv::Mat cpu_dst;
 786         gdst_whole.download(cpu_dst);
 787         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
 788     }
 789
 790 }
 791
 792 /////////////////////////////////////////////////////////////////////////////////////////////////
 793 // remap
 794 //////////////////////////////////////////////////////////////////////////////////////////////////
 795
 796 PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int)
 797 {
 798     int srcType;
 799     int map1Type;
 800     int map2Type;
 801     cv::Scalar val;
 802
 803     int interpolation;
 804     int bordertype;
 805
 806     cv::Mat src;
 807     cv::Mat dst;
 808     cv::Mat map1;
 809     cv::Mat map2;
 810
 811     //std::vector<cv::ocl::Info> oclinfo;
 812
 813     int src_roicols;
 814     int src_roirows;
 815     int dst_roicols;
 816     int dst_roirows;
 817     int map1_roicols;
 818     int map1_roirows;
 819     int map2_roicols;
 820     int map2_roirows;
 821     int srcx;
 822     int srcy;
 823     int dstx;
 824     int dsty;
 825     int map1x;
 826     int map1y;
 827     int map2x;
 828     int map2y;
 829
 830     cv::Mat src_roi;
 831     cv::Mat dst_roi;
 832     cv::Mat map1_roi;
 833     cv::Mat map2_roi;
 834
 835     //ocl mat for testing
 836     cv::ocl::oclMat gdst;
 837
 838     //ocl mat with roi
 839     cv::ocl::oclMat gsrc_roi;
 840     cv::ocl::oclMat gdst_roi;
 841     cv::ocl::oclMat gmap1_roi;
 842     cv::ocl::oclMat gmap2_roi;
 843
 844     virtual void SetUp()
 845     {
 846         srcType = GET_PARAM(0);
 847         map1Type = GET_PARAM(1);
 848         map2Type = GET_PARAM(2);
 849         interpolation = GET_PARAM(3);
 850         bordertype = GET_PARAM(4);
 851
 852         cv::RNG &rng = TS::ptr()->get_rng();
 853         cv::Size srcSize = cv::Size(MWIDTH, MHEIGHT);
 854         cv::Size map1Size = cv::Size(MWIDTH, MHEIGHT);
 855         double min = 5, max = 16;
 856
 857         if(srcType != nulltype)
 858         {
 859             src = randomMat(rng, srcSize, srcType, min, max, false);
 860         }
 861         if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2 && map2Type == nulltype))
 862         {
 863             map1 = randomMat(rng, map1Size, map1Type, min, max, false);
 864         }
 865         else if (map1Type == CV_32FC1 && map2Type == CV_32FC1)
 866         {
 867             map1 = randomMat(rng, map1Size, map1Type, min, max, false);
 868             map2 = randomMat(rng, map1Size, map1Type, min, max, false);
 869         }
 870
 871         else
 872         {
 873             cout << "The wrong input type" << endl;
 874             return;
 875         }
 876
 877         dst = randomMat(rng, map1Size, srcType, min, max, false);
 878         switch (src.channels())
 879         {
 880         case 1:
 881             val = cv::Scalar(rng.uniform(0.0, 10.0), 0, 0, 0);
 882             break;
 883         case 2:
 884             val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0, 0);
 885             break;
 886         case 3:
 887             val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0);
 888             break;
 889         case 4:
 890             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));
 891             break;
 892         }
 893
 894     }
 895     void random_roi()
 896     {
 897         cv::RNG &rng = TS::ptr()->get_rng();
 898
 899         dst_roicols = rng.uniform(1, dst.cols);
 900         dst_roirows = rng.uniform(1, dst.rows);
 901
 902         src_roicols = rng.uniform(1, src.cols);
 903         src_roirows = rng.uniform(1, src.rows);
 904
 905
 906         srcx = rng.uniform(0, src.cols - src_roicols);
 907         srcy = rng.uniform(0, src.rows - src_roirows);
 908         dstx = rng.uniform(0, dst.cols - dst_roicols);
 909         dsty = rng.uniform(0, dst.rows - dst_roirows);
 910         map1_roicols = dst_roicols;
 911         map1_roirows = dst_roirows;
 912         map2_roicols = dst_roicols;
 913         map2_roirows = dst_roirows;
 914         map1x = dstx;
 915         map1y = dsty;
 916         map2x = dstx;
 917         map2y = dsty;
 918
 919         if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2 && map2Type == nulltype))
 920         {
 921             map1_roi = map1(Rect(map1x, map1y, map1_roicols, map1_roirows));
 922             gmap1_roi = map1_roi;
 923         }
 924
 925         else if (map1Type == CV_32FC1 && map2Type == CV_32FC1)
 926         {
 927             map1_roi = map1(Rect(map1x, map1y, map1_roicols, map1_roirows));
 928             gmap1_roi = map1_roi;
 929             map2_roi = map2(Rect(map2x, map2y, map2_roicols, map2_roirows));
 930             gmap2_roi = map2_roi;
 931         }
 932         src_roi = src(Rect(srcx, srcy, src_roicols, src_roirows));
 933         dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
 934         gsrc_roi = src_roi;
 935         gdst = dst;
 936         gdst_roi = gdst(Rect(dstx, dsty, dst_roicols, dst_roirows));
 937     }
 938 };
 939
 940 TEST_P(Remap, Mat)
 941 {
 942     if((interpolation == 1 && map1Type == CV_16SC2) || (map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1))
 943     {
 944         cout << "Don't support the dataType" << endl;
 945         return;
 946     }
 947     int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/};
 948     //const char *borderstr[] = {"BORDER_CONSTANT", "BORDER_REPLICATE"/*, "BORDER_REFLECT","BORDER_WRAP","BORDER_REFLECT_101"*/};
 949     // for(int i = 0; i < sizeof(bordertype)/sizeof(int); i++)
 950     for(int j = 0; j < LOOP_TIMES; j++)
 951     {
 952         random_roi();
 953         cv::remap(src_roi, dst_roi, map1_roi, map2_roi, interpolation, bordertype[0], val);
 954         cv::ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val);
 955         cv::Mat cpu_dst;
 956         gdst.download(cpu_dst);
 957
 958         if(interpolation == 0)
 959             EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
 960         EXPECT_MAT_NEAR(dst, cpu_dst, 2.0);
 961
 962     }
 963 }
 964
 965
 966
 967 /////////////////////////////////////////////////////////////////////////////////////////////////
 968 // resize
 969
 970 PARAM_TEST_CASE(Resize, MatType, cv::Size, double, double, int)
 971 {
 972     int type;
 973     cv::Size dsize;
 974     double fx, fy;
 975     int interpolation;
 976
 977     //src mat
 978     cv::Mat mat1;
 979     cv::Mat dst;
 980
 981     // set up roi
 982     int src_roicols;
 983     int src_roirows;
 984     int dst_roicols;
 985     int dst_roirows;
 986     int src1x;
 987     int src1y;
 988     int dstx;
 989     int dsty;
 990
 991     //src mat with roi
 992     cv::Mat mat1_roi;
 993     cv::Mat dst_roi;
 994
 995     //ocl dst mat for testing
 996     cv::ocl::oclMat gdst_whole;
 997
 998     //ocl mat with roi
 999     cv::ocl::oclMat gmat1;
1000     cv::ocl::oclMat gdst;
1001
1002     virtual void SetUp()
1003     {
1004         type = GET_PARAM(0);
1005         dsize = GET_PARAM(1);
1006         fx = GET_PARAM(2);
1007         fy = GET_PARAM(3);
1008         interpolation = GET_PARAM(4);
1009
1010         cv::RNG &rng = TS::ptr()->get_rng();
1011
1012         cv::Size size(MWIDTH, MHEIGHT);
1013
1014         if(dsize == cv::Size() && !(fx > 0 && fy > 0))
1015         {
1016             cout << "invalid dsize and fx fy" << endl;
1017             return;
1018         }
1019
1020         if(dsize == cv::Size())
1021         {
1022             dsize.width = (int)(size.width * fx);
1023             dsize.height = (int)(size.height * fy);
1024         }
1025
1026         mat1 = randomMat(rng, size, type, 5, 16, false);
1027         dst  = randomMat(rng, dsize, type, 5, 16, false);
1028
1029     }
1030
1031     void random_roi()
1032     {
1033 #ifdef RANDOMROI
1034         //randomize ROI
1035         cv::RNG &rng = TS::ptr()->get_rng();
1036         src_roicols = rng.uniform(1, mat1.cols);
1037         src_roirows = rng.uniform(1, mat1.rows);
1038         dst_roicols = (int)(src_roicols * fx);
1039         dst_roirows = (int)(src_roirows * fy);
1040         src1x   = rng.uniform(0, mat1.cols - src_roicols);
1041         src1y   = rng.uniform(0, mat1.rows - src_roirows);
1042         dstx    = rng.uniform(0, dst.cols  - dst_roicols);
1043         dsty    = rng.uniform(0, dst.rows  - dst_roirows);
1044 #else
1045         src_roicols = mat1.cols;
1046         src_roirows = mat1.rows;
1047         dst_roicols = dst.cols;
1048         dst_roirows = dst.rows;
1049         src1x   = 0;
1050         src1y   = 0;
1051         dstx    = 0;
1052         dsty    = 0;
1053 #endif
1054         dsize.width = dst_roicols;
1055         dsize.height = dst_roirows;
1056         mat1_roi = mat1(Rect(src1x, src1y, src_roicols, src_roirows));
1057         dst_roi  = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
1058
1059         gdst_whole = dst;
1060         gdst = gdst_whole(Rect(dstx, dsty, dst_roicols, dst_roirows));
1061
1062         dsize.width = (int)(mat1_roi.size().width * fx);
1063         dsize.height = (int)(mat1_roi.size().height * fy);
1064
1065         gmat1 = mat1_roi;
1066     }
1067
1068 };
1069
1070 TEST_P(Resize, Mat)
1071 {
1072     for(int j = 0; j < LOOP_TIMES; j++)
1073     {
1074         random_roi();
1075
1076         // cv::resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation);
1077         // cv::ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation);
1078         if(dst_roicols < 1 || dst_roirows < 1) continue;
1079         cv::resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation);
1080         cv::ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation);
1081
1082         cv::Mat cpu_dst;
1083         gdst_whole.download(cpu_dst);
1084         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0);
1085     }
1086
1087 }
1088
1089
1090 /////////////////////////////////////////////////////////////////////////////////////////////////
1091 //threshold
1092
1093 PARAM_TEST_CASE(Threshold, MatType, ThreshOp)
1094 {
1095     int type;
1096     int threshOp;
1097
1098     //src mat
1099     cv::Mat mat1;
1100     cv::Mat dst;
1101
1102     // set up roi
1103     int roicols;
1104     int roirows;
1105     int src1x;
1106     int src1y;
1107     int dstx;
1108     int dsty;
1109
1110     //src mat with roi
1111     cv::Mat mat1_roi;
1112     cv::Mat dst_roi;
1113
1114     //ocl dst mat for testing
1115     cv::ocl::oclMat gdst_whole;
1116
1117     //ocl mat with roi
1118     cv::ocl::oclMat gmat1;
1119     cv::ocl::oclMat gdst;
1120
1121     virtual void SetUp()
1122     {
1123         type = GET_PARAM(0);
1124         threshOp = GET_PARAM(1);
1125
1126         cv::RNG &rng = TS::ptr()->get_rng();
1127         cv::Size size(MWIDTH, MHEIGHT);
1128
1129         mat1 = randomMat(rng, size, type, 5, 16, false);
1130         dst  = randomMat(rng, size, type, 5, 16, false);
1131     }
1132
1133     void random_roi()
1134     {
1135 #ifdef RANDOMROI
1136         //randomize ROI
1137         cv::RNG &rng = TS::ptr()->get_rng();
1138         roicols = rng.uniform(1, mat1.cols);
1139         roirows = rng.uniform(1, mat1.rows);
1140         src1x   = rng.uniform(0, mat1.cols - roicols);
1141         src1y   = rng.uniform(0, mat1.rows - roirows);
1142         dstx    = rng.uniform(0, dst.cols  - roicols);
1143         dsty    = rng.uniform(0, dst.rows  - roirows);
1144 #else
1145         roicols = mat1.cols;
1146         roirows = mat1.rows;
1147         src1x   = 0;
1148         src1y   = 0;
1149         dstx    = 0;
1150         dsty    = 0;
1151 #endif
1152
1153         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
1154         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
1155
1156         gdst_whole = dst;
1157         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
1158
1159
1160         gmat1 = mat1_roi;
1161     }
1162
1163 };
1164
1165 TEST_P(Threshold, Mat)
1166 {
1167     for(int j = 0; j < LOOP_TIMES; j++)
1168     {
1169         random_roi();
1170         double maxVal = randomDouble(20.0, 127.0);
1171         double thresh = randomDouble(0.0, maxVal);
1172
1173         cv::threshold(mat1_roi, dst_roi, thresh, maxVal, threshOp);
1174         cv::ocl::threshold(gmat1, gdst, thresh, maxVal, threshOp);
1175
1176         cv::Mat cpu_dst;
1177         gdst_whole.download(cpu_dst);
1178         EXPECT_MAT_NEAR(dst, cpu_dst, 1);
1179     }
1180
1181 }
1182
1183 PARAM_TEST_CASE(meanShiftTestBase, MatType, MatType, int, int, cv::TermCriteria)
1184 {
1185     int type, typeCoor;
1186     int sp, sr;
1187     cv::TermCriteria crit;
1188     //src mat
1189     cv::Mat src;
1190     cv::Mat dst;
1191     cv::Mat dstCoor;
1192
1193     //set up roi
1194     int roicols;
1195     int roirows;
1196     int srcx;
1197     int srcy;
1198     int dstx;
1199     int dsty;
1200
1201     //src mat with roi
1202     cv::Mat src_roi;
1203     cv::Mat dst_roi;
1204     cv::Mat dstCoor_roi;
1205
1206     //ocl dst mat
1207     cv::ocl::oclMat gdst;
1208     cv::ocl::oclMat gdstCoor;
1209
1210     //ocl mat with roi
1211     cv::ocl::oclMat gsrc_roi;
1212     cv::ocl::oclMat gdst_roi;
1213     cv::ocl::oclMat gdstCoor_roi;
1214
1215     virtual void SetUp()
1216     {
1217         type     = GET_PARAM(0);
1218         typeCoor = GET_PARAM(1);
1219         sp       = GET_PARAM(2);
1220         sr       = GET_PARAM(3);
1221         crit     = GET_PARAM(4);
1222
1223         cv::RNG &rng = TS::ptr()->get_rng();
1224
1225         // MWIDTH=256, MHEIGHT=256. defined in utility.hpp
1226         cv::Size size = cv::Size(MWIDTH, MHEIGHT);
1227
1228         src = randomMat(rng, size, type, 5, 16, false);
1229         dst = randomMat(rng, size, type, 5, 16, false);
1230         dstCoor = randomMat(rng, size, typeCoor, 5, 16, false);
1231
1232     }
1233
1234     void random_roi()
1235     {
1236 #ifdef RANDOMROI
1237         cv::RNG &rng = TS::ptr()->get_rng();
1238
1239         //randomize ROI
1240         roicols = rng.uniform(1, src.cols);
1241         roirows = rng.uniform(1, src.rows);
1242         srcx = rng.uniform(0, src.cols - roicols);
1243         srcy = rng.uniform(0, src.rows - roirows);
1244         dstx = rng.uniform(0, dst.cols - roicols);
1245         dsty = rng.uniform(0, dst.rows - roirows);
1246 #else
1247         roicols = src.cols;
1248         roirows = src.rows;
1249         srcx = 0;
1250         srcy = 0;
1251         dstx = 0;
1252         dsty = 0;
1253 #endif
1254         src_roi = src(Rect(srcx, srcy, roicols, roirows));
1255         dst_roi = dst(Rect(dstx, dsty, roicols, roirows));
1256         dstCoor_roi = dstCoor(Rect(dstx, dsty, roicols, roirows));
1257
1258         gdst = dst;
1259         gdstCoor = dstCoor;
1260
1261         gsrc_roi = src_roi;
1262         gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows));  //gdst_roi
1263         gdstCoor_roi = gdstCoor(Rect(dstx, dsty, roicols, roirows));
1264     }
1265 };
1266
1267 /////////////////////////meanShiftFiltering/////////////////////////////
1268 struct meanShiftFiltering : meanShiftTestBase {};
1269
1270 TEST_P(meanShiftFiltering, Mat)
1271 {
1272
1273     for(int j = 0; j < LOOP_TIMES; j++)
1274     {
1275         random_roi();
1276
1277         cv::Mat cpu_gdst;
1278         gdst.download(cpu_gdst);
1279
1280         meanShiftFiltering_(src_roi, dst_roi, sp, sr, crit);
1281         cv::ocl::meanShiftFiltering(gsrc_roi, gdst_roi, sp, sr, crit);
1282
1283         gdst.download(cpu_gdst);
1284         EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0);
1285     }
1286 }
1287
1288 ///////////////////////////meanShiftProc//////////////////////////////////
1289 struct meanShiftProc : meanShiftTestBase {};
1290
1291 TEST_P(meanShiftProc, Mat)
1292 {
1293
1294     for(int j = 0; j < LOOP_TIMES; j++)
1295     {
1296         random_roi();
1297
1298         cv::Mat cpu_gdst;
1299         cv::Mat cpu_gdstCoor;
1300
1301         meanShiftProc_(src_roi, dst_roi, dstCoor_roi, sp, sr, crit);
1302         cv::ocl::meanShiftProc(gsrc_roi, gdst_roi, gdstCoor_roi, sp, sr, crit);
1303
1304         gdst.download(cpu_gdst);
1305         gdstCoor.download(cpu_gdstCoor);
1306         EXPECT_MAT_NEAR(dst, cpu_gdst, 0.0);
1307         EXPECT_MAT_NEAR(dstCoor, cpu_gdstCoor, 0.0);
1308     }
1309 }
1310
1311 ///////////////////////////////////////////////////////////////////////////////////////
1312 //hist
1313 void calcHistGold(const cv::Mat &src, cv::Mat &hist)
1314 {
1315     hist.create(1, 256, CV_32SC1);
1316     hist.setTo(cv::Scalar::all(0));
1317
1318     int *hist_row = hist.ptr<int>();
1319     for (int y = 0; y < src.rows; ++y)
1320     {
1321         const uchar *src_row = src.ptr(y);
1322
1323         for (int x = 0; x < src.cols; ++x)
1324             ++hist_row[src_row[x]];
1325     }
1326 }
1327
1328 PARAM_TEST_CASE(histTestBase, MatType, MatType)
1329 {
1330     int type_src;
1331
1332     //src mat
1333     cv::Mat src;
1334     cv::Mat dst_hist;
1335     //set up roi
1336     int roicols;
1337     int roirows;
1338     int srcx;
1339     int srcy;
1340     //src mat with roi
1341     cv::Mat src_roi;
1342     //ocl dst mat, dst_hist and gdst_hist don't have roi
1343     cv::ocl::oclMat gdst_hist;
1344     //ocl mat with roi
1345     cv::ocl::oclMat gsrc_roi;
1346
1347     virtual void SetUp()
1348     {
1349         type_src   = GET_PARAM(0);
1350
1351         cv::RNG &rng = TS::ptr()->get_rng();
1352         cv::Size size = cv::Size(MWIDTH, MHEIGHT);
1353
1354         src = randomMat(rng, size, type_src, 0, 256, false);
1355
1356     }
1357
1358     void random_roi()
1359     {
1360 #ifdef RANDOMROI
1361         cv::RNG &rng = TS::ptr()->get_rng();
1362
1363         //randomize ROI
1364         roicols = rng.uniform(1, src.cols);
1365         roirows = rng.uniform(1, src.rows);
1366         srcx = rng.uniform(0, src.cols - roicols);
1367         srcy = rng.uniform(0, src.rows - roirows);
1368 #else
1369         roicols = src.cols;
1370         roirows = src.rows;
1371         srcx = 0;
1372         srcy = 0;
1373 #endif
1374         src_roi = src(Rect(srcx, srcy, roicols, roirows));
1375
1376         gsrc_roi = src_roi;
1377     }
1378 };
1379 ///////////////////////////calcHist///////////////////////////////////////
1380 struct calcHist : histTestBase {};
1381
1382 TEST_P(calcHist, Mat)
1383 {
1384     for(int j = 0; j < LOOP_TIMES; j++)
1385     {
1386         random_roi();
1387
1388         cv::Mat cpu_hist;
1389
1390         calcHistGold(src_roi, dst_hist);
1391         cv::ocl::calcHist(gsrc_roi, gdst_hist);
1392
1393         gdst_hist.download(cpu_hist);
1394         EXPECT_MAT_NEAR(dst_hist, cpu_hist, 0.0);
1395     }
1396 }
1397 ///////////////////////////////////////////////////////////////////////////////////////////////////////
1398 // CLAHE
1399 namespace
1400 {
1401     IMPLEMENT_PARAM_CLASS(ClipLimit, double)
1402 }
1403
1404 PARAM_TEST_CASE(CLAHE, cv::Size, ClipLimit)
1405 {
1406     cv::Size size;
1407     double clipLimit;
1408
1409     cv::Mat src;
1410     cv::Mat dst_gold;
1411
1412     cv::ocl::oclMat g_src;
1413     cv::ocl::oclMat g_dst;
1414
1415     virtual void SetUp()
1416     {
1417         size = GET_PARAM(0);
1418         clipLimit = GET_PARAM(1);
1419
1420         cv::RNG &rng = TS::ptr()->get_rng();
1421         src = randomMat(rng, size, CV_8UC1, 0, 256, false);
1422         g_src.upload(src);
1423     }
1424 };
1425
1426 TEST_P(CLAHE, Accuracy)
1427 {
1428     cv::Ptr<cv::ocl::CLAHE> clahe = cv::ocl::createCLAHE(clipLimit);
1429     clahe->apply(g_src, g_dst);
1430     cv::Mat dst(g_dst);
1431
1432     cv::Ptr<cv::CLAHE> clahe_gold = cv::createCLAHE(clipLimit);
1433     clahe_gold->apply(src, dst_gold);
1434
1435     EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
1436 }
1437
1438 ///////////////////////////Convolve//////////////////////////////////
1439 PARAM_TEST_CASE(ConvolveTestBase, MatType, bool)
1440 {
1441     int type;
1442     //src mat
1443     cv::Mat mat1;
1444     cv::Mat mat2;
1445     cv::Mat dst;
1446     cv::Mat dst1; //bak, for two outputs
1447     // set up roi
1448     int roicols;
1449     int roirows;
1450     int src1x;
1451     int src1y;
1452     int src2x;
1453     int src2y;
1454     int dstx;
1455     int dsty;
1456     //src mat with roi
1457     cv::Mat mat1_roi;
1458     cv::Mat mat2_roi;
1459     cv::Mat dst_roi;
1460     cv::Mat dst1_roi; //bak
1461     //ocl dst mat for testing
1462     cv::ocl::oclMat gdst_whole;
1463     cv::ocl::oclMat gdst1_whole; //bak
1464     //ocl mat with roi
1465     cv::ocl::oclMat gmat1;
1466     cv::ocl::oclMat gmat2;
1467     cv::ocl::oclMat gdst;
1468     cv::ocl::oclMat gdst1;   //bak
1469     virtual void SetUp()
1470     {
1471         type = GET_PARAM(0);
1472
1473         cv::RNG &rng = TS::ptr()->get_rng();
1474
1475         cv::Size size(MWIDTH, MHEIGHT);
1476
1477         mat1 = randomMat(rng, size, type, 5, 16, false);
1478         mat2 = randomMat(rng, size, type, 5, 16, false);
1479         dst  = randomMat(rng, size, type, 5, 16, false);
1480         dst1  = randomMat(rng, size, type, 5, 16, false);
1481     }
1482     void random_roi()
1483     {
1484         cv::RNG &rng = TS::ptr()->get_rng();
1485
1486 #ifdef RANDOMROI
1487         //randomize ROI
1488         roicols = rng.uniform(1, mat1.cols);
1489         roirows = rng.uniform(1, mat1.rows);
1490         src1x   = rng.uniform(0, mat1.cols - roicols);
1491         src1y   = rng.uniform(0, mat1.rows - roirows);
1492         dstx    = rng.uniform(0, dst.cols  - roicols);
1493         dsty    = rng.uniform(0, dst.rows  - roirows);
1494 #else
1495         roicols = mat1.cols;
1496         roirows = mat1.rows;
1497         src1x = 0;
1498         src1y = 0;
1499         dstx = 0;
1500         dsty = 0;
1501 #endif
1502         src2x   = rng.uniform(0, mat2.cols - roicols);
1503         src2y   = rng.uniform(0, mat2.rows - roirows);
1504         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
1505         mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows));
1506         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
1507         dst1_roi = dst1(Rect(dstx, dsty, roicols, roirows));
1508
1509         gdst_whole = dst;
1510         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
1511
1512         gdst1_whole = dst1;
1513         gdst1 = gdst1_whole(Rect(dstx, dsty, roicols, roirows));
1514
1515         gmat1 = mat1_roi;
1516         gmat2 = mat2_roi;
1517         //end
1518     }
1519
1520 };
1521 struct Convolve : ConvolveTestBase {};
1522
1523 void conv2( cv::Mat x, cv::Mat y, cv::Mat z)
1524 {
1525     int N1 = x.rows;
1526     int M1 = x.cols;
1527     int N2 = y.rows;
1528     int M2 = y.cols;
1529
1530     int i, j;
1531     int m, n;
1532
1533
1534     float *kerneldata = (float *)(x.data);
1535     float *srcdata = (float *)(y.data);
1536     float *dstdata = (float *)(z.data);
1537
1538     for(i = 0; i < N2; i++)
1539         for(j = 0; j < M2; j++)
1540         {
1541             float temp = 0;
1542             for(m = 0; m < N1; m++)
1543                 for(n = 0; n < M1; n++)
1544                 {
1545                     int r, c;
1546                     r = min(max((i - N1 / 2 + m), 0), N2 - 1);
1547                     c = min(max((j - M1 / 2 + n), 0), M2 - 1);
1548                     temp += kerneldata[m * (x.step >> 2) + n] * srcdata[r * (y.step >> 2) + c];
1549                 }
1550             dstdata[i * (z.step >> 2) + j] = temp;
1551         }
1552 }
1553 TEST_P(Convolve, Mat)
1554 {
1555     if(mat1.type() != CV_32FC1)
1556     {
1557         cout << "\tUnsupported type\t\n";
1558     }
1559     for(int j = 0; j < LOOP_TIMES; j++)
1560     {
1561         random_roi();
1562         cv::ocl::oclMat temp1;
1563         cv::Mat kernel_cpu = mat2(Rect(0, 0, 7, 7));
1564         temp1 = kernel_cpu;
1565
1566         conv2(kernel_cpu, mat1_roi, dst_roi);
1567         cv::ocl::convolve(gmat1, temp1, gdst);
1568
1569         cv::Mat cpu_dst;
1570         gdst_whole.download(cpu_dst);
1571         EXPECT_MAT_NEAR(dst, cpu_dst, .1);
1572
1573     }
1574 }
1575
1576 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, equalizeHist, Combine(
1577                             ONE_TYPE(CV_8UC1),
1578                             NULL_TYPE,
1579                             ONE_TYPE(CV_8UC1),
1580                             NULL_TYPE,
1581                             NULL_TYPE,
1582                             Values(false))); // Values(false) is the reserved parameter
1583
1584 //INSTANTIATE_TEST_CASE_P(ImgprocTestBase, bilateralFilter, Combine(
1585 //      ONE_TYPE(CV_8UC1),
1586 //      NULL_TYPE,
1587 //      ONE_TYPE(CV_8UC1),
1588 //      NULL_TYPE,
1589 //      NULL_TYPE,
1590 //      Values(false))); // Values(false) is the reserved parameter
1591 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, bilateralFilter, Combine(
1592                             Values(CV_8UC1, CV_8UC3),
1593                             NULL_TYPE,
1594                             Values(CV_8UC1, CV_8UC3),
1595                             NULL_TYPE,
1596                             NULL_TYPE,
1597                             Values(false))); // Values(false) is the reserved parameter
1598
1599
1600 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CopyMakeBorder, Combine(
1601                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1602                             NULL_TYPE,
1603                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32SC1, CV_32SC3, CV_32SC4, CV_32FC1, CV_32FC3, CV_32FC4),
1604                             NULL_TYPE,
1605                             NULL_TYPE,
1606                             Values(false))); // Values(false) is the reserved parameter
1607
1608 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, cornerMinEigenVal, Combine(
1609                             Values(CV_8UC1, CV_32FC1),
1610                             NULL_TYPE,
1611                             ONE_TYPE(CV_32FC1),
1612                             NULL_TYPE,
1613                             NULL_TYPE,
1614                             Values(false))); // Values(false) is the reserved parameter
1615
1616 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, cornerHarris, Combine(
1617                             Values(CV_8UC1, CV_32FC1),
1618                             NULL_TYPE,
1619                             ONE_TYPE(CV_32FC1),
1620                             NULL_TYPE,
1621                             NULL_TYPE,
1622                             Values(false))); // Values(false) is the reserved parameter
1623
1624
1625 INSTANTIATE_TEST_CASE_P(ImgprocTestBase, integral, Combine(
1626                             ONE_TYPE(CV_8UC1),
1627                             NULL_TYPE,
1628                             ONE_TYPE(CV_32SC1),
1629                             ONE_TYPE(CV_32FC1),
1630                             NULL_TYPE,
1631                             Values(false))); // Values(false) is the reserved parameter
1632
1633 INSTANTIATE_TEST_CASE_P(Imgproc, WarpAffine, Combine(
1634                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
1635                             Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR,
1636                                    (MatType)cv::INTER_CUBIC, (MatType)(cv::INTER_NEAREST | cv::WARP_INVERSE_MAP),
1637                                    (MatType)(cv::INTER_LINEAR | cv::WARP_INVERSE_MAP), (MatType)(cv::INTER_CUBIC | cv::WARP_INVERSE_MAP))));
1638
1639
1640 INSTANTIATE_TEST_CASE_P(Imgproc, WarpPerspective, Combine
1641                         (Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
1642                          Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR,
1643                                 (MatType)cv::INTER_CUBIC, (MatType)(cv::INTER_NEAREST | cv::WARP_INVERSE_MAP),
1644                                 (MatType)(cv::INTER_LINEAR | cv::WARP_INVERSE_MAP), (MatType)(cv::INTER_CUBIC | cv::WARP_INVERSE_MAP))));
1645
1646
1647 INSTANTIATE_TEST_CASE_P(Imgproc, Resize, Combine(
1648                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),  Values(cv::Size()),
1649                             Values(0.5, 1.5, 2), Values(0.5, 1.5, 2), Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR)));
1650
1651
1652 INSTANTIATE_TEST_CASE_P(Imgproc, Threshold, Combine(
1653                             Values(CV_8UC1, CV_32FC1), Values(ThreshOp(cv::THRESH_BINARY),
1654                                     ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC),
1655                                     ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))));
1656
1657
1658 INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftFiltering, Combine(
1659                             ONE_TYPE(CV_8UC4),
1660                             ONE_TYPE(CV_16SC2),
1661                             Values(5),
1662                             Values(6),
1663                             Values(cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1))
1664                         ));
1665
1666
1667 INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftProc, Combine(
1668                             ONE_TYPE(CV_8UC4),
1669                             ONE_TYPE(CV_16SC2),
1670                             Values(5),
1671                             Values(6),
1672                             Values(cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1))
1673                         ));
1674
1675 INSTANTIATE_TEST_CASE_P(Imgproc, Remap, Combine(
1676                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
1677                             Values(CV_32FC1, CV_16SC2, CV_32FC2), Values(-1, CV_32FC1),
1678                             Values((int)cv::INTER_NEAREST, (int)cv::INTER_LINEAR),
1679                             Values((int)cv::BORDER_CONSTANT)));
1680
1681
1682 INSTANTIATE_TEST_CASE_P(histTestBase, calcHist, Combine(
1683                             ONE_TYPE(CV_8UC1),
1684                             ONE_TYPE(CV_32SC1) //no use
1685                         ));
1686
1687 INSTANTIATE_TEST_CASE_P(ImgProc, CLAHE, Combine(
1688                         Values(cv::Size(128, 128), cv::Size(113, 113), cv::Size(1300, 1300)),
1689                         Values(0.0, 40.0)));
1690
1691 //INSTANTIATE_TEST_CASE_P(ConvolveTestBase, Convolve, Combine(
1692 //                            Values(CV_32FC1, CV_32FC1),
1693 //                            Values(false))); // Values(false) is the reserved parameter
1694 #endif // HAVE_OPENCL