modules/ocl/test/test_filters.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 // Third party copyrights are property of their respective owners.
  16 //
  17 // @Authors
  18 //    Niko Li, newlife20080214@gmail.com
  19 //    Jia Haipeng, jiahaipeng95@gmail.com
  20 //    Zero Lin, Zero.Lin@amd.com
  21 //    Zhang Ying, zhangying913@gmail.com
  22 //
  23 // Redistribution and use in source and binary forms, with or without modification,
  24 // are permitted provided that the following conditions are met:
  25 //
  26 //   * Redistribution's of source code must retain the above copyright notice,
  27 //     this list of conditions and the following disclaimer.
  28 //
  29 //   * Redistribution's in binary form must reproduce the above copyright notice,
  30 //     this list of conditions and the following disclaimer in the documentation
  31 //     and/or other oclMaterials provided with the distribution.
  32 //
  33 //   * The name of the copyright holders may not be used to endorse or promote products
  34 //     derived from this software without specific prior written permission.
  35 //
  36 // This software is provided by the copyright holders and contributors "as is" and
  37 // any express or implied warranties, including, but not limited to, the implied
  38 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  39 // In no event shall the Intel Corporation or contributors be liable for any direct,
  40 // indirect, incidental, special, exemplary, or consequential damages
  41 // (including, but not limited to, procurement of substitute goods or services;
  42 // loss of use, data, or profits; or business interruption) however caused
  43 // and on any theory of liability, whether in contract, strict liability,
  44 // or tort (including negligence or otherwise) arising in any way out of
  45 // the use of this software, even if advised of the possibility of such damage.
  46 //
  47 //M*/
  48
  49 #include "precomp.hpp"
  50
  51 #ifdef HAVE_OPENCL
  52
  53 using namespace cvtest;
  54 using namespace testing;
  55 using namespace std;
  56
  57
  58 PARAM_TEST_CASE(FilterTestBase, MatType, bool)
  59 {
  60     int type;
  61     cv::Scalar val;
  62
  63     //src mat
  64     cv::Mat mat1;
  65     cv::Mat mat2;
  66     cv::Mat mask;
  67     cv::Mat dst;
  68     cv::Mat dst1; //bak, for two outputs
  69
  70     // set up roi
  71     int roicols;
  72     int roirows;
  73     int src1x;
  74     int src1y;
  75     int src2x;
  76     int src2y;
  77     int dstx;
  78     int dsty;
  79     int maskx;
  80     int masky;
  81
  82     //src mat with roi
  83     cv::Mat mat1_roi;
  84     cv::Mat mat2_roi;
  85     cv::Mat mask_roi;
  86     cv::Mat dst_roi;
  87     cv::Mat dst1_roi; //bak
  88     //std::vector<cv::ocl::Info> oclinfo;
  89     //ocl dst mat for testing
  90     cv::ocl::oclMat gdst_whole;
  91     cv::ocl::oclMat gdst1_whole; //bak
  92
  93     //ocl mat with roi
  94     cv::ocl::oclMat gmat1;
  95     cv::ocl::oclMat gmat2;
  96     cv::ocl::oclMat gdst;
  97     cv::ocl::oclMat gdst1;   //bak
  98     cv::ocl::oclMat gmask;
  99
 100     virtual void SetUp()
 101     {
 102         type = GET_PARAM(0);
 103
 104         cv::RNG &rng = TS::ptr()->get_rng();
 105         cv::Size size(MWIDTH, MHEIGHT);
 106
 107         mat1 = randomMat(rng, size, type, 5, 16, false);
 108         mat2 = randomMat(rng, size, type, 5, 16, false);
 109         dst  = randomMat(rng, size, type, 5, 16, false);
 110         dst1  = randomMat(rng, size, type, 5, 16, false);
 111         mask = randomMat(rng, size, CV_8UC1, 0, 2,  false);
 112
 113         cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
 114
 115         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));
 116     }
 117
 118     void random_roi()
 119     {
 120 #ifdef RANDOMROI
 121         //randomize ROI
 122         cv::RNG &rng = TS::ptr()->get_rng();
 123         roicols = rng.uniform(1, mat1.cols);
 124         roirows = rng.uniform(1, mat1.rows);
 125         src1x   = rng.uniform(0, mat1.cols - roicols);
 126         src1y   = rng.uniform(0, mat1.rows - roirows);
 127         src2x   = rng.uniform(0, mat2.cols - roicols);
 128         src2y   = rng.uniform(0, mat2.rows - roirows);
 129         dstx    = rng.uniform(0, dst.cols  - roicols);
 130         dsty    = rng.uniform(0, dst.rows  - roirows);
 131         maskx   = rng.uniform(0, mask.cols - roicols);
 132         masky   = rng.uniform(0, mask.rows - roirows);
 133 #else
 134         roicols = mat1.cols;
 135         roirows = mat1.rows;
 136         src1x = 0;
 137         src1y = 0;
 138         src2x = 0;
 139         src2y = 0;
 140         dstx = 0;
 141         dsty = 0;
 142         maskx = 0;
 143         masky = 0;
 144 #endif
 145         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 146         mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows));
 147         mask_roi = mask(Rect(maskx, masky, roicols, roirows));
 148         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 149         dst1_roi = dst1(Rect(dstx, dsty, roicols, roirows));
 150
 151         gdst_whole = dst;
 152         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 153
 154         gdst1_whole = dst1;
 155         gdst1 = gdst1_whole(Rect(dstx, dsty, roicols, roirows));
 156
 157         gmat1 = mat1_roi;
 158         gmat2 = mat2_roi;
 159         gmask = mask_roi;
 160     }
 161
 162 };
 163
 164 /////////////////////////////////////////////////////////////////////////////////////////////////
 165 // blur
 166
 167 PARAM_TEST_CASE(Blur, MatType, cv::Size, int)
 168 {
 169     int type;
 170     cv::Size ksize;
 171     int bordertype;
 172
 173     //src mat
 174     cv::Mat mat1;
 175     cv::Mat dst;
 176
 177     // set up roi
 178     int roicols;
 179     int roirows;
 180     int src1x;
 181     int src1y;
 182     int dstx;
 183     int dsty;
 184
 185     //src mat with roi
 186     cv::Mat mat1_roi;
 187     cv::Mat dst_roi;
 188     //std::vector<cv::ocl::Info> oclinfo;
 189     //ocl dst mat for testing
 190     cv::ocl::oclMat gdst_whole;
 191
 192     //ocl mat with roi
 193     cv::ocl::oclMat gmat1;
 194     cv::ocl::oclMat gdst;
 195
 196     virtual void SetUp()
 197     {
 198         type = GET_PARAM(0);
 199         ksize = GET_PARAM(1);
 200         bordertype = GET_PARAM(2);
 201
 202         cv::RNG &rng = TS::ptr()->get_rng();
 203         cv::Size size(MWIDTH, MHEIGHT);
 204
 205         mat1 = randomMat(rng, size, type, 5, 16, false);
 206         dst  = randomMat(rng, size, type, 5, 16, false);
 207         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 208         //CV_Assert(devnums > 0);
 209         ////if you want to use undefault device, set it here
 210         ////setDevice(oclinfo[0]);
 211     }
 212
 213     void random_roi()
 214     {
 215 #ifdef RANDOMROI
 216         //randomize ROI
 217         cv::RNG &rng = TS::ptr()->get_rng();
 218         roicols = rng.uniform(2, mat1.cols);
 219         roirows = rng.uniform(2, mat1.rows);
 220         src1x   = rng.uniform(0, mat1.cols - roicols);
 221         src1y   = rng.uniform(0, mat1.rows - roirows);
 222         dstx    = rng.uniform(0, dst.cols  - roicols);
 223         dsty    = rng.uniform(0, dst.rows  - roirows);
 224 #else
 225         roicols = mat1.cols;
 226         roirows = mat1.rows;
 227         src1x = 0;
 228         src1y = 0;
 229         dstx = 0;
 230         dsty = 0;
 231 #endif
 232
 233         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 234         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 235
 236         gdst_whole = dst;
 237         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 238
 239
 240         gmat1 = mat1_roi;
 241     }
 242
 243 };
 244
 245 TEST_P(Blur, Mat)
 246 {
 247     for(int j = 0; j < LOOP_TIMES; j++)
 248     {
 249         random_roi();
 250
 251         cv::blur(mat1_roi, dst_roi, ksize, Point(-1, -1), bordertype);
 252         cv::ocl::blur(gmat1, gdst, ksize, Point(-1, -1), bordertype);
 253
 254         cv::Mat cpu_dst;
 255         gdst_whole.download(cpu_dst);
 256         char sss[1024];
 257         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 258         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0, sss);
 259     }
 260
 261 }
 262
 263
 264
 265 /////////////////////////////////////////////////////////////////////////////////////////////////
 266 //Laplacian
 267
 268 PARAM_TEST_CASE(LaplacianTestBase, MatType, int)
 269 {
 270     int type;
 271     int ksize;
 272
 273     //src mat
 274     cv::Mat mat;
 275     cv::Mat dst;
 276
 277     // set up roi
 278     int roicols;
 279     int roirows;
 280     int srcx;
 281     int srcy;
 282     int dstx;
 283     int dsty;
 284
 285     //src mat with roi
 286     cv::Mat mat_roi;
 287     cv::Mat dst_roi;
 288     //std::vector<cv::ocl::Info> oclinfo;
 289     //ocl dst mat for testing
 290     cv::ocl::oclMat gdst_whole;
 291
 292     //ocl mat with roi
 293     cv::ocl::oclMat gmat;
 294     cv::ocl::oclMat gdst;
 295
 296     virtual void SetUp()
 297     {
 298         type = GET_PARAM(0);
 299         ksize = GET_PARAM(1);
 300
 301         cv::RNG &rng = TS::ptr()->get_rng();
 302         cv::Size size(MWIDTH, MHEIGHT);
 303
 304         mat  = randomMat(rng, size, type, 5, 16, false);
 305         dst  = randomMat(rng, size, type, 5, 16, false);
 306
 307         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 308         //CV_Assert(devnums > 0);
 309         ////if you want to use undefault device, set it here
 310         ////setDevice(oclinfo[0]);
 311     }
 312
 313     void random_roi()
 314     {
 315 #ifdef RANDOMROI
 316         //randomize ROI
 317         cv::RNG &rng = TS::ptr()->get_rng();
 318         roicols = rng.uniform(2, mat.cols);
 319         roirows = rng.uniform(2, mat.rows);
 320         srcx   = rng.uniform(0, mat.cols - roicols);
 321         srcy   = rng.uniform(0, mat.rows - roirows);
 322         dstx    = rng.uniform(0, dst.cols  - roicols);
 323         dsty    = rng.uniform(0, dst.rows  - roirows);
 324 #else
 325         roicols = mat.cols;
 326         roirows = mat.rows;
 327         srcx = 0;
 328         srcy = 0;
 329         dstx = 0;
 330         dsty = 0;
 331 #endif
 332
 333         mat_roi  = mat(Rect(srcx, srcy, roicols, roirows));
 334         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 335
 336         gdst_whole = dst;
 337         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 338
 339         gmat = mat_roi;
 340     }
 341 };
 342
 343 struct Laplacian : LaplacianTestBase {};
 344
 345 TEST_P(Laplacian, Accuracy)
 346 {
 347     for(int j = 0; j < LOOP_TIMES; j++)
 348     {
 349         random_roi();
 350
 351         cv::Laplacian(mat_roi, dst_roi, -1, ksize, 1);
 352         cv::ocl::Laplacian(gmat, gdst, -1, ksize, 1);
 353
 354         cv::Mat cpu_dst;
 355         gdst_whole.download(cpu_dst);
 356         char sss[1024];
 357         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, srcx, srcy, dstx, dsty);
 358
 359         EXPECT_MAT_NEAR(dst, cpu_dst, 1e-5, sss);
 360     }
 361 }
 362
 363
 364
 365 /////////////////////////////////////////////////////////////////////////////////////////////////
 366 // erode & dilate
 367
 368 PARAM_TEST_CASE(ErodeDilateBase, MatType, int)
 369 {
 370     int type;
 371     int iterations;
 372
 373     //erode or dilate kernel
 374     cv::Mat kernel;
 375
 376     //src mat
 377     cv::Mat mat1;
 378     cv::Mat dst;
 379
 380     // set up roi
 381     int roicols;
 382     int roirows;
 383     int src1x;
 384     int src1y;
 385     int dstx;
 386     int dsty;
 387
 388     //src mat with roi
 389     cv::Mat mat1_roi;
 390     cv::Mat dst_roi;
 391     //std::vector<cv::ocl::Info> oclinfo;
 392     //ocl dst mat for testing
 393     cv::ocl::oclMat gdst_whole;
 394
 395     //ocl mat with roi
 396     cv::ocl::oclMat gmat1;
 397     cv::ocl::oclMat gdst;
 398
 399     virtual void SetUp()
 400     {
 401         type = GET_PARAM(0);
 402         iterations = GET_PARAM(1);
 403
 404         cv::RNG &rng = TS::ptr()->get_rng();
 405         cv::Size size(MWIDTH, MHEIGHT);
 406
 407         mat1 = randomMat(rng, size, type, 5, 16, false);
 408         dst  = randomMat(rng, size, type, 5, 16, false);
 409         //              rng.fill(kernel, cv::RNG::UNIFORM, cv::Scalar::all(0), cv::Scalar::all(3));
 410         kernel = randomMat(rng, Size(3, 3), CV_8UC1, 0, 3, false);
 411
 412     }
 413
 414     void random_roi()
 415     {
 416 #ifdef RANDOMROI
 417         //randomize ROI
 418         cv::RNG &rng = TS::ptr()->get_rng();
 419         roicols = rng.uniform(2, mat1.cols);
 420         roirows = rng.uniform(2, mat1.rows);
 421         src1x   = rng.uniform(0, mat1.cols - roicols);
 422         src1y   = rng.uniform(0, mat1.rows - roirows);
 423         dstx    = rng.uniform(0, dst.cols  - roicols);
 424         dsty    = rng.uniform(0, dst.rows  - roirows);
 425 #else
 426         roicols = mat1.cols;
 427         roirows = mat1.rows;
 428         src1x = 0;
 429         src1y = 0;
 430         dstx = 0;
 431         dsty = 0;
 432 #endif
 433
 434         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 435         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 436
 437         gdst_whole = dst;
 438         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 439
 440
 441         gmat1 = mat1_roi;
 442     }
 443
 444 };
 445
 446 // erode
 447
 448 struct Erode : ErodeDilateBase {};
 449
 450 TEST_P(Erode, Mat)
 451 {
 452     for(int j = 0; j < LOOP_TIMES; j++)
 453     {
 454         random_roi();
 455
 456         cv::erode(mat1_roi, dst_roi, kernel, Point(-1, -1), iterations);
 457         cv::ocl::erode(gmat1, gdst, kernel, Point(-1, -1), iterations);
 458
 459         cv::Mat cpu_dst;
 460         gdst_whole.download(cpu_dst);
 461         char sss[1024];
 462         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 463
 464         EXPECT_MAT_NEAR(dst, cpu_dst, 1e-5, sss);
 465     }
 466
 467 }
 468
 469
 470
 471
 472
 473 // dilate
 474
 475 struct Dilate : ErodeDilateBase {};
 476
 477 TEST_P(Dilate, Mat)
 478 {
 479     for(int j = 0; j < LOOP_TIMES; j++)
 480     {
 481         random_roi();
 482         cv::erode(mat1_roi, dst_roi, kernel, Point(-1, -1), iterations);
 483         cv::ocl::erode(gmat1, gdst, kernel, Point(-1, -1), iterations);
 484
 485         cv::Mat cpu_dst;
 486         gdst_whole.download(cpu_dst);
 487         char sss[1024];
 488         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 489
 490         EXPECT_MAT_NEAR(dst, cpu_dst, 1e-5, sss);
 491     }
 492
 493 }
 494
 495
 496
 497
 498 /////////////////////////////////////////////////////////////////////////////////////////////////
 499 // Sobel
 500
 501 PARAM_TEST_CASE(Sobel, MatType, int, int, int, int)
 502 {
 503     int type;
 504     int dx, dy, ksize, bordertype;
 505
 506     //src mat
 507     cv::Mat mat1;
 508     cv::Mat dst;
 509
 510     // set up roi
 511     int roicols;
 512     int roirows;
 513     int src1x;
 514     int src1y;
 515     int dstx;
 516     int dsty;
 517
 518     //src mat with roi
 519     cv::Mat mat1_roi;
 520     cv::Mat dst_roi;
 521     //std::vector<cv::ocl::Info> oclinfo;
 522     //ocl dst mat for testing
 523     cv::ocl::oclMat gdst_whole;
 524
 525     //ocl mat with roi
 526     cv::ocl::oclMat gmat1;
 527     cv::ocl::oclMat gdst;
 528
 529     virtual void SetUp()
 530     {
 531         type = GET_PARAM(0);
 532         dx = GET_PARAM(1);
 533         dy = GET_PARAM(2);
 534         ksize = GET_PARAM(3);
 535         bordertype = GET_PARAM(4);
 536
 537
 538         cv::RNG &rng = TS::ptr()->get_rng();
 539         cv::Size size(MWIDTH, MHEIGHT);
 540
 541         mat1 = randomMat(rng, size, type, 5, 16, false);
 542         dst  = randomMat(rng, size, type, 5, 16, false);
 543
 544         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 545         //CV_Assert(devnums > 0);
 546         ////if you want to use undefault device, set it here
 547         ////setDevice(oclinfo[0]);
 548     }
 549
 550     void random_roi()
 551     {
 552 #ifdef RANDOMROI
 553         //randomize ROI
 554         cv::RNG &rng = TS::ptr()->get_rng();
 555         roicols = rng.uniform(2, mat1.cols);
 556         roirows = rng.uniform(2, mat1.rows);
 557         src1x   = rng.uniform(0, mat1.cols - roicols);
 558         src1y   = rng.uniform(0, mat1.rows - roirows);
 559         dstx    = rng.uniform(0, dst.cols  - roicols);
 560         dsty    = rng.uniform(0, dst.rows  - roirows);
 561 #else
 562         roicols = mat1.cols;
 563         roirows = mat1.rows;
 564         src1x = 0;
 565         src1y = 0;
 566         dstx = 0;
 567         dsty = 0;
 568 #endif
 569
 570         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 571         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 572
 573         gdst_whole = dst;
 574         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 575
 576
 577         gmat1 = mat1_roi;
 578     }
 579
 580 };
 581
 582 TEST_P(Sobel, Mat)
 583 {
 584     for(int j = 0; j < LOOP_TIMES; j++)
 585     {
 586         random_roi();
 587
 588         cv::Sobel(mat1_roi, dst_roi, -1, dx, dy, ksize, /*scale*/0.00001,/*delta*/0, bordertype);
 589         cv::ocl::Sobel(gmat1, gdst, -1, dx, dy, ksize,/*scale*/0.00001,/*delta*/0, bordertype);
 590
 591         cv::Mat cpu_dst;
 592         gdst_whole.download(cpu_dst);
 593         char sss[1024];
 594         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 595
 596         EXPECT_MAT_NEAR(dst, cpu_dst, 1, sss);
 597     }
 598
 599 }
 600
 601
 602 /////////////////////////////////////////////////////////////////////////////////////////////////
 603 // Scharr
 604
 605 PARAM_TEST_CASE(Scharr, MatType, int, int, int)
 606 {
 607     int type;
 608     int dx, dy, bordertype;
 609
 610     //src mat
 611     cv::Mat mat1;
 612     cv::Mat dst;
 613
 614     // set up roi
 615     int roicols;
 616     int roirows;
 617     int src1x;
 618     int src1y;
 619     int dstx;
 620     int dsty;
 621
 622     //src mat with roi
 623     cv::Mat mat1_roi;
 624     cv::Mat dst_roi;
 625     //std::vector<cv::ocl::Info> oclinfo;
 626     //ocl dst mat for testing
 627     cv::ocl::oclMat gdst_whole;
 628
 629     //ocl mat with roi
 630     cv::ocl::oclMat gmat1;
 631     cv::ocl::oclMat gdst;
 632
 633     virtual void SetUp()
 634     {
 635         type = GET_PARAM(0);
 636         dx = GET_PARAM(1);
 637         dy = GET_PARAM(2);
 638         bordertype = GET_PARAM(3);
 639         dx = 1;
 640         dy = 0;
 641
 642         cv::RNG &rng = TS::ptr()->get_rng();
 643         cv::Size size(MWIDTH, MHEIGHT);
 644
 645         mat1 = randomMat(rng, size, type, 5, 16, false);
 646         dst  = randomMat(rng, size, type, 5, 16, false);
 647
 648         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 649         //CV_Assert(devnums > 0);
 650         ////if you want to use undefault device, set it here
 651         ////setDevice(oclinfo[0]);
 652     }
 653
 654     void random_roi()
 655     {
 656 #ifdef RANDOMROI
 657         //randomize ROI
 658         cv::RNG &rng = TS::ptr()->get_rng();
 659         roicols = rng.uniform(2, mat1.cols);
 660         roirows = rng.uniform(2, mat1.rows);
 661         src1x   = rng.uniform(0, mat1.cols - roicols);
 662         src1y   = rng.uniform(0, mat1.rows - roirows);
 663         dstx    = rng.uniform(0, dst.cols  - roicols);
 664         dsty    = rng.uniform(0, dst.rows  - roirows);
 665 #else
 666         roicols = mat1.cols;
 667         roirows = mat1.rows;
 668         src1x = 0;
 669         src1y = 0;
 670         dstx = 0;
 671         dsty = 0;
 672 #endif
 673
 674         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 675         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 676
 677         gdst_whole = dst;
 678         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 679
 680
 681         gmat1 = mat1_roi;
 682     }
 683
 684 };
 685
 686 TEST_P(Scharr, Mat)
 687 {
 688     for(int j = 0; j < LOOP_TIMES; j++)
 689     {
 690         random_roi();
 691
 692         cv::Scharr(mat1_roi, dst_roi, -1, dx, dy, /*scale*/1,/*delta*/0, bordertype);
 693         cv::ocl::Scharr(gmat1, gdst, -1, dx, dy,/*scale*/1,/*delta*/0, bordertype);
 694
 695         cv::Mat cpu_dst;
 696         gdst_whole.download(cpu_dst);
 697         char sss[1024];
 698         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 699
 700         EXPECT_MAT_NEAR(dst, cpu_dst, 1, sss);
 701     }
 702
 703 }
 704
 705
 706 /////////////////////////////////////////////////////////////////////////////////////////////////
 707 // GaussianBlur
 708
 709 PARAM_TEST_CASE(GaussianBlur, MatType, cv::Size, int)
 710 {
 711     int type;
 712     cv::Size ksize;
 713     int bordertype;
 714
 715     double sigma1, sigma2;
 716
 717     //src mat
 718     cv::Mat mat1;
 719     cv::Mat dst;
 720
 721     // set up roi
 722     int roicols;
 723     int roirows;
 724     int src1x;
 725     int src1y;
 726     int dstx;
 727     int dsty;
 728
 729     //src mat with roi
 730     cv::Mat mat1_roi;
 731     cv::Mat dst_roi;
 732     //std::vector<cv::ocl::Info> oclinfo;
 733     //ocl dst mat for testing
 734     cv::ocl::oclMat gdst_whole;
 735
 736     //ocl mat with roi
 737     cv::ocl::oclMat gmat1;
 738     cv::ocl::oclMat gdst;
 739
 740     virtual void SetUp()
 741     {
 742         type = GET_PARAM(0);
 743         ksize = GET_PARAM(1);
 744         bordertype = GET_PARAM(2);
 745
 746         cv::RNG &rng = TS::ptr()->get_rng();
 747         cv::Size size(MWIDTH, MHEIGHT);
 748
 749         sigma1 = rng.uniform(0.1, 1.0);
 750         sigma2 = rng.uniform(0.1, 1.0);
 751
 752         mat1 = randomMat(rng, size, type, 5, 16, false);
 753         dst  = randomMat(rng, size, type, 5, 16, false);
 754
 755         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 756         //CV_Assert(devnums > 0);
 757         ////if you want to use undefault device, set it here
 758         ////setDevice(oclinfo[0]);
 759     }
 760
 761     void random_roi()
 762     {
 763 #ifdef RANDOMROI
 764         //randomize ROI
 765         cv::RNG &rng = TS::ptr()->get_rng();
 766         roicols = rng.uniform(2, mat1.cols);
 767         roirows = rng.uniform(2, mat1.rows);
 768         src1x   = rng.uniform(0, mat1.cols - roicols);
 769         src1y   = rng.uniform(0, mat1.rows - roirows);
 770         dstx    = rng.uniform(0, dst.cols  - roicols);
 771         dsty    = rng.uniform(0, dst.rows  - roirows);
 772 #else
 773         roicols = mat1.cols;
 774         roirows = mat1.rows;
 775         src1x = 0;
 776         src1y = 0;
 777         dstx = 0;
 778         dsty = 0;
 779 #endif
 780
 781         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 782         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 783
 784         gdst_whole = dst;
 785         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 786
 787
 788         gmat1 = mat1_roi;
 789     }
 790
 791 };
 792
 793 TEST_P(GaussianBlur, Mat)
 794 {
 795     for(int j = 0; j < LOOP_TIMES; j++)
 796     {
 797         random_roi();
 798
 799         cv::GaussianBlur(mat1_roi, dst_roi, ksize, sigma1, sigma2, bordertype);
 800         cv::ocl::GaussianBlur(gmat1, gdst, ksize, sigma1, sigma2, bordertype);
 801
 802         cv::Mat cpu_dst;
 803         gdst_whole.download(cpu_dst);
 804         char sss[1024];
 805         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 806
 807         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0, sss);
 808     }
 809
 810 }
 811
 812
 813
 814 INSTANTIATE_TEST_CASE_P(Filter, Blur, Combine(Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 815                         Values(cv::Size(3, 3), cv::Size(5, 5), cv::Size(7, 7)),
 816                         Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE, (MatType)cv::BORDER_REFLECT, (MatType)cv::BORDER_REFLECT_101)));
 817
 818
 819 INSTANTIATE_TEST_CASE_P(Filters, Laplacian, Combine(
 820                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
 821                             Values(1, 3)));
 822
 823 INSTANTIATE_TEST_CASE_P(Filter, Erode, Combine(Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1)));
 824
 825 //INSTANTIATE_TEST_CASE_P(Filter, Erode, Combine(Values(CV_8UC1, CV_8UC1), Values(false)));
 826
 827 INSTANTIATE_TEST_CASE_P(Filter, Dilate, Combine(Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1)));
 828
 829 //INSTANTIATE_TEST_CASE_P(Filter, Dilate, Combine(Values(CV_8UC1, CV_8UC1), Values(false)));
 830
 831
 832 INSTANTIATE_TEST_CASE_P(Filter, Sobel, Combine(Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
 833                         Values(1, 2), Values(0, 1), Values(3, 5), Values((MatType)cv::BORDER_CONSTANT,
 834                                 (MatType)cv::BORDER_REPLICATE)));
 835
 836
 837 INSTANTIATE_TEST_CASE_P(Filter, Scharr, Combine(
 838                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4), Values(0, 1), Values(0, 1),
 839                             Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 840
 841 INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, Combine(
 842                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 843                             Values(cv::Size(3, 3), cv::Size(5, 5)),
 844                             Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 845
 846
 847
 848 #endif // HAVE_OPENCL