modules/core/test/ocl/test_arithm.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-2013, Advanced Micro Devices, Inc., all rights reserved.
  14 // Third party copyrights are property of their respective owners.
  15 //
  16 // Redistribution and use in source and binary forms, with or without modification,
  17 // are permitted provided that the following conditions are met:
  18 //
  19 //   * Redistribution's of source code must retain the above copyright notice,
  20 //     this list of conditions and the following disclaimer.
  21 //
  22 //   * Redistribution's in binary form must reproduce the above copyright notice,
  23 //     this list of conditions and the following disclaimer in the documentation
  24 //     and/or other materials provided with the distribution.
  25 //
  26 //   * The name of the copyright holders may not be used to endorse or promote products
  27 //     derived from this software without specific prior written permission.
  28 //
  29 // This software is provided by the copyright holders and contributors "as is" and
  30 // any express or implied warranties, including, but not limited to, the implied
  31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  32 // In no event shall the OpenCV Foundation or contributors be liable for any direct,
  33 // indirect, incidental, special, exemplary, or consequential damages
  34 // (including, but not limited to, procurement of substitute goods or services;
  35 // loss of use, data, or profits; or business interruption) however caused
  36 // and on any theory of liability, whether in contract, strict liability,
  37 // or tort (including negligence or otherwise) arising in any way out of
  38 // the use of this software, even if advised of the possibility of such damage.
  39 //
  40 //M*/
  41
  42 #include "test_precomp.hpp"
  43 #include "opencv2/ts/ocl_test.hpp"
  44
  45 #include <cmath>
  46
  47 #ifdef HAVE_OPENCL
  48
  49 namespace cvtest {
  50 namespace ocl {
  51
  52 //////////////////////////////// LUT /////////////////////////////////////////////////
  53
  54 PARAM_TEST_CASE(Lut, MatDepth, MatDepth, Channels, bool, bool)
  55 {
  56     int src_depth, lut_depth;
  57     int cn;
  58     bool use_roi, same_cn;
  59
  60     TEST_DECLARE_INPUT_PARAMETER(src)
  61     TEST_DECLARE_INPUT_PARAMETER(lut)
  62     TEST_DECLARE_OUTPUT_PARAMETER(dst)
  63
  64     virtual void SetUp()
  65     {
  66         src_depth = GET_PARAM(0);
  67         lut_depth = GET_PARAM(1);
  68         cn = GET_PARAM(2);
  69         same_cn = GET_PARAM(3);
  70         use_roi = GET_PARAM(4);
  71     }
  72
  73     void generateTestData()
  74     {
  75         const int src_type = CV_MAKE_TYPE(src_depth, cn);
  76         const int lut_type = CV_MAKE_TYPE(lut_depth, same_cn ? cn : 1);
  77         const int dst_type = CV_MAKE_TYPE(lut_depth, cn);
  78
  79         Size roiSize = randomSize(1, MAX_VALUE);
  80         Border srcBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
  81         randomSubMat(src, src_roi, roiSize, srcBorder, src_type, 0, 256);
  82
  83         Size lutRoiSize = Size(256, 1);
  84         Border lutBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
  85         randomSubMat(lut, lut_roi, lutRoiSize, lutBorder, lut_type, 5, 16);
  86
  87         Border dstBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
  88         randomSubMat(dst, dst_roi, roiSize, dstBorder, dst_type, 5, 16);
  89
  90         UMAT_UPLOAD_INPUT_PARAMETER(src)
  91         UMAT_UPLOAD_INPUT_PARAMETER(lut)
  92         UMAT_UPLOAD_OUTPUT_PARAMETER(dst)
  93     }
  94
  95     void Near(double threshold = 0.)
  96     {
  97         OCL_EXPECT_MATS_NEAR(dst, threshold)
  98     }
  99 };
 100
 101 OCL_TEST_P(Lut, Mat)
 102 {
 103     for (int j = 0; j < test_loop_times; j++)
 104     {
 105         generateTestData();
 106
 107         OCL_OFF(cv::LUT(src_roi, lut_roi, dst_roi));
 108         OCL_ON(cv::LUT(usrc_roi, ulut_roi, udst_roi));
 109
 110         Near();
 111     }
 112 }
 113
 114 ///////////////////////// ArithmTestBase ///////////////////////////
 115
 116 PARAM_TEST_CASE(ArithmTestBase, MatDepth, Channels, bool)
 117 {
 118     int depth;
 119     int cn;
 120     bool use_roi;
 121     cv::Scalar val;
 122     cv::Scalar val_in_range;
 123
 124     TEST_DECLARE_INPUT_PARAMETER(src1)
 125     TEST_DECLARE_INPUT_PARAMETER(src2)
 126     TEST_DECLARE_INPUT_PARAMETER(mask)
 127     TEST_DECLARE_OUTPUT_PARAMETER(dst1)
 128     TEST_DECLARE_OUTPUT_PARAMETER(dst2)
 129
 130     virtual void SetUp()
 131     {
 132         depth = GET_PARAM(0);
 133         cn = GET_PARAM(1);
 134         use_roi = GET_PARAM(2);
 135     }
 136
 137     virtual void generateTestData()
 138     {
 139         const int type = CV_MAKE_TYPE(depth, cn);
 140
 141         double minV = getMinVal(type);
 142         double maxV = getMaxVal(type);
 143
 144         Size roiSize = randomSize(1, MAX_VALUE);
 145         Border src1Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
 146         randomSubMat(src1, src1_roi, roiSize, src1Border, type, minV, maxV);
 147
 148         Border src2Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
 149         randomSubMat(src2, src2_roi, roiSize, src2Border, type, std::max(-1540., minV), std::min(1740., maxV));
 150
 151         Border dst1Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
 152         randomSubMat(dst1, dst1_roi, roiSize, dst1Border, type, 5, 16);
 153
 154         Border dst2Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
 155         randomSubMat(dst2, dst2_roi, roiSize, dst2Border, type, 5, 16);
 156
 157         Border maskBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
 158         randomSubMat(mask, mask_roi, roiSize, maskBorder, CV_8UC1, 0, 2);
 159         cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
 160
 161         val = cv::Scalar(rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0),
 162                          rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0));
 163
 164         val_in_range = cv::Scalar(rng.uniform(minV, maxV), rng.uniform(minV, maxV),
 165                                   rng.uniform(minV, maxV), rng.uniform(minV, maxV));
 166
 167         UMAT_UPLOAD_INPUT_PARAMETER(src1)
 168         UMAT_UPLOAD_INPUT_PARAMETER(src2)
 169         UMAT_UPLOAD_INPUT_PARAMETER(mask)
 170         UMAT_UPLOAD_OUTPUT_PARAMETER(dst1)
 171         UMAT_UPLOAD_OUTPUT_PARAMETER(dst2)
 172     }
 173
 174     void Near(double threshold = 0.)
 175     {
 176         OCL_EXPECT_MATS_NEAR(dst1, threshold)
 177     }
 178
 179     void Near1(double threshold = 0.)
 180     {
 181         OCL_EXPECT_MATS_NEAR(dst2, threshold)
 182     }
 183 };
 184
 185 //////////////////////////////// Add /////////////////////////////////////////////////
 186
 187 typedef ArithmTestBase Add;
 188
 189 OCL_TEST_P(Add, Mat)
 190 {
 191     for (int j = 0; j < test_loop_times; j++)
 192     {
 193         generateTestData();
 194
 195         OCL_OFF(cv::add(src1_roi, src2_roi, dst1_roi));
 196         OCL_ON(cv::add(usrc1_roi, usrc2_roi, udst1_roi));
 197         Near(0);
 198     }
 199 }
 200
 201 OCL_TEST_P(Add, Mat_Mask)
 202 {
 203     for (int j = 0; j < test_loop_times; j++)
 204     {
 205         generateTestData();
 206
 207         OCL_OFF(cv::add(src1_roi, src2_roi, dst1_roi, mask_roi));
 208         OCL_ON(cv::add(usrc1_roi, usrc2_roi, udst1_roi, umask_roi));
 209         Near(0);
 210     }
 211 }
 212
 213 OCL_TEST_P(Add, Scalar)
 214 {
 215     for (int j = 0; j < test_loop_times; j++)
 216     {
 217         generateTestData();
 218
 219         OCL_OFF(cv::add(src1_roi, val, dst1_roi));
 220         OCL_ON(cv::add(val, usrc1_roi, udst1_roi));
 221         Near(1e-5);
 222     }
 223 }
 224
 225 OCL_TEST_P(Add, Scalar_Mask)
 226 {
 227     for (int j = 0; j < test_loop_times; j++)
 228     {
 229         generateTestData();
 230
 231         OCL_OFF(cv::add(src1_roi, val, dst1_roi, mask_roi));
 232         OCL_ON(cv::add(usrc1_roi, val, udst1_roi, umask_roi));
 233         Near(1e-5);
 234     }
 235 }
 236
 237 //////////////////////////////////////// Subtract //////////////////////////////////////////////
 238
 239 typedef ArithmTestBase Subtract;
 240
 241 OCL_TEST_P(Subtract, Mat)
 242 {
 243     for (int j = 0; j < test_loop_times; j++)
 244     {
 245         generateTestData();
 246
 247         OCL_OFF(cv::subtract(src1_roi, src2_roi, dst1_roi));
 248         OCL_ON(cv::subtract(usrc1_roi, usrc2_roi, udst1_roi));
 249         Near(0);
 250     }
 251 }
 252
 253 OCL_TEST_P(Subtract, Mat_Mask)
 254 {
 255     for (int j = 0; j < test_loop_times; j++)
 256     {
 257         generateTestData();
 258
 259         OCL_OFF(cv::subtract(src1_roi, src2_roi, dst1_roi, mask_roi));
 260         OCL_ON(cv::subtract(usrc1_roi, usrc2_roi, udst1_roi, umask_roi));
 261         Near(0);
 262     }
 263 }
 264
 265 OCL_TEST_P(Subtract, Scalar)
 266 {
 267     for (int j = 0; j < test_loop_times; j++)
 268     {
 269         generateTestData();
 270
 271         OCL_OFF(cv::subtract(val, src1_roi, dst1_roi));
 272         OCL_ON(cv::subtract(val, usrc1_roi, udst1_roi));
 273         Near(1e-5);
 274     }
 275 }
 276
 277 OCL_TEST_P(Subtract, Scalar_Mask)
 278 {
 279     for (int j = 0; j < test_loop_times; j++)
 280     {
 281         generateTestData();
 282
 283         OCL_OFF(cv::subtract(src1_roi, val, dst1_roi, mask_roi));
 284         OCL_ON(cv::subtract(usrc1_roi, val, udst1_roi, umask_roi));
 285         Near(1e-5);
 286     }
 287 }
 288
 289 //////////////////////////////// Mul /////////////////////////////////////////////////
 290
 291 typedef ArithmTestBase Mul;
 292
 293 OCL_TEST_P(Mul, Mat)
 294 {
 295     for (int j = 0; j < test_loop_times; j++)
 296     {
 297         generateTestData();
 298
 299         OCL_OFF(cv::multiply(src1_roi, src2_roi, dst1_roi));
 300         OCL_ON(cv::multiply(usrc1_roi, usrc2_roi, udst1_roi));
 301         Near(0);
 302     }
 303 }
 304
 305 OCL_TEST_P(Mul, Scalar)
 306 {
 307     for (int j = 0; j < test_loop_times; j++)
 308     {
 309         generateTestData();
 310
 311         OCL_OFF(cv::multiply(src1_roi, val, dst1_roi));
 312         OCL_ON(cv::multiply(val, usrc1_roi, udst1_roi));
 313
 314         Near(udst1_roi.depth() >= CV_32F ? 1e-3 : 1);
 315     }
 316 }
 317
 318 OCL_TEST_P(Mul, Mat_Scale)
 319 {
 320     for (int j = 0; j < test_loop_times; j++)
 321     {
 322         generateTestData();
 323
 324         OCL_OFF(cv::multiply(src1_roi, src2_roi, dst1_roi, val[0]));
 325         OCL_ON(cv::multiply(usrc1_roi, usrc2_roi, udst1_roi, val[0]));
 326
 327         Near(udst1_roi.depth() >= CV_32F ? 1e-3 : 1);
 328     }
 329 }
 330
 331 OCL_TEST_P(Mul, Mat_Scalar_Scale)
 332 {
 333     for (int j = 0; j < test_loop_times; j++)
 334     {
 335         generateTestData();
 336
 337         OCL_OFF(cv::multiply(src1_roi, val, dst1_roi, val[0]));
 338         OCL_ON(cv::multiply(usrc1_roi, val, udst1_roi, val[0]));
 339
 340         Near(udst1_roi.depth() >= CV_32F ? 1e-2 : 1);
 341     }
 342 }
 343
 344
 345 //////////////////////////////// Div /////////////////////////////////////////////////
 346
 347 typedef ArithmTestBase Div;
 348
 349 OCL_TEST_P(Div, Mat)
 350 {
 351     for (int j = 0; j < test_loop_times; j++)
 352     {
 353         generateTestData();
 354
 355         OCL_OFF(cv::divide(src1_roi, src2_roi, dst1_roi));
 356         OCL_ON(cv::divide(usrc1_roi, usrc2_roi, udst1_roi));
 357         Near(1);
 358     }
 359 }
 360
 361 OCL_TEST_P(Div, Scalar)
 362 {
 363     for (int j = 0; j < test_loop_times; j++)
 364     {
 365         generateTestData();
 366
 367         OCL_OFF(cv::divide(val, src1_roi, dst1_roi));
 368         OCL_ON(cv::divide(val, usrc1_roi, udst1_roi));
 369
 370         Near(udst1_roi.depth() >= CV_32F ? 1e-3 : 1);
 371     }
 372 }
 373
 374 OCL_TEST_P(Div, Scalar2)
 375 {
 376     for (int j = 0; j < test_loop_times; j++)
 377     {
 378         generateTestData();
 379
 380         OCL_OFF(cv::divide(src1_roi, val, dst1_roi));
 381         OCL_ON(cv::divide(usrc1_roi, val, udst1_roi));
 382
 383         Near(udst1_roi.depth() >= CV_32F ? 1e-3 : 1);
 384     }
 385 }
 386
 387 OCL_TEST_P(Div, Mat_Scale)
 388 {
 389     for (int j = 0; j < test_loop_times; j++)
 390     {
 391         generateTestData();
 392
 393         OCL_OFF(cv::divide(src1_roi, src2_roi, dst1_roi, val[0]));
 394         OCL_ON(cv::divide(usrc1_roi, usrc2_roi, udst1_roi, val[0]));
 395
 396         Near(udst1_roi.depth() >= CV_32F ? 4e-3 : 1);
 397     }
 398 }
 399
 400 OCL_TEST_P(Div, Mat_Scalar_Scale)
 401 {
 402     for (int j = 0; j < test_loop_times; j++)
 403     {
 404         generateTestData();
 405
 406         OCL_OFF(cv::divide(src1_roi, val, dst1_roi, val[0]));
 407         OCL_ON(cv::divide(usrc1_roi, val, udst1_roi, val[0]));
 408
 409         Near(udst1_roi.depth() >= CV_32F ? 4e-3 : 1);
 410     }
 411 }
 412
 413 OCL_TEST_P(Div, Recip)
 414 {
 415     for (int j = 0; j < test_loop_times; j++)
 416     {
 417         generateTestData();
 418
 419         OCL_OFF(cv::divide(val[0], src1_roi, dst1_roi));
 420         OCL_ON(cv::divide(val[0], usrc1_roi, udst1_roi));
 421
 422         Near(udst1_roi.depth() >= CV_32F ? 1e-3 : 1);
 423     }
 424 }
 425
 426 //////////////////////////////// Min/Max /////////////////////////////////////////////////
 427
 428 typedef ArithmTestBase Min;
 429
 430 OCL_TEST_P(Min, Mat)
 431 {
 432     for (int j = 0; j < test_loop_times; j++)
 433     {
 434         generateTestData();
 435
 436         OCL_OFF(cv::max(src1_roi, src2_roi, dst1_roi));
 437         OCL_ON(cv::max(usrc1_roi, usrc2_roi, udst1_roi));
 438         Near(0);
 439     }
 440 }
 441
 442 typedef ArithmTestBase Max;
 443
 444 OCL_TEST_P(Max, Mat)
 445 {
 446     for (int j = 0; j < test_loop_times; j++)
 447     {
 448         generateTestData();
 449
 450         OCL_OFF(cv::min(src1_roi, src2_roi, dst1_roi));
 451         OCL_ON(cv::min(usrc1_roi, usrc2_roi, udst1_roi));
 452         Near(0);
 453     }
 454 }
 455
 456 //////////////////////////////// Absdiff /////////////////////////////////////////////////
 457
 458 typedef ArithmTestBase Absdiff;
 459
 460 OCL_TEST_P(Absdiff, Mat)
 461 {
 462     for (int j = 0; j < test_loop_times; j++)
 463     {
 464         generateTestData();
 465
 466         OCL_OFF(cv::absdiff(src1_roi, src2_roi, dst1_roi));
 467         OCL_ON(cv::absdiff(usrc1_roi, usrc2_roi, udst1_roi));
 468         Near(0);
 469     }
 470 }
 471
 472 OCL_TEST_P(Absdiff, Scalar)
 473 {
 474     for (int j = 0; j < test_loop_times; j++)
 475     {
 476         generateTestData();
 477
 478         OCL_OFF(cv::absdiff(src1_roi, val, dst1_roi));
 479         OCL_ON(cv::absdiff(usrc1_roi, val, udst1_roi));
 480         Near(1e-5);
 481     }
 482 }
 483
 484 //////////////////////////////// CartToPolar /////////////////////////////////////////////////
 485
 486 typedef ArithmTestBase CartToPolar;
 487
 488 OCL_TEST_P(CartToPolar, angleInDegree)
 489 {
 490     for (int j = 0; j < test_loop_times; j++)
 491     {
 492         generateTestData();
 493
 494         OCL_OFF(cv::cartToPolar(src1_roi, src2_roi, dst1_roi, dst2_roi, true));
 495         OCL_ON(cv::cartToPolar(usrc1_roi, usrc2_roi, udst1_roi, udst2_roi, true));
 496         Near(0.5);
 497         Near1(0.5);
 498     }
 499 }
 500
 501 OCL_TEST_P(CartToPolar, angleInRadians)
 502 {
 503     for (int j = 0; j < test_loop_times; j++)
 504     {
 505         generateTestData();
 506
 507         OCL_OFF(cv::cartToPolar(src1_roi, src2_roi, dst1_roi, dst2_roi));
 508         OCL_ON(cv::cartToPolar(usrc1_roi, usrc2_roi, udst1_roi, udst2_roi));
 509         Near(0.5);
 510         Near1(0.5);
 511     }
 512 }
 513
 514 //////////////////////////////// PolarToCart /////////////////////////////////////////////////
 515
 516 typedef ArithmTestBase PolarToCart;
 517
 518 OCL_TEST_P(PolarToCart, angleInDegree)
 519 {
 520     for (int j = 0; j < test_loop_times; j++)
 521     {
 522         generateTestData();
 523
 524         OCL_OFF(cv::polarToCart(src1_roi, src2_roi, dst1_roi, dst2_roi, true));
 525         OCL_ON(cv::polarToCart(usrc1_roi, usrc2_roi, udst1_roi, udst2_roi, true));
 526
 527         Near(0.5);
 528         Near1(0.5);
 529     }
 530 }
 531
 532 OCL_TEST_P(PolarToCart, angleInRadians)
 533 {
 534     for (int j = 0; j < test_loop_times; j++)
 535     {
 536         generateTestData();
 537
 538         OCL_OFF(cv::polarToCart(src1_roi, src2_roi, dst1_roi, dst2_roi));
 539         OCL_ON(cv::polarToCart(usrc1_roi, usrc2_roi, udst1_roi, udst2_roi));
 540
 541         Near(0.5);
 542         Near1(0.5);
 543     }
 544 }
 545
 546 //////////////////////////////// Transpose /////////////////////////////////////////////////
 547
 548 typedef ArithmTestBase Transpose;
 549
 550 OCL_TEST_P(Transpose, Mat)
 551 {
 552     for (int j = 0; j < test_loop_times; j++)
 553     {
 554         generateTestData();
 555
 556         OCL_OFF(cv::transpose(src1_roi, dst1_roi));
 557         OCL_ON(cv::transpose(usrc1_roi, udst1_roi));
 558
 559         Near(1e-5);
 560     }
 561 }
 562
 563 OCL_TEST_P(Transpose, SquareInplace)
 564 {
 565     const int type = CV_MAKE_TYPE(depth, cn);
 566
 567     for (int j = 0; j < test_loop_times; j++)
 568     {
 569         Size roiSize = randomSize(1, MAX_VALUE);
 570         roiSize.height = roiSize.width; // make it square
 571
 572         Border srcBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
 573         randomSubMat(src1, src1_roi, roiSize, srcBorder, type, 5, 16);
 574
 575         UMAT_UPLOAD_OUTPUT_PARAMETER(src1);
 576
 577         OCL_OFF(cv::transpose(src1_roi, src1_roi));
 578         OCL_ON(cv::transpose(usrc1_roi, usrc1_roi));
 579
 580         OCL_EXPECT_MATS_NEAR(src1, 0)
 581     }
 582 }
 583
 584 //////////////////////////////// Bitwise_and /////////////////////////////////////////////////
 585
 586 typedef ArithmTestBase Bitwise_and;
 587
 588 OCL_TEST_P(Bitwise_and, Mat)
 589 {
 590     for (int j = 0; j < test_loop_times; j++)
 591     {
 592         generateTestData();
 593
 594         OCL_OFF(cv::bitwise_and(src1_roi, src2_roi, dst1_roi));
 595         OCL_ON(cv::bitwise_and(usrc1_roi, usrc2_roi, udst1_roi));
 596         Near(0);
 597     }
 598 }
 599
 600 OCL_TEST_P(Bitwise_and, Mat_Mask)
 601 {
 602     for (int j = 0; j < test_loop_times; j++)
 603     {
 604         generateTestData();
 605
 606         OCL_OFF(cv::bitwise_and(src1_roi, src2_roi, dst1_roi, mask_roi));
 607         OCL_ON(cv::bitwise_and(usrc1_roi, usrc2_roi, udst1_roi, umask_roi));
 608         Near(0);
 609     }
 610 }
 611
 612 OCL_TEST_P(Bitwise_and, Scalar)
 613 {
 614     for (int j = 0; j < test_loop_times; j++)
 615     {
 616         generateTestData();
 617
 618         OCL_OFF(cv::bitwise_and(src1_roi, val, dst1_roi));
 619         OCL_ON(cv::bitwise_and(usrc1_roi, val, udst1_roi));
 620         Near(1e-5);
 621     }
 622 }
 623
 624 OCL_TEST_P(Bitwise_and, Scalar_Mask)
 625 {
 626     for (int j = 0; j < test_loop_times; j++)
 627     {
 628         generateTestData();
 629
 630         OCL_OFF(cv::bitwise_and(src1_roi, val, dst1_roi, mask_roi));
 631         OCL_ON(cv::bitwise_and(usrc1_roi, val, udst1_roi, umask_roi));
 632         Near(1e-5);
 633     }
 634 }
 635
 636 //////////////////////////////// Bitwise_or /////////////////////////////////////////////////
 637
 638 typedef ArithmTestBase Bitwise_or;
 639
 640 OCL_TEST_P(Bitwise_or, Mat)
 641 {
 642     for (int j = 0; j < test_loop_times; j++)
 643     {
 644         generateTestData();
 645
 646         OCL_OFF(cv::bitwise_or(src1_roi, src2_roi, dst1_roi));
 647         OCL_ON(cv::bitwise_or(usrc1_roi, usrc2_roi, udst1_roi));
 648         Near(0);
 649     }
 650 }
 651
 652 OCL_TEST_P(Bitwise_or, Mat_Mask)
 653 {
 654     for (int j = 0; j < test_loop_times; j++)
 655     {
 656         generateTestData();
 657
 658         OCL_OFF(cv::bitwise_or(src1_roi, src2_roi, dst1_roi, mask_roi));
 659         OCL_ON(cv::bitwise_or(usrc1_roi, usrc2_roi, udst1_roi, umask_roi));
 660         Near(0);
 661     }
 662 }
 663
 664 OCL_TEST_P(Bitwise_or, Scalar)
 665 {
 666     for (int j = 0; j < test_loop_times; j++)
 667     {
 668         generateTestData();
 669
 670         OCL_OFF(cv::bitwise_or(src1_roi, val, dst1_roi));
 671         OCL_ON(cv::bitwise_or(usrc1_roi, val, udst1_roi));
 672         Near(1e-5);
 673     }
 674 }
 675
 676 OCL_TEST_P(Bitwise_or, Scalar_Mask)
 677 {
 678     for (int j = 0; j < test_loop_times; j++)
 679     {
 680         generateTestData();
 681
 682         OCL_OFF(cv::bitwise_or(src1_roi, val, dst1_roi, mask_roi));
 683         OCL_ON(cv::bitwise_or(val, usrc1_roi, udst1_roi, umask_roi));
 684         Near(1e-5);
 685     }
 686 }
 687
 688 //////////////////////////////// Bitwise_xor /////////////////////////////////////////////////
 689
 690 typedef ArithmTestBase Bitwise_xor;
 691
 692 OCL_TEST_P(Bitwise_xor, Mat)
 693 {
 694     for (int j = 0; j < test_loop_times; j++)
 695     {
 696         generateTestData();
 697
 698         OCL_OFF(cv::bitwise_xor(src1_roi, src2_roi, dst1_roi));
 699         OCL_ON(cv::bitwise_xor(usrc1_roi, usrc2_roi, udst1_roi));
 700         Near(0);
 701     }
 702 }
 703
 704 OCL_TEST_P(Bitwise_xor, Mat_Mask)
 705 {
 706     for (int j = 0; j < test_loop_times; j++)
 707     {
 708         generateTestData();
 709
 710         OCL_OFF(cv::bitwise_xor(src1_roi, src2_roi, dst1_roi, mask_roi));
 711         OCL_ON(cv::bitwise_xor(usrc1_roi, usrc2_roi, udst1_roi, umask_roi));
 712         Near(0);
 713     }
 714 }
 715
 716 OCL_TEST_P(Bitwise_xor, Scalar)
 717 {
 718     for (int j = 0; j < test_loop_times; j++)
 719     {
 720         generateTestData();
 721
 722         OCL_OFF(cv::bitwise_xor(src1_roi, val, dst1_roi));
 723         OCL_ON(cv::bitwise_xor(usrc1_roi, val, udst1_roi));
 724         Near(1e-5);
 725     }
 726 }
 727
 728 OCL_TEST_P(Bitwise_xor, Scalar_Mask)
 729 {
 730     for (int j = 0; j < test_loop_times; j++)
 731     {
 732         generateTestData();
 733
 734         OCL_OFF(cv::bitwise_xor(src1_roi, val, dst1_roi, mask_roi));
 735         OCL_ON(cv::bitwise_xor(usrc1_roi, val, udst1_roi, umask_roi));
 736         Near(1e-5);
 737     }
 738 }
 739
 740 //////////////////////////////// Bitwise_not /////////////////////////////////////////////////
 741
 742 typedef ArithmTestBase Bitwise_not;
 743
 744 OCL_TEST_P(Bitwise_not, Mat)
 745 {
 746     for (int j = 0; j < test_loop_times; j++)
 747     {
 748         generateTestData();
 749
 750         OCL_OFF(cv::bitwise_not(src1_roi, dst1_roi));
 751         OCL_ON(cv::bitwise_not(usrc1_roi, udst1_roi));
 752         Near(0);
 753     }
 754 }
 755
 756 //////////////////////////////// Compare /////////////////////////////////////////////////
 757
 758 typedef ArithmTestBase Compare;
 759
 760 static const int cmp_codes[] = { CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE };
 761 static const char* cmp_strs[] = { "CMP_EQ", "CMP_GT", "CMP_GE", "CMP_LT", "CMP_LE", "CMP_NE" };
 762 static const int cmp_num = sizeof(cmp_codes) / sizeof(int);
 763
 764 OCL_TEST_P(Compare, Mat)
 765 {
 766     for (int i = 0; i < cmp_num; ++i)
 767     {
 768         SCOPED_TRACE(cmp_strs[i]);
 769         for (int j = 0; j < test_loop_times; j++)
 770         {
 771             generateTestData();
 772
 773             OCL_OFF(cv::compare(src1_roi, src2_roi, dst1_roi, cmp_codes[i]));
 774             OCL_ON(cv::compare(usrc1_roi, usrc2_roi, udst1_roi, cmp_codes[i]));
 775
 776             Near(0);
 777         }
 778     }
 779 }
 780
 781 OCL_TEST_P(Compare, Scalar)
 782 {
 783     for (int i = 0; i < cmp_num; ++i)
 784     {
 785         SCOPED_TRACE(cmp_strs[i]);
 786         for (int j = 0; j < test_loop_times; j++)
 787         {
 788             generateTestData();
 789
 790             OCL_OFF(cv::compare(src1_roi, val_in_range, dst1_roi, cmp_codes[i]));
 791             OCL_ON(cv::compare(usrc1_roi, val_in_range, udst1_roi, cmp_codes[i]));
 792
 793             Near(0);
 794         }
 795     }
 796 }
 797
 798 OCL_TEST_P(Compare, Scalar2)
 799 {
 800     for (int i = 0; i < cmp_num; ++i)
 801     {
 802         SCOPED_TRACE(cmp_strs[i]);
 803         for (int j = 0; j < test_loop_times; j++)
 804         {
 805             generateTestData();
 806
 807             OCL_OFF(cv::compare(val_in_range, src1_roi, dst1_roi, cmp_codes[i]));
 808             OCL_ON(cv::compare(val_in_range, usrc1_roi, udst1_roi, cmp_codes[i]));
 809
 810             Near(0);
 811         }
 812     }
 813 }
 814
 815 //////////////////////////////// Pow /////////////////////////////////////////////////
 816
 817 typedef ArithmTestBase Pow;
 818
 819 OCL_TEST_P(Pow, Mat)
 820 {
 821     static const double pows[] = { -4, -1, -2.5, 0, 1, 2, 3.7, 4 };
 822
 823     for (int j = 0; j < test_loop_times; j++)
 824         for (int k = 0, size = sizeof(pows) / sizeof(double); k < size; ++k)
 825         {
 826             generateTestData();
 827
 828             OCL_OFF(cv::pow(src1_roi, pows[k], dst1_roi));
 829             OCL_ON(cv::pow(usrc1_roi, pows[k], udst1_roi));
 830
 831             Near(1);
 832         }
 833 }
 834
 835 //////////////////////////////// AddWeighted /////////////////////////////////////////////////
 836
 837 typedef ArithmTestBase AddWeighted;
 838
 839 OCL_TEST_P(AddWeighted, Mat)
 840 {
 841     for (int j = 0; j < test_loop_times; j++)
 842     {
 843         generateTestData();
 844
 845         const double alpha = 2.0, beta = 1.0, gama = 3.0;
 846
 847         OCL_OFF(cv::addWeighted(src1_roi, alpha, src2_roi, beta, gama, dst1_roi));
 848         OCL_ON(cv::addWeighted(usrc1_roi, alpha, usrc2_roi, beta, gama, udst1_roi));
 849
 850         Near(3e-4);
 851     }
 852 }
 853
 854 //////////////////////////////// setIdentity /////////////////////////////////////////////////
 855
 856 typedef ArithmTestBase SetIdentity;
 857
 858 OCL_TEST_P(SetIdentity, Mat)
 859 {
 860     for (int j = 0; j < test_loop_times; j++)
 861     {
 862         generateTestData();
 863
 864         OCL_OFF(cv::setIdentity(dst1_roi, val));
 865         OCL_ON(cv::setIdentity(udst1_roi, val));
 866
 867         Near(0);
 868     }
 869 }
 870
 871 //// Repeat
 872
 873 struct RepeatTestCase :
 874         public ArithmTestBase
 875 {
 876     int nx, ny;
 877
 878     virtual void generateTestData()
 879     {
 880         const int type = CV_MAKE_TYPE(depth, cn);
 881
 882         nx = randomInt(1, 4);
 883         ny = randomInt(1, 4);
 884
 885         Size srcRoiSize = randomSize(1, MAX_VALUE);
 886         Border srcBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
 887         randomSubMat(src1, src1_roi, srcRoiSize, srcBorder, type, 2, 11);
 888
 889         Size dstRoiSize(srcRoiSize.width * nx, srcRoiSize.height * ny);
 890         Border dst1Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
 891         randomSubMat(dst1, dst1_roi, dstRoiSize, dst1Border, type, 5, 16);
 892
 893         UMAT_UPLOAD_INPUT_PARAMETER(src1)
 894         UMAT_UPLOAD_OUTPUT_PARAMETER(dst1)
 895     }
 896 };
 897
 898 typedef RepeatTestCase Repeat;
 899
 900 OCL_TEST_P(Repeat, Mat)
 901 {
 902     for (int i = 0; i < test_loop_times; ++i)
 903     {
 904         generateTestData();
 905
 906         OCL_OFF(cv::repeat(src1_roi, ny, nx, dst1_roi));
 907         OCL_ON(cv::repeat(usrc1_roi, ny, nx, udst1_roi));
 908
 909         Near();
 910     }
 911 }
 912
 913 //////////////////////////////// CountNonZero /////////////////////////////////////////////////
 914
 915 typedef ArithmTestBase CountNonZero;
 916
 917 OCL_TEST_P(CountNonZero, MAT)
 918 {
 919     for (int j = 0; j < test_loop_times; j++)
 920     {
 921         generateTestData();
 922
 923         int cpures, gpures;
 924         OCL_OFF(cpures = cv::countNonZero(src1_roi));
 925         OCL_ON(gpures = cv::countNonZero(usrc1_roi));
 926
 927         EXPECT_EQ(cpures, gpures);
 928     }
 929 }
 930
 931 //////////////////////////////// Sum /////////////////////////////////////////////////
 932
 933 typedef ArithmTestBase Sum;
 934
 935 OCL_TEST_P(Sum, MAT)
 936 {
 937     for (int j = 0; j < test_loop_times; j++)
 938     {
 939         generateTestData();
 940
 941         Scalar cpures, gpures;
 942         OCL_OFF(cpures = cv::sum(src1_roi));
 943         OCL_ON(gpures = cv::sum(usrc1_roi));
 944
 945         for (int i = 0; i < cn; ++i)
 946             EXPECT_NEAR(cpures[i], gpures[i], 0.1);
 947     }
 948 }
 949
 950 //////////////////////////////// meanStdDev /////////////////////////////////////////////////
 951
 952 typedef ArithmTestBase MeanStdDev;
 953
 954 OCL_TEST_P(MeanStdDev, Mat)
 955 {
 956     for (int j = 0; j < test_loop_times; j++)
 957     {
 958         generateTestData();
 959
 960         Scalar cpu_mean, cpu_stddev;
 961         Scalar gpu_mean, gpu_stddev;
 962
 963         OCL_OFF(cv::meanStdDev(src1_roi, cpu_mean, cpu_stddev));
 964         OCL_ON(cv::meanStdDev(usrc1_roi, gpu_mean, gpu_stddev));
 965
 966         for (int i = 0; i < cn; ++i)
 967         {
 968             EXPECT_NEAR(cpu_mean[i], gpu_mean[i], 0.1);
 969             EXPECT_NEAR(cpu_stddev[i], gpu_stddev[i], 0.1);
 970         }
 971     }
 972 }
 973
 974 OCL_TEST_P(MeanStdDev, Mat_Mask)
 975 {
 976     for (int j = 0; j < test_loop_times; j++)
 977     {
 978         generateTestData();
 979
 980         Scalar cpu_mean, cpu_stddev;
 981         Scalar gpu_mean, gpu_stddev;
 982
 983         OCL_OFF(cv::meanStdDev(src1_roi, cpu_mean, cpu_stddev, mask_roi));
 984         OCL_ON(cv::meanStdDev(usrc1_roi, gpu_mean, gpu_stddev, umask_roi));
 985
 986         for (int i = 0; i < cn; ++i)
 987         {
 988             EXPECT_NEAR(cpu_mean[i], gpu_mean[i], 0.1);
 989             EXPECT_NEAR(cpu_stddev[i], gpu_stddev[i], 0.1);
 990         }
 991     }
 992 }
 993
 994 OCL_TEST(MeanStdDev_, ZeroMask)
 995 {
 996     Size size(5, 5);
 997     UMat um(size, CV_32SC1), umask(size, CV_8UC1, Scalar::all(0));
 998     Mat m(size, CV_32SC1), mask(size, CV_8UC1, Scalar::all(0));
 999
1000     Scalar cpu_mean, cpu_stddev;
1001     Scalar gpu_mean, gpu_stddev;
1002
1003     OCL_OFF(cv::meanStdDev(m, cpu_mean, cpu_stddev, mask));
1004     OCL_ON(cv::meanStdDev(um, gpu_mean, gpu_stddev, umask));
1005
1006     for (int i = 0; i < 4; ++i)
1007     {
1008         EXPECT_NEAR(cpu_mean[i], gpu_mean[i], 0.1);
1009         EXPECT_NEAR(cpu_stddev[i], gpu_stddev[i], 0.1);
1010     }
1011 }
1012
1013 //////////////////////////////////////// Log /////////////////////////////////////////
1014
1015 typedef ArithmTestBase Log;
1016
1017 OCL_TEST_P(Log, Mat)
1018 {
1019     for (int j = 0; j < test_loop_times; j++)
1020     {
1021         generateTestData();
1022
1023         OCL_OFF(cv::log(src1_roi, dst1_roi));
1024         OCL_ON(cv::log(usrc1_roi, udst1_roi));
1025         Near(1);
1026     }
1027 }
1028
1029 //////////////////////////////////////// Exp /////////////////////////////////////////
1030
1031 typedef ArithmTestBase Exp;
1032
1033 OCL_TEST_P(Exp, Mat)
1034 {
1035     for (int j = 0; j < test_loop_times; j++)
1036     {
1037         generateTestData();
1038
1039         OCL_OFF(cv::exp(src1_roi, dst1_roi));
1040         OCL_ON(cv::exp(usrc1_roi, udst1_roi));
1041         Near(2);
1042     }
1043 }
1044
1045 //////////////////////////////////////// Phase /////////////////////////////////////////
1046
1047 typedef ArithmTestBase Phase;
1048
1049 OCL_TEST_P(Phase, angleInDegree)
1050 {
1051     for (int j = 0; j < test_loop_times; j++)
1052     {
1053         generateTestData();
1054
1055         OCL_OFF(cv::phase(src1_roi, src2_roi, dst1_roi, true));
1056         OCL_ON(cv::phase(usrc1_roi, usrc2_roi, udst1_roi, true));
1057         Near(1e-2);
1058     }
1059 }
1060
1061 OCL_TEST_P(Phase, angleInRadians)
1062 {
1063     for (int j = 0; j < test_loop_times; j++)
1064     {
1065         generateTestData();
1066
1067         OCL_OFF(cv::phase(src1_roi, src2_roi, dst1_roi));
1068         OCL_ON(cv::phase(usrc1_roi, usrc2_roi, udst1_roi));
1069         Near(1e-2);
1070     }
1071 }
1072
1073 //////////////////////////////////////// Magnitude /////////////////////////////////////////
1074
1075 typedef ArithmTestBase Magnitude;
1076
1077 OCL_TEST_P(Magnitude, Mat)
1078 {
1079     for (int j = 0; j < test_loop_times; j++)
1080     {
1081         generateTestData();
1082
1083         OCL_OFF(cv::magnitude(src1_roi, src2_roi, dst1_roi));
1084         OCL_ON(cv::magnitude(usrc1_roi, usrc2_roi, udst1_roi));
1085         Near(depth == CV_64F ? 1e-5 : 1e-2);
1086     }
1087 }
1088
1089 //////////////////////////////// Flip /////////////////////////////////////////////////
1090
1091 typedef ArithmTestBase Flip;
1092
1093 OCL_TEST_P(Flip, X)
1094 {
1095     for (int j = 0; j < test_loop_times; j++)
1096     {
1097         generateTestData();
1098
1099         OCL_OFF(cv::flip(src1_roi, dst1_roi, 0));
1100         OCL_ON(cv::flip(usrc1_roi, udst1_roi, 0));
1101         Near(0);
1102     }
1103 }
1104
1105 OCL_TEST_P(Flip, Y)
1106 {
1107     for (int j = 0; j < test_loop_times; j++)
1108     {
1109         generateTestData();
1110
1111         OCL_OFF(cv::flip(src1_roi, dst1_roi, 1));
1112         OCL_ON(cv::flip(usrc1_roi, udst1_roi, 1));
1113         Near(0);
1114     }
1115 }
1116
1117 OCL_TEST_P(Flip, BOTH)
1118 {
1119     for (int j = 0; j < test_loop_times; j++)
1120     {
1121         generateTestData();
1122
1123         OCL_OFF(cv::flip(src1_roi, dst1_roi, -1));
1124         OCL_ON(cv::flip(usrc1_roi, udst1_roi, -1));
1125         Near(0);
1126     }
1127 }
1128 //////////////////////////////////////// minMaxIdx /////////////////////////////////////////
1129
1130 typedef ArithmTestBase MinMaxIdx;
1131
1132 OCL_TEST_P(MinMaxIdx, Mat)
1133 {
1134     for (int j = 0; j < test_loop_times; j++)
1135     {
1136         generateTestData();
1137
1138         int p1[2], p2[2], up1[2], up2[2];
1139         double minv, maxv, uminv, umaxv;
1140
1141         if(src1_roi.channels() > 1)
1142         {
1143             OCL_OFF(cv::minMaxIdx(src2_roi, &minv, &maxv) );
1144             OCL_ON(cv::minMaxIdx(usrc2_roi, &uminv, &umaxv));
1145
1146             EXPECT_DOUBLE_EQ(minv, uminv);
1147             EXPECT_DOUBLE_EQ(maxv, umaxv);
1148         }
1149         else
1150         {
1151             OCL_OFF(cv::minMaxIdx(src2_roi, &minv, &maxv, p1, p2, noArray()));
1152             OCL_ON(cv::minMaxIdx(usrc2_roi, &uminv, &umaxv, up1, up2, noArray()));
1153
1154             EXPECT_DOUBLE_EQ(minv, uminv);
1155             EXPECT_DOUBLE_EQ(maxv, umaxv);
1156             for( int i = 0; i < 2; i++)
1157             {
1158                 EXPECT_EQ(p1[i], up1[i]);
1159                 EXPECT_EQ(p2[i], up2[i]);
1160             }
1161         }
1162     }
1163 }
1164
1165 typedef ArithmTestBase MinMaxIdx_Mask;
1166
1167 OCL_TEST_P(MinMaxIdx_Mask, Mat)
1168 {
1169     for (int j = 0; j < test_loop_times; j++)
1170     {
1171         generateTestData();
1172
1173         int p1[2], p2[2], up1[2], up2[2];
1174         double minv, maxv, uminv, umaxv;
1175
1176         OCL_OFF(cv::minMaxIdx(src2_roi, &minv, &maxv, p1, p2, mask_roi));
1177         OCL_ON(cv::minMaxIdx(usrc2_roi, &uminv, &umaxv, up1, up2, umask_roi));
1178
1179         EXPECT_DOUBLE_EQ(minv, uminv);
1180         EXPECT_DOUBLE_EQ(maxv, umaxv);
1181         for( int i = 0; i < 2; i++)
1182         {
1183             EXPECT_EQ(p1[i], up1[i]);
1184             EXPECT_EQ(p2[i], up2[i]);
1185         }
1186
1187     }
1188 }
1189
1190 //////////////////////////////// Norm /////////////////////////////////////////////////
1191
1192 static bool relativeError(double actual, double expected, double eps)
1193 {
1194     return std::abs(actual - expected) / actual < eps;
1195 }
1196
1197 typedef ArithmTestBase Norm;
1198
1199 OCL_TEST_P(Norm, NORM_INF_1arg)
1200 {
1201     for (int j = 0; j < test_loop_times; j++)
1202     {
1203         generateTestData();
1204
1205         OCL_OFF(const double cpuRes = cv::norm(src1_roi, NORM_INF));
1206         OCL_ON(const double gpuRes = cv::norm(usrc1_roi, NORM_INF));
1207
1208         EXPECT_NEAR(cpuRes, gpuRes, 0.1);
1209     }
1210 }
1211
1212 OCL_TEST_P(Norm, NORM_INF_1arg_mask)
1213 {
1214     for (int j = 0; j < test_loop_times; j++)
1215     {
1216         generateTestData();
1217
1218         OCL_OFF(const double cpuRes = cv::norm(src1_roi, NORM_INF, mask_roi));
1219         OCL_ON(const double gpuRes = cv::norm(usrc1_roi, NORM_INF, umask_roi));
1220
1221         EXPECT_NEAR(cpuRes, gpuRes, 0.1);
1222     }
1223 }
1224
1225 OCL_TEST_P(Norm, NORM_L1_1arg)
1226 {
1227     for (int j = 0; j < test_loop_times; j++)
1228     {
1229         generateTestData();
1230
1231         OCL_OFF(const double cpuRes = cv::norm(src1_roi, NORM_L1));
1232         OCL_ON(const double gpuRes = cv::norm(usrc1_roi, NORM_L1));
1233
1234         EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1235     }
1236 }
1237
1238 OCL_TEST_P(Norm, NORM_L1_1arg_mask)
1239 {
1240     for (int j = 0; j < test_loop_times; j++)
1241     {
1242         generateTestData();
1243
1244         OCL_OFF(const double cpuRes = cv::norm(src1_roi, NORM_L1, mask_roi));
1245         OCL_ON(const double gpuRes = cv::norm(usrc1_roi, NORM_L1, umask_roi));
1246
1247         EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1248     }
1249 }
1250
1251 OCL_TEST_P(Norm, NORM_L2_1arg)
1252 {
1253     for (int j = 0; j < test_loop_times; j++)
1254     {
1255         generateTestData();
1256
1257         OCL_OFF(const double cpuRes = cv::norm(src1_roi, NORM_L2));
1258         OCL_ON(const double gpuRes = cv::norm(usrc1_roi, NORM_L2));
1259
1260         EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1261     }
1262 }
1263
1264 OCL_TEST_P(Norm, NORM_L2_1arg_mask)
1265 {
1266     for (int j = 0; j < test_loop_times; j++)
1267     {
1268         generateTestData();
1269
1270         OCL_OFF(const double cpuRes = cv::norm(src1_roi, NORM_L2, mask_roi));
1271         OCL_ON(const double gpuRes = cv::norm(usrc1_roi, NORM_L2, umask_roi));
1272
1273         EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1274     }
1275 }
1276
1277 OCL_TEST_P(Norm, NORM_INF_2args)
1278 {
1279     for (int relative = 0; relative < 2; ++relative)
1280         for (int j = 0; j < test_loop_times; j++)
1281         {
1282             generateTestData();
1283
1284             int type = NORM_INF;
1285             if (relative == 1)
1286                 type |= NORM_RELATIVE;
1287
1288             OCL_OFF(const double cpuRes = cv::norm(src1_roi, src2_roi, type));
1289             OCL_ON(const double gpuRes = cv::norm(usrc1_roi, usrc2_roi, type));
1290
1291             EXPECT_NEAR(cpuRes, gpuRes, 0.1);
1292         }
1293 }
1294
1295 OCL_TEST_P(Norm, NORM_INF_2args_mask)
1296 {
1297     for (int relative = 0; relative < 2; ++relative)
1298         for (int j = 0; j < test_loop_times; j++)
1299         {
1300             generateTestData();
1301
1302             int type = NORM_INF;
1303             if (relative == 1)
1304                 type |= NORM_RELATIVE;
1305
1306             OCL_OFF(const double cpuRes = cv::norm(src1_roi, src2_roi, type, mask_roi));
1307             OCL_ON(const double gpuRes = cv::norm(usrc1_roi, usrc2_roi, type, umask_roi));
1308
1309             EXPECT_NEAR(cpuRes, gpuRes, 0.1);
1310         }
1311 }
1312
1313 OCL_TEST_P(Norm, NORM_L1_2args)
1314 {
1315     for (int relative = 0; relative < 2; ++relative)
1316         for (int j = 0; j < test_loop_times; j++)
1317         {
1318             generateTestData();
1319
1320             int type = NORM_L1;
1321             if (relative == 1)
1322                 type |= NORM_RELATIVE;
1323
1324             OCL_OFF(const double cpuRes = cv::norm(src1_roi, src2_roi, type));
1325             OCL_ON(const double gpuRes = cv::norm(usrc1_roi, usrc2_roi, type));
1326
1327             EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1328         }
1329 }
1330
1331 OCL_TEST_P(Norm, NORM_L1_2args_mask)
1332 {
1333     for (int relative = 0; relative < 2; ++relative)
1334         for (int j = 0; j < test_loop_times; j++)
1335         {
1336             generateTestData();
1337
1338             int type = NORM_L1;
1339             if (relative == 1)
1340                 type |= NORM_RELATIVE;
1341
1342             OCL_OFF(const double cpuRes = cv::norm(src1_roi, src2_roi, type, mask_roi));
1343             OCL_ON(const double gpuRes = cv::norm(usrc1_roi, usrc2_roi, type, umask_roi));
1344
1345             EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1346         }
1347 }
1348
1349 OCL_TEST_P(Norm, NORM_L2_2args)
1350 {
1351     for (int relative = 0; relative < 2; ++relative)
1352         for (int j = 0; j < test_loop_times; j++)
1353         {
1354             generateTestData();
1355
1356             int type = NORM_L2;
1357             if (relative == 1)
1358                 type |= NORM_RELATIVE;
1359
1360             OCL_OFF(const double cpuRes = cv::norm(src1_roi, src2_roi, type));
1361             OCL_ON(const double gpuRes = cv::norm(usrc1_roi, usrc2_roi, type));
1362
1363             EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1364         }
1365 }
1366
1367 OCL_TEST_P(Norm, NORM_L2_2args_mask)
1368 {
1369     for (int relative = 0; relative < 2; ++relative)
1370         for (int j = 0; j < test_loop_times; j++)
1371         {
1372             generateTestData();
1373
1374             int type = NORM_L2;
1375             if (relative == 1)
1376                 type |= NORM_RELATIVE;
1377
1378             OCL_OFF(const double cpuRes = cv::norm(src1_roi, src2_roi, type, mask_roi));
1379             OCL_ON(const double gpuRes = cv::norm(usrc1_roi, usrc2_roi, type, umask_roi));
1380
1381             EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1382         }
1383 }
1384
1385 //////////////////////////////// UMat::dot ////////////////////////////////////////////////
1386
1387 typedef ArithmTestBase UMatDot;
1388
1389 OCL_TEST_P(UMatDot, Mat)
1390 {
1391     for (int j = 0; j < test_loop_times; j++)
1392     {
1393         generateTestData();
1394
1395         OCL_OFF(const double cpuRes = src1_roi.dot(src2_roi));
1396         OCL_ON(const double gpuRes = usrc1_roi.dot(usrc2_roi));
1397
1398         EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1399     }
1400 }
1401
1402 //////////////////////////////// Sqrt ////////////////////////////////////////////////
1403
1404 typedef ArithmTestBase Sqrt;
1405
1406 OCL_TEST_P(Sqrt, Mat)
1407 {
1408     for (int j = 0; j < test_loop_times; j++)
1409     {
1410         generateTestData();
1411
1412         OCL_OFF(cv::sqrt(src1_roi, dst1_roi));
1413         OCL_ON(cv::sqrt(usrc1_roi, udst1_roi));
1414
1415         Near(1);
1416     }
1417 }
1418
1419 //////////////////////////////// Normalize ////////////////////////////////////////////////
1420
1421 typedef ArithmTestBase Normalize;
1422
1423 OCL_TEST_P(Normalize, Mat)
1424 {
1425     static int modes[] = { CV_MINMAX, CV_L2, CV_L1, CV_C };
1426
1427     for (int j = 0; j < test_loop_times; j++)
1428     {
1429         generateTestData();
1430
1431         for (int i = 0, size = sizeof(modes) / sizeof(modes[0]); i < size; ++i)
1432         {
1433             OCL_OFF(cv::normalize(src1_roi, dst1_roi, 10, 110, modes[i], src1_roi.type(), mask_roi));
1434             OCL_ON(cv::normalize(usrc1_roi, udst1_roi, 10, 110, modes[i], src1_roi.type(), umask_roi));
1435
1436             Near(1);
1437         }
1438     }
1439 }
1440
1441 //////////////////////////////////////// InRange ///////////////////////////////////////////////
1442
1443 PARAM_TEST_CASE(InRange, MatDepth, Channels, bool /*Scalar or not*/, bool /*Roi*/)
1444 {
1445     int depth;
1446     int cn;
1447     bool scalars, use_roi;
1448     cv::Scalar val1, val2;
1449
1450     TEST_DECLARE_INPUT_PARAMETER(src1)
1451     TEST_DECLARE_INPUT_PARAMETER(src2)
1452     TEST_DECLARE_INPUT_PARAMETER(src3)
1453     TEST_DECLARE_OUTPUT_PARAMETER(dst)
1454
1455     virtual void SetUp()
1456     {
1457         depth = GET_PARAM(0);
1458         cn = GET_PARAM(1);
1459         scalars = GET_PARAM(2);
1460         use_roi = GET_PARAM(3);
1461     }
1462
1463     virtual void generateTestData()
1464     {
1465         const int type = CV_MAKE_TYPE(depth, cn);
1466
1467         Size roiSize = randomSize(1, MAX_VALUE);
1468         Border src1Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
1469         randomSubMat(src1, src1_roi, roiSize, src1Border, type, -40, 40);
1470
1471         Border src2Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
1472         randomSubMat(src2, src2_roi, roiSize, src2Border, type, -40, 40);
1473
1474         Border src3Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
1475         randomSubMat(src3, src3_roi, roiSize, src3Border, type, -40, 40);
1476
1477         Border dstBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
1478         randomSubMat(dst, dst_roi, roiSize, dstBorder, CV_8UC1, 5, 16);
1479
1480         val1 = cv::Scalar(rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0),
1481                           rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0));
1482         val2 = cv::Scalar(rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0),
1483                           rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0));
1484
1485         UMAT_UPLOAD_INPUT_PARAMETER(src1)
1486         UMAT_UPLOAD_INPUT_PARAMETER(src2)
1487         UMAT_UPLOAD_INPUT_PARAMETER(src3)
1488         UMAT_UPLOAD_OUTPUT_PARAMETER(dst)
1489     }
1490
1491     void Near()
1492     {
1493         OCL_EXPECT_MATS_NEAR(dst, 0)
1494     }
1495 };
1496
1497 OCL_TEST_P(InRange, Mat)
1498 {
1499     for (int j = 0; j < test_loop_times; j++)
1500     {
1501         generateTestData();
1502
1503         OCL_OFF(cv::inRange(src1_roi, src2_roi, src3_roi, dst_roi));
1504         OCL_ON(cv::inRange(usrc1_roi, usrc2_roi, usrc3_roi, udst_roi));
1505
1506         Near();
1507     }
1508 }
1509
1510 OCL_TEST_P(InRange, Scalar)
1511 {
1512     for (int j = 0; j < test_loop_times; j++)
1513     {
1514         generateTestData();
1515
1516         OCL_OFF(cv::inRange(src1_roi, val1, val2, dst_roi));
1517         OCL_ON(cv::inRange(usrc1_roi, val1, val2, udst_roi));
1518
1519         Near();
1520     }
1521 }
1522
1523 //////////////////////////////// ConvertScaleAbs ////////////////////////////////////////////////
1524
1525 typedef ArithmTestBase ConvertScaleAbs;
1526
1527 OCL_TEST_P(ConvertScaleAbs, Mat)
1528 {
1529     for (int j = 0; j < test_loop_times; j++)
1530     {
1531         generateTestData();
1532
1533         OCL_OFF(cv::convertScaleAbs(src1_roi, dst1_roi, val[0], val[1]));
1534         OCL_ON(cv::convertScaleAbs(usrc1_roi, udst1_roi, val[0], val[1]));
1535
1536         Near(depth <= CV_32S ? 1 : 1e-6);
1537     }
1538 }
1539
1540 //////////////////////////////// ScaleAdd ////////////////////////////////////////////////
1541
1542 typedef ArithmTestBase ScaleAdd;
1543
1544 OCL_TEST_P(ScaleAdd, Mat)
1545 {
1546     for (int j = 0; j < test_loop_times; j++)
1547     {
1548         generateTestData();
1549
1550         OCL_OFF(cv::scaleAdd(src1_roi, val[0], src2_roi, dst1_roi));
1551         OCL_ON(cv::scaleAdd(usrc1_roi, val[0], usrc2_roi, udst1_roi));
1552
1553         Near(depth <= CV_32S ? 1 : 1e-3);
1554     }
1555 }
1556
1557 //////////////////////////////// PatchNans ////////////////////////////////////////////////
1558
1559 PARAM_TEST_CASE(PatchNaNs, Channels, bool)
1560 {
1561     int cn;
1562     bool use_roi;
1563     double value;
1564
1565     TEST_DECLARE_INPUT_PARAMETER(src)
1566
1567     virtual void SetUp()
1568     {
1569         cn = GET_PARAM(0);
1570         use_roi = GET_PARAM(1);
1571     }
1572
1573     virtual void generateTestData()
1574     {
1575         const int type = CV_MAKE_TYPE(CV_32F, cn);
1576
1577         Size roiSize = randomSize(1, 10);
1578         Border srcBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
1579         randomSubMat(src, src_roi, roiSize, srcBorder, type, -40, 40);
1580
1581         // generating NaNs
1582         roiSize.width *= cn;
1583         for (int y = 0; y < roiSize.height; ++y)
1584         {
1585             float * const ptr = src_roi.ptr<float>(y);
1586             for (int x = 0; x < roiSize.width; ++x)
1587                 ptr[x] = randomInt(-1, 1) == 0 ? std::numeric_limits<float>::quiet_NaN() : ptr[x];
1588         }
1589
1590         value = randomDouble(-100, 100);
1591
1592         UMAT_UPLOAD_INPUT_PARAMETER(src)
1593     }
1594
1595     void Near()
1596     {
1597         OCL_EXPECT_MATS_NEAR(src, 0)
1598     }
1599 };
1600
1601 OCL_TEST_P(PatchNaNs, Mat)
1602 {
1603     for (int j = 0; j < test_loop_times; j++)
1604     {
1605         generateTestData();
1606
1607         OCL_OFF(cv::patchNaNs(src_roi, value));
1608         OCL_ON(cv::patchNaNs(usrc_roi, value));
1609
1610         Near();
1611     }
1612 }
1613
1614 //////////////////////////////// Psnr ////////////////////////////////////////////////
1615
1616 typedef ArithmTestBase Psnr;
1617
1618 OCL_TEST_P(Psnr, Mat)
1619 {
1620     for (int j = 0; j < test_loop_times; j++)
1621     {
1622         generateTestData();
1623
1624         double cpuRes = 0, gpuRes = 0;
1625
1626         OCL_OFF(cpuRes = cv::PSNR(src1_roi, src2_roi));
1627         OCL_ON(gpuRes = cv::PSNR(usrc1_roi, usrc2_roi));
1628
1629         EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
1630     }
1631 }
1632
1633 //////////////////////////////////////// Reduce /////////////////////////////////////////////
1634
1635 PARAM_TEST_CASE(Reduce, std::pair<MatDepth, MatDepth>, Channels, int, bool)
1636 {
1637     int sdepth, ddepth, cn, dim, dtype;
1638     bool use_roi;
1639
1640     TEST_DECLARE_INPUT_PARAMETER(src)
1641     TEST_DECLARE_OUTPUT_PARAMETER(dst)
1642
1643     virtual void SetUp()
1644     {
1645         const std::pair<MatDepth, MatDepth> p = GET_PARAM(0);
1646         sdepth = p.first;
1647         ddepth = p.second;
1648         cn = GET_PARAM(1);
1649         dim = GET_PARAM(2);
1650         use_roi = GET_PARAM(3);
1651     }
1652
1653     virtual void generateTestData()
1654     {
1655         const int stype = CV_MAKE_TYPE(sdepth, cn);
1656         dtype = CV_MAKE_TYPE(ddepth, cn);
1657
1658         Size roiSize = randomSize(1, MAX_VALUE);
1659         Border srcBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
1660         randomSubMat(src, src_roi, roiSize, srcBorder, stype, -40, 40);
1661
1662         Size dstRoiSize = Size(dim == 0 ? roiSize.width : 1, dim == 0 ? 1 : roiSize.height);
1663         Border dstBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
1664         randomSubMat(dst, dst_roi, dstRoiSize, dstBorder, dtype, 5, 16);
1665
1666         UMAT_UPLOAD_INPUT_PARAMETER(src)
1667         UMAT_UPLOAD_OUTPUT_PARAMETER(dst)
1668     }
1669 };
1670
1671 typedef Reduce ReduceSum;
1672
1673 OCL_TEST_P(ReduceSum, Mat)
1674 {
1675     for (int j = 0; j < test_loop_times; j++)
1676     {
1677         generateTestData();
1678
1679         OCL_OFF(cv::reduce(src_roi, dst_roi, dim, CV_REDUCE_SUM, dtype));
1680         OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, CV_REDUCE_SUM, dtype));
1681
1682         double eps = ddepth <= CV_32S ? 1 : 1e-4;
1683         OCL_EXPECT_MATS_NEAR(dst, eps)
1684     }
1685 }
1686
1687 typedef Reduce ReduceMax;
1688
1689 OCL_TEST_P(ReduceMax, Mat)
1690 {
1691     for (int j = 0; j < test_loop_times; j++)
1692     {
1693         generateTestData();
1694
1695         OCL_OFF(cv::reduce(src_roi, dst_roi, dim, CV_REDUCE_MAX, dtype));
1696         OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, CV_REDUCE_MAX, dtype));
1697
1698         OCL_EXPECT_MATS_NEAR(dst, 0)
1699     }
1700 }
1701
1702 typedef Reduce ReduceMin;
1703
1704 OCL_TEST_P(ReduceMin, Mat)
1705 {
1706     for (int j = 0; j < test_loop_times; j++)
1707     {
1708         generateTestData();
1709
1710         OCL_OFF(cv::reduce(src_roi, dst_roi, dim, CV_REDUCE_MIN, dtype));
1711         OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, CV_REDUCE_MIN, dtype));
1712
1713         OCL_EXPECT_MATS_NEAR(dst, 0)
1714     }
1715 }
1716
1717 typedef Reduce ReduceAvg;
1718
1719 OCL_TEST_P(ReduceAvg, Mat)
1720 {
1721     for (int j = 0; j < test_loop_times; j++)
1722     {
1723         generateTestData();
1724
1725         OCL_OFF(cv::reduce(src_roi, dst_roi, dim, CV_REDUCE_AVG, dtype));
1726         OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, CV_REDUCE_AVG, dtype));
1727
1728         double eps = ddepth <= CV_32S ? 1 : 5e-6;
1729         OCL_EXPECT_MATS_NEAR(dst, eps)
1730     }
1731 }
1732
1733 //////////////////////////////////////// Instantiation /////////////////////////////////////////
1734
1735 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Lut, Combine(::testing::Values(CV_8U, CV_8S), OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool(), Bool()));
1736 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Add, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1737 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Subtract, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1738 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Mul, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1739 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Div, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1740 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Min, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1741 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Max, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1742 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Absdiff, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1743 OCL_INSTANTIATE_TEST_CASE_P(Arithm, CartToPolar, Combine(testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1744 OCL_INSTANTIATE_TEST_CASE_P(Arithm, PolarToCart, Combine(testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1745 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Transpose, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1746 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_and, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1747 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_not, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1748 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_xor, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1749 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Bitwise_or, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1750 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Pow, Combine(testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1751 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Compare, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1752 OCL_INSTANTIATE_TEST_CASE_P(Arithm, AddWeighted, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1753 OCL_INSTANTIATE_TEST_CASE_P(Arithm, SetIdentity, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1754 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Repeat, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1755 OCL_INSTANTIATE_TEST_CASE_P(Arithm, CountNonZero, Combine(OCL_ALL_DEPTHS, testing::Values(Channels(1)), Bool()));
1756 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Sum, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1757 OCL_INSTANTIATE_TEST_CASE_P(Arithm, MeanStdDev, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1758 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Log, Combine(::testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1759 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Exp, Combine(::testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1760 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Phase, Combine(::testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1761 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Magnitude, Combine(::testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1762 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Flip, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1763 OCL_INSTANTIATE_TEST_CASE_P(Arithm, MinMaxIdx, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1764 OCL_INSTANTIATE_TEST_CASE_P(Arithm, MinMaxIdx_Mask, Combine(OCL_ALL_DEPTHS, ::testing::Values(Channels(1)), Bool()));
1765 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Norm, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1766 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Sqrt, Combine(::testing::Values(CV_32F, CV_64F), OCL_ALL_CHANNELS, Bool()));
1767 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Normalize, Combine(OCL_ALL_DEPTHS, Values(Channels(1)), Bool()));
1768 OCL_INSTANTIATE_TEST_CASE_P(Arithm, InRange, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool(), Bool()));
1769 OCL_INSTANTIATE_TEST_CASE_P(Arithm, ConvertScaleAbs, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1770 OCL_INSTANTIATE_TEST_CASE_P(Arithm, ScaleAdd, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1771 OCL_INSTANTIATE_TEST_CASE_P(Arithm, PatchNaNs, Combine(OCL_ALL_CHANNELS, Bool()));
1772 OCL_INSTANTIATE_TEST_CASE_P(Arithm, Psnr, Combine(::testing::Values((MatDepth)CV_8U), OCL_ALL_CHANNELS, Bool()));
1773 OCL_INSTANTIATE_TEST_CASE_P(Arithm, UMatDot, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
1774
1775 OCL_INSTANTIATE_TEST_CASE_P(Arithm, ReduceSum, Combine(testing::Values(std::make_pair<MatDepth, MatDepth>(CV_8U, CV_32S),
1776                                                                        std::make_pair<MatDepth, MatDepth>(CV_8U, CV_32F),
1777                                                                        std::make_pair<MatDepth, MatDepth>(CV_8U, CV_64F),
1778                                                                        std::make_pair<MatDepth, MatDepth>(CV_16U, CV_32F),
1779                                                                        std::make_pair<MatDepth, MatDepth>(CV_16U, CV_64F),
1780                                                                        std::make_pair<MatDepth, MatDepth>(CV_16S, CV_32F),
1781                                                                        std::make_pair<MatDepth, MatDepth>(CV_16S, CV_64F),
1782                                                                        std::make_pair<MatDepth, MatDepth>(CV_32F, CV_32F),
1783                                                                        std::make_pair<MatDepth, MatDepth>(CV_32F, CV_64F),
1784                                                                        std::make_pair<MatDepth, MatDepth>(CV_64F, CV_64F)),
1785                                                        OCL_ALL_CHANNELS, testing::Values(0, 1), Bool()));
1786 OCL_INSTANTIATE_TEST_CASE_P(Arithm, ReduceAvg, Combine(testing::Values(std::make_pair<MatDepth, MatDepth>(CV_8U, CV_32S),
1787                                                                        std::make_pair<MatDepth, MatDepth>(CV_8U, CV_32F),
1788                                                                        std::make_pair<MatDepth, MatDepth>(CV_8U, CV_64F),
1789                                                                        std::make_pair<MatDepth, MatDepth>(CV_16U, CV_32F),
1790                                                                        std::make_pair<MatDepth, MatDepth>(CV_16U, CV_64F),
1791                                                                        std::make_pair<MatDepth, MatDepth>(CV_16S, CV_32F),
1792                                                                        std::make_pair<MatDepth, MatDepth>(CV_16S, CV_64F),
1793                                                                        std::make_pair<MatDepth, MatDepth>(CV_32F, CV_32F),
1794                                                                        std::make_pair<MatDepth, MatDepth>(CV_32F, CV_64F),
1795                                                                        std::make_pair<MatDepth, MatDepth>(CV_64F, CV_64F)),
1796                                                        OCL_ALL_CHANNELS, testing::Values(0, 1), Bool()));
1797 OCL_INSTANTIATE_TEST_CASE_P(Arithm, ReduceMax, Combine(testing::Values(std::make_pair<MatDepth, MatDepth>(CV_8U, CV_8U),
1798                                                                        std::make_pair<MatDepth, MatDepth>(CV_16U, CV_16U),
1799                                                                        std::make_pair<MatDepth, MatDepth>(CV_16S, CV_16S),
1800                                                                        std::make_pair<MatDepth, MatDepth>(CV_32F, CV_32F),
1801                                                                        std::make_pair<MatDepth, MatDepth>(CV_64F, CV_64F)),
1802                                                        OCL_ALL_CHANNELS, testing::Values(0, 1), Bool()));
1803 OCL_INSTANTIATE_TEST_CASE_P(Arithm, ReduceMin, Combine(testing::Values(std::make_pair<MatDepth, MatDepth>(CV_8U, CV_8U),
1804                                                                        std::make_pair<MatDepth, MatDepth>(CV_16U, CV_16U),
1805                                                                        std::make_pair<MatDepth, MatDepth>(CV_16S, CV_16S),
1806                                                                        std::make_pair<MatDepth, MatDepth>(CV_32F, CV_32F),
1807                                                                        std::make_pair<MatDepth, MatDepth>(CV_64F, CV_64F)),
1808                                                        OCL_ALL_CHANNELS, testing::Values(0, 1), Bool()));
1809
1810
1811 } } // namespace cvtest::ocl
1812
1813 #endif // HAVE_OPENCL