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, bool)
 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         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 413         //CV_Assert(devnums > 0);
 414         ////if you want to use undefault device, set it here
 415         ////setDevice(oclinfo[0]);
 416     }
 417
 418     void random_roi()
 419     {
 420 #ifdef RANDOMROI
 421         //randomize ROI
 422         cv::RNG &rng = TS::ptr()->get_rng();
 423         roicols = rng.uniform(2, mat1.cols);
 424         roirows = rng.uniform(2, mat1.rows);
 425         src1x   = rng.uniform(0, mat1.cols - roicols);
 426         src1y   = rng.uniform(0, mat1.rows - roirows);
 427         dstx    = rng.uniform(0, dst.cols  - roicols);
 428         dsty    = rng.uniform(0, dst.rows  - roirows);
 429 #else
 430         roicols = mat1.cols;
 431         roirows = mat1.rows;
 432         src1x = 0;
 433         src1y = 0;
 434         dstx = 0;
 435         dsty = 0;
 436 #endif
 437
 438         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 439         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 440
 441         gdst_whole = dst;
 442         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 443
 444
 445         gmat1 = mat1_roi;
 446     }
 447
 448 };
 449
 450 // erode
 451
 452 struct Erode : ErodeDilateBase {};
 453
 454 TEST_P(Erode, Mat)
 455 {
 456     for(int j = 0; j < LOOP_TIMES; j++)
 457     {
 458         random_roi();
 459         //int iterations =3;
 460         //cv::erode(mat1_roi, dst_roi, kernel, Point(-1, -1), iterations);
 461         //cv::ocl::erode(gmat1, gdst, kernel, Point(-1, -1), iterations);
 462
 463         cv::erode(mat1_roi, dst_roi, kernel);
 464         cv::ocl::erode(gmat1, gdst, kernel);
 465
 466         cv::Mat cpu_dst;
 467         gdst_whole.download(cpu_dst);
 468         char sss[1024];
 469         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 470
 471         EXPECT_MAT_NEAR(dst, cpu_dst, 1e-5, sss);
 472     }
 473
 474 }
 475
 476
 477
 478
 479
 480 // dilate
 481
 482 struct Dilate : ErodeDilateBase {};
 483
 484 TEST_P(Dilate, Mat)
 485 {
 486     for(int j = 0; j < LOOP_TIMES; j++)
 487     {
 488         random_roi();
 489         //int iterations =3;
 490         //      cv::erode(mat1_roi, dst_roi, kernel, Point(-1, -1), iterations);
 491         //      cv::ocl::erode(gmat1, gdst, kernel, Point(-1, -1), iterations);
 492
 493         cv::dilate(mat1_roi, dst_roi, kernel);
 494         cv::ocl::dilate(gmat1, gdst, kernel);
 495
 496         cv::Mat cpu_dst;
 497         gdst_whole.download(cpu_dst);
 498         char sss[1024];
 499         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 500
 501         EXPECT_MAT_NEAR(dst, cpu_dst, 1e-5, sss);
 502     }
 503
 504 }
 505
 506
 507
 508
 509 /////////////////////////////////////////////////////////////////////////////////////////////////
 510 // Sobel
 511
 512 PARAM_TEST_CASE(Sobel, MatType, int, int, int, int)
 513 {
 514     int type;
 515     int dx, dy, ksize, bordertype;
 516
 517     //src mat
 518     cv::Mat mat1;
 519     cv::Mat dst;
 520
 521     // set up roi
 522     int roicols;
 523     int roirows;
 524     int src1x;
 525     int src1y;
 526     int dstx;
 527     int dsty;
 528
 529     //src mat with roi
 530     cv::Mat mat1_roi;
 531     cv::Mat dst_roi;
 532     //std::vector<cv::ocl::Info> oclinfo;
 533     //ocl dst mat for testing
 534     cv::ocl::oclMat gdst_whole;
 535
 536     //ocl mat with roi
 537     cv::ocl::oclMat gmat1;
 538     cv::ocl::oclMat gdst;
 539
 540     virtual void SetUp()
 541     {
 542         type = GET_PARAM(0);
 543         dx = GET_PARAM(1);
 544         dy = GET_PARAM(2);
 545         ksize = GET_PARAM(3);
 546         bordertype = GET_PARAM(4);
 547
 548
 549         cv::RNG &rng = TS::ptr()->get_rng();
 550         cv::Size size(MWIDTH, MHEIGHT);
 551
 552         mat1 = randomMat(rng, size, type, 5, 16, false);
 553         dst  = randomMat(rng, size, type, 5, 16, false);
 554
 555         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 556         //CV_Assert(devnums > 0);
 557         ////if you want to use undefault device, set it here
 558         ////setDevice(oclinfo[0]);
 559     }
 560
 561     void random_roi()
 562     {
 563 #ifdef RANDOMROI
 564         //randomize ROI
 565         cv::RNG &rng = TS::ptr()->get_rng();
 566         roicols = rng.uniform(2, mat1.cols);
 567         roirows = rng.uniform(2, mat1.rows);
 568         src1x   = rng.uniform(0, mat1.cols - roicols);
 569         src1y   = rng.uniform(0, mat1.rows - roirows);
 570         dstx    = rng.uniform(0, dst.cols  - roicols);
 571         dsty    = rng.uniform(0, dst.rows  - roirows);
 572 #else
 573         roicols = mat1.cols;
 574         roirows = mat1.rows;
 575         src1x = 0;
 576         src1y = 0;
 577         dstx = 0;
 578         dsty = 0;
 579 #endif
 580
 581         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 582         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 583
 584         gdst_whole = dst;
 585         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 586
 587
 588         gmat1 = mat1_roi;
 589     }
 590
 591 };
 592
 593 TEST_P(Sobel, Mat)
 594 {
 595     for(int j = 0; j < LOOP_TIMES; j++)
 596     {
 597         random_roi();
 598
 599         cv::Sobel(mat1_roi, dst_roi, -1, dx, dy, ksize, /*scale*/0.00001,/*delta*/0, bordertype);
 600         cv::ocl::Sobel(gmat1, gdst, -1, dx, dy, ksize,/*scale*/0.00001,/*delta*/0, bordertype);
 601
 602         cv::Mat cpu_dst;
 603         gdst_whole.download(cpu_dst);
 604         char sss[1024];
 605         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 606
 607         EXPECT_MAT_NEAR(dst, cpu_dst, 1, sss);
 608     }
 609
 610 }
 611
 612
 613 /////////////////////////////////////////////////////////////////////////////////////////////////
 614 // Scharr
 615
 616 PARAM_TEST_CASE(Scharr, MatType, int, int, int)
 617 {
 618     int type;
 619     int dx, dy, bordertype;
 620
 621     //src mat
 622     cv::Mat mat1;
 623     cv::Mat dst;
 624
 625     // set up roi
 626     int roicols;
 627     int roirows;
 628     int src1x;
 629     int src1y;
 630     int dstx;
 631     int dsty;
 632
 633     //src mat with roi
 634     cv::Mat mat1_roi;
 635     cv::Mat dst_roi;
 636     //std::vector<cv::ocl::Info> oclinfo;
 637     //ocl dst mat for testing
 638     cv::ocl::oclMat gdst_whole;
 639
 640     //ocl mat with roi
 641     cv::ocl::oclMat gmat1;
 642     cv::ocl::oclMat gdst;
 643
 644     virtual void SetUp()
 645     {
 646         type = GET_PARAM(0);
 647         dx = GET_PARAM(1);
 648         dy = GET_PARAM(2);
 649         bordertype = GET_PARAM(3);
 650         dx = 1;
 651         dy = 0;
 652
 653         cv::RNG &rng = TS::ptr()->get_rng();
 654         cv::Size size(MWIDTH, MHEIGHT);
 655
 656         mat1 = randomMat(rng, size, type, 5, 16, false);
 657         dst  = randomMat(rng, size, type, 5, 16, false);
 658
 659         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 660         //CV_Assert(devnums > 0);
 661         ////if you want to use undefault device, set it here
 662         ////setDevice(oclinfo[0]);
 663     }
 664
 665     void random_roi()
 666     {
 667 #ifdef RANDOMROI
 668         //randomize ROI
 669         cv::RNG &rng = TS::ptr()->get_rng();
 670         roicols = rng.uniform(2, mat1.cols);
 671         roirows = rng.uniform(2, mat1.rows);
 672         src1x   = rng.uniform(0, mat1.cols - roicols);
 673         src1y   = rng.uniform(0, mat1.rows - roirows);
 674         dstx    = rng.uniform(0, dst.cols  - roicols);
 675         dsty    = rng.uniform(0, dst.rows  - roirows);
 676 #else
 677         roicols = mat1.cols;
 678         roirows = mat1.rows;
 679         src1x = 0;
 680         src1y = 0;
 681         dstx = 0;
 682         dsty = 0;
 683 #endif
 684
 685         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 686         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 687
 688         gdst_whole = dst;
 689         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 690
 691
 692         gmat1 = mat1_roi;
 693     }
 694
 695 };
 696
 697 TEST_P(Scharr, Mat)
 698 {
 699     for(int j = 0; j < LOOP_TIMES; j++)
 700     {
 701         random_roi();
 702
 703         cv::Scharr(mat1_roi, dst_roi, -1, dx, dy, /*scale*/1,/*delta*/0, bordertype);
 704         cv::ocl::Scharr(gmat1, gdst, -1, dx, dy,/*scale*/1,/*delta*/0, bordertype);
 705
 706         cv::Mat cpu_dst;
 707         gdst_whole.download(cpu_dst);
 708         char sss[1024];
 709         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 710
 711         EXPECT_MAT_NEAR(dst, cpu_dst, 1, sss);
 712     }
 713
 714 }
 715
 716
 717 /////////////////////////////////////////////////////////////////////////////////////////////////
 718 // GaussianBlur
 719
 720 PARAM_TEST_CASE(GaussianBlur, MatType, cv::Size, int)
 721 {
 722     int type;
 723     cv::Size ksize;
 724     int bordertype;
 725
 726     double sigma1, sigma2;
 727
 728     //src mat
 729     cv::Mat mat1;
 730     cv::Mat dst;
 731
 732     // set up roi
 733     int roicols;
 734     int roirows;
 735     int src1x;
 736     int src1y;
 737     int dstx;
 738     int dsty;
 739
 740     //src mat with roi
 741     cv::Mat mat1_roi;
 742     cv::Mat dst_roi;
 743     //std::vector<cv::ocl::Info> oclinfo;
 744     //ocl dst mat for testing
 745     cv::ocl::oclMat gdst_whole;
 746
 747     //ocl mat with roi
 748     cv::ocl::oclMat gmat1;
 749     cv::ocl::oclMat gdst;
 750
 751     virtual void SetUp()
 752     {
 753         type = GET_PARAM(0);
 754         ksize = GET_PARAM(1);
 755         bordertype = GET_PARAM(2);
 756
 757         cv::RNG &rng = TS::ptr()->get_rng();
 758         cv::Size size(MWIDTH, MHEIGHT);
 759
 760         sigma1 = rng.uniform(0.1, 1.0);
 761         sigma2 = rng.uniform(0.1, 1.0);
 762
 763         mat1 = randomMat(rng, size, type, 5, 16, false);
 764         dst  = randomMat(rng, size, type, 5, 16, false);
 765
 766         //int devnums = getDevice(oclinfo, OPENCV_DEFAULT_OPENCL_DEVICE);
 767         //CV_Assert(devnums > 0);
 768         ////if you want to use undefault device, set it here
 769         ////setDevice(oclinfo[0]);
 770     }
 771
 772     void random_roi()
 773     {
 774 #ifdef RANDOMROI
 775         //randomize ROI
 776         cv::RNG &rng = TS::ptr()->get_rng();
 777         roicols = rng.uniform(2, mat1.cols);
 778         roirows = rng.uniform(2, mat1.rows);
 779         src1x   = rng.uniform(0, mat1.cols - roicols);
 780         src1y   = rng.uniform(0, mat1.rows - roirows);
 781         dstx    = rng.uniform(0, dst.cols  - roicols);
 782         dsty    = rng.uniform(0, dst.rows  - roirows);
 783 #else
 784         roicols = mat1.cols;
 785         roirows = mat1.rows;
 786         src1x = 0;
 787         src1y = 0;
 788         dstx = 0;
 789         dsty = 0;
 790 #endif
 791
 792         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 793         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 794
 795         gdst_whole = dst;
 796         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 797
 798
 799         gmat1 = mat1_roi;
 800     }
 801
 802 };
 803
 804 TEST_P(GaussianBlur, Mat)
 805 {
 806     for(int j = 0; j < LOOP_TIMES; j++)
 807     {
 808         random_roi();
 809
 810         cv::GaussianBlur(mat1_roi, dst_roi, ksize, sigma1, sigma2, bordertype);
 811         cv::ocl::GaussianBlur(gmat1, gdst, ksize, sigma1, sigma2, bordertype);
 812
 813         cv::Mat cpu_dst;
 814         gdst_whole.download(cpu_dst);
 815         char sss[1024];
 816         sprintf(sss, "roicols=%d,roirows=%d,src1x=%d,src1y=%d,dstx=%d,dsty=%d", roicols, roirows, src1x, src1y, dstx, dsty);
 817
 818         EXPECT_MAT_NEAR(dst, cpu_dst, 1.0, sss);
 819     }
 820
 821 }
 822
 823
 824
 825 INSTANTIATE_TEST_CASE_P(Filter, Blur, Combine(Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 826                         Values(cv::Size(3, 3), cv::Size(5, 5), cv::Size(7, 7)),
 827                         Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE, (MatType)cv::BORDER_REFLECT, (MatType)cv::BORDER_REFLECT_101)));
 828
 829
 830 INSTANTIATE_TEST_CASE_P(Filters, Laplacian, Combine(
 831                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
 832                             Values(1, 3)));
 833
 834 INSTANTIATE_TEST_CASE_P(Filter, Erode, Combine(Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1, 2, 3)));
 835
 836 //INSTANTIATE_TEST_CASE_P(Filter, Erode, Combine(Values(CV_8UC1, CV_8UC1), Values(false)));
 837
 838 INSTANTIATE_TEST_CASE_P(Filter, Dilate, Combine(Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1, 2, 3)));
 839
 840 //INSTANTIATE_TEST_CASE_P(Filter, Dilate, Combine(Values(CV_8UC1, CV_8UC1), Values(false)));
 841
 842
 843 INSTANTIATE_TEST_CASE_P(Filter, Sobel, Combine(Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
 844                         Values(1, 2), Values(0, 1), Values(3, 5), Values((MatType)cv::BORDER_CONSTANT,
 845                                 (MatType)cv::BORDER_REPLICATE)));
 846
 847
 848 INSTANTIATE_TEST_CASE_P(Filter, Scharr, Combine(
 849                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4), Values(0, 1), Values(0, 1),
 850                             Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 851
 852 INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, Combine(
 853                             Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 854                             Values(cv::Size(3, 3), cv::Size(5, 5)),
 855                             Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 856
 857
 858
 859 #endif // HAVE_OPENCL